prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
from distanceclosure.distance import pairwise_proximity, _jaccard_coef_scipy, _jaccard_coef_binary, _jaccard_coef_set, _jaccard_coef_weighted_numpy
import numpy as np
from scipy.sparse import csr_matrix
B = np.array([
[1, 1, 1, 1],
[1, 1, 1, 0],
[1, 1, 0, 0],
[1, 0, 0, 0],
])
N = np.array([
[2, 3, 4, 2],
[2, 3, 4, 2],
[2, 3, 3, 2],
[2, 1, 3, 4]
])
W = np.array([
[4, 3, 2, 1],
[3, 2, 1, 0],
[2, 1, 0, 0],
[1, 0, 0, 0],
])
def test_jaccard_scipy():
""" Test Jaccard: scipy.spatial.dist.jaccard """
u = np.array([2, 3, 4, 5])
v = np.array([2, 3, 4, 2])
d = _jaccard_coef_scipy(u, v, min_support=1)
assert (d == 0.75)
def test_jaccard_binary():
""" Test Jaccard: binary (bitwise) coef """
u = np.array([1, 1, 1, 1])
v = np.array([1, 1, 1, 0])
d = _jaccard_coef_binary(u, v, min_support=1)
assert (d == 0.75)
def test_jaccard_set():
""" Test Jaccard: set coef """
u = np.array([4, 3, 2, 1])
v = np.array([3, 2, 1, 0])
d = _jaccard_coef_set(u, v, min_support=1)
assert (d == 0.6)
def test_jaccard_weighted():
""" Test Jaccard: weighted coef """
u = np.array([4, 3, 2, 1])
v = np.array([3, 2, 1, 0])
d = _jaccard_coef_weighted_numpy(u, v, min_support=1)
assert (d == 0.6)
def test_pairwise_distance_numpy_scipy():
""" Test pairwise distance: using the Numpy (dense matrix) implemmentation for numer jaccard (scipy) coef """
D = pairwise_proximity(N, metric='jaccard')
true = np.array([
[1., 1., 0.75, 0.25],
[1., 1., 0.75, 0.25],
[0.75, 0.75, 1., 0.5],
[0.25, 0.25, 0.5, 1.]], dtype=float)
assert np.isclose(D, true). all()
def test_pairwise_distance_numpy_binary():
""" Test pairwise distance: using the Numpy (dense matrix) implementation for jaccard binary coef """
D = pairwise_proximity(B, metric='jaccard_binary', min_support=1, verbose=True)
true = np.array([
[1., 0.75, 0.5, 0.25],
[0.75, 1., 0.66666667, 0.33333333],
[0.5, 0.66666667, 1., 0.5],
[0.25, 0.33333333, 0.5, 1.]], dtype=float)
assert np.isclose(D, true).all()
def test_pairwise_distance_numpy_set():
""" Test pairwise distance: using the Numpy (dense matrix) implementation for jaccard set coef """
D = pairwise_proximity(W, metric='jaccard_set', min_support=1)
true = np.array([
[1., 0.6, 0.4, 0.2],
[0.6, 1., 0.75, 0.5],
[0.4, 0.75, 1., 0.66666667],
[0.2, 0.5, 0.66666667, 1.]], dtype=float)
assert np.isclose(D, true).all()
def test_pairwise_distance_numpy_weighted():
""" Test pairwise distance: using Numpy (dense matrix) using weighted jaccard """
D = pairwise_proximity(W, metric='weighted_jaccard', min_support=10)
true = np.array([
[1., 0.6, 0.3, 0.1],
[0.6, 1., 0., 0.],
[0.3, 0., 1., 0.],
[0.1, 0., 0., 1.]], dtype=float)
assert np.isclose(D, true).all()
def test_pairwise_distance_sparse_scipy():
""" Test pairwise distance: using the Scipy (sparse matrix) implemmentation for jaccard scipy coef """
N_sparse = csr_matrix(N)
D = pairwise_proximity(N_sparse, metric='jaccard', min_support=1)
true = np.array([
[1., 1., 0.75, 0.25],
[1., 1., 0.75, 0.25],
[0.75, 0.75, 1., 0.5],
[0.25, 0.25, 0.5, 1.]], dtype=float)
assert np.isclose(D.todense(), true). all()
def test_pairwise_distance_sparse_binary():
""" Test pairwise distance: using the Scipy (sparse matrix) implementation for jaccard bitwise coef """
B_sparse = csr_matrix(B)
D = pairwise_proximity(B_sparse, metric='jaccard_binary', min_support=1)
true = np.array([
[1., 0.75, 0.5, 0.25],
[0.75, 1., 0.66666667, 0.33333333],
[0.5, 0.66666667, 1., 0.5],
[0.25, 0.33333333, 0.5, 1.]], dtype=float)
assert np.isclose(D.todense(), true).all()
def test_pairwise_distance_sparse_set():
""" Test pairwise distance: using the Scipy (sparse matrix) implementation for jaccard set coef """
W_sparse = csr_matrix(W)
D = pairwise_proximity(W_sparse, metric='jaccard_set', min_support=1)
true = np.array([
[1., 0.75, 0.5, 0.25],
[0.75, 1., 0.66666667, 0.33333333],
[0.5, 0.66666667, 1., 0.5],
[0.25, 0.33333333, 0.5, 1.]], dtype=float)
assert np.isclose(D.todense(), true).all()
def test_pairwise_distance_sparse_weighted():
""" Test pairwise distance: using the Scipy (sparse matrix) implementation for jaccard weighted coef """
W_sparse = csr_matrix(W)
D = pairwise_proximity(W_sparse, metric='jaccard_weighted', min_support=1)
true = np.array([
[1., 0.6, 0.3, 0.1],
[0.6, 1., 0., 0.],
[0.3, 0., 1., 0.],
[0.1, 0., 0., 1.]], dtype=float)
assert np.isclose(D.todense(), true).all()
def test_pairwise_distance_dense_my_own_metric():
""" Test pairwise distance: using the numpy (dense matrix) implementation and my own metric function """
def my_coef(u, v):
return 0.25
D = pairwise_proximity(W, metric=my_coef, verbose=True)
true = np.array([
[1., .25, .25, .25],
[.25, 1., .25, .25],
[.25, .25, 1., .25],
[.25, .25, .25, 1.]], dtype=float)
assert | np.isclose(D, true) | numpy.isclose |
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
def sigmoid(z):
return 1 / (1 + np.exp(-z))
def forward_propagates(X, theta):
a = []
z = []
a.append(X) # a[0].shape = (m, n)
for i in range(len(theta)):
a[i] = np.insert(a[i], 0, values=1, axis=1) # a[0].shape = (m, n+1 or hidden_units + 1)
z.append(np.dot(a[i], theta[i].T)) # z.shape = (m, hidden_units or outputs)
a.append(sigmoid(z[-1])) # a.shape = (m, hidden_units or outputs)
return z, a
def cost(params, input_size, hidden_size, num_labels, X, y, regularization):
m = len(X)
# reshape the parameter array into parameter matrices for each layer
theta1 = np.reshape(params[:hidden_size * (input_size + 1)], (hidden_size, (input_size + 1)))
theta2 = np.reshape(params[hidden_size * (input_size + 1):], (num_labels, (hidden_size + 1)))
z, a = forward_propagates(X, [theta1, theta2])
# compute the cost
first_term = (-y) * np.log(a[-1])
second_term = - (1 - y) * np.log(1 - a[-1])
J = np.sum(first_term + second_term) / m
# add the regularization cost term
J += regularization / (2 * m) * (np.sum(np.power(z[0], 2)) + np.sum(np.power(z[1], 2)))
return J
def sigmoid_gradient(z):
return sigmoid(z) * (1 - sigmoid(z))
def backprop(params, input_size, hidden_size, num_labels, X, y, regularization):
m = len(X)
# reshape the parameter array into parameter matrices for each layer
theta1 = np.reshape(params[:hidden_size * (input_size + 1)], (hidden_size, (input_size + 1)))
theta2 = np.reshape(params[hidden_size * (input_size + 1):], (num_labels, (hidden_size + 1)))
# initializations
delta1 = np.zeros(theta1.shape) # (25, 401)
delta2 = np.zeros(theta2.shape) # (10, 26)
z, a = forward_propagates(X, [theta1, theta2])
# compute the cost
first_term = (-y) * np.log(a[-1])
second_term = - (1 - y) * np.log(1 - a[-1])
J = | np.sum(first_term + second_term) | numpy.sum |
"""
Container objects for working with geometric information
"""
import numpy as np
class Polygon:
type = 'Polygon'
shapeType = 5 # pyshp
def __init__(self, exterior, interiors=None):
"""Container for housing and describing polygon geometries
(e.g. to be read or written to shapefiles or other geographic data formats)
Parameters
----------
exterior : sequence
Sequence of coordinates describing the outer ring of the polygon.
interiors : sequence of sequences
Describes one or more holes within the polygon
Attributes
----------
exterior : (x, y, z) coordinates of exterior
interiors : tuple of (x, y, z) coordinates of each interior polygon
patch : descartes.PolygonPatch representation
bounds : (xmin, ymin, xmax, ymax)
Tuple describing bounding box for polygon
geojson : dict
Returns a geojson representation of the feature
pyshp_parts : list of lists
Returns a list of all parts (each an individual polygon).
Can be used as input for the shapefile.Writer.poly method (pyshp package)
Methods
-------
get_patch
Returns a descartes PolygonPatch object representation of the polygon.
Accepts keyword arguments to descartes.PolygonPatch. Requires the
descartes package (pip install descartes).
plot
Plots the feature using descartes (via get_patch) and matplotlib.pyplot.
Accepts keyword arguments to descartes.PolygonPatch. Requires the
descartes package (pip install descartes).
Notes
-----
Multi-polygons not yet supported.
z information is only stored if it was entered.
"""
self.exterior = tuple(map(tuple, exterior))
self.interiors = tuple() if interiors is None else (map(tuple, i) for i in interiors)
def __eq__(self, other):
if not isinstance(other, Polygon):
return False
if other.exterior != self.exterior:
return False
if other.interiors != self.interiors:
return False
return True
@property
def _exterior_x(self):
return [x for x, y in self.exterior]
@property
def _exterior_y(self):
return [y for x, y in self.exterior]
@property
def bounds(self):
ymin = np.min(self._exterior_y)
ymax = np.max(self._exterior_y)
xmin = np.min(self._exterior_x)
xmax = np.max(self._exterior_x)
return xmin, ymin, xmax, ymax
@property
def geojson(self):
return {'coordinates': tuple([self.exterior] + [i for i in self.interiors]),
'type': self.type}
@property
def pyshp_parts(self):
return [list(self.exterior) + [list(i) for i in self.interiors]]
@property
def patch(self):
return self.get_patch()
def get_patch(self, **kwargs):
try:
from descartes import PolygonPatch
except ImportError:
print('This feature requires descartes.\nTry "pip install descartes"')
return PolygonPatch(self.geojson, **kwargs)
def plot(self, ax=None, **kwargs):
"""Plot the feature.
Parameters
----------
ax : matplotlib.pyplot axes instance
Accepts keyword arguments to descartes.PolygonPatch. Requires the
descartes package (pip install descartes).
"""
try:
import matplotlib.pyplot as plt
except ImportError:
print('This feature requires matplotlib.')
if ax is None:
fig, ax = plt.subplots()
else:
fig = ax.figure
try:
ax.add_patch(self.get_patch(**kwargs))
xmin, ymin, xmax, ymax = self.bounds
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)
plt.show()
except:
print('could not plot polygon feature')
class LineString:
type = 'LineString'
shapeType = 3
has_z = False
def __init__(self, coordinates):
"""Container for housing and describing linestring geometries
(e.g. to be read or written to shapefiles or other geographic data formats)
Parameters
----------
coordinates : sequence
Sequence of coordinates describing a line
Attributes
----------
coords : list of (x, y, z) coordinates
x : list of x coordinates
y : list of y coordinates
z : list of z coordinates
bounds : (xmin, ymin, xmax, ymax)
Tuple describing bounding box for linestring
geojson : dict
Returns a geojson representation of the feature
pyshp_parts : list of lists
Returns a list of all parts (each an individual linestring).
Can be used as input for the shapefile.Writer.line method (pyshp package)
Methods
-------
plot
Plots the feature using matplotlib.pyplot.
Accepts keyword arguments to pyplot.plot.
Notes
-----
Multi-linestrings not yet supported.
z information is only stored if it was entered.
"""
self.coords = list(map(tuple, coordinates))
if len(self.coords[0]) == 3:
self.has_z = True
def __eq__(self, other):
if not isinstance(other, LineString):
return False
if other.x != self.x:
return False
if other.y != self.y:
return False
if other.z != self.z:
return False
return True
@property
def x(self):
return[c[0] for c in self.coords]
@property
def y(self):
return [c[1] for c in self.coords]
@property
def z(self):
return 0 if not self.has_z else [c[2] for c in self.coords]
@property
def bounds(self):
ymin = | np.min(self.y) | numpy.min |
"""
This module contains functions for:
- sorting clusters by size
- sorting clusters by clumpiness and declumping
- other cluster analyses
"""
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from matplotlib.lines import Line2D
from skimage import filters
from sklearn.neighbors import KDTree
from sklearn.cluster import KMeans
from instapipeline import util
# list of declumping algorithms handled
declumping_algs = ['KMeans']
"""
Functions for sorting clusters by size
"""
def get_cluster_size_threshold(clusters):
"""
Calculate a cluster size threshold for all clusters
using K-means in 1D. Assumes a bimodal distribution.
Parameters
----------
clusters : pandas dataframe returned by sa.get_clusters()
(centroid_x | centroid_y | members)
centroid_x = int x coord of cluster centroid
centroid_y = int y coord of cluster centroid
members = list of annotations belonging to the cluster
each annotation is a numpy ndarray of properties:
[int x coord, int y coord, int time spent, str worker ID]
Returns
-------
float cluster size threshold
"""
total_list = []
for index, row in clusters.iterrows():
members = row['members']
worker_list = [member[3] for member in members]
num_members = len(np.unique(worker_list))
total_list.append(num_members)
total_array = np.asarray(total_list)
km = KMeans(n_clusters=2).fit(total_array.reshape(-1, 1))
cluster_centers = km.cluster_centers_
return (cluster_centers[0][0]+cluster_centers[1][0])/2
def plot_cluster_size_threshold(clusters, threshold):
"""
Visualize cluster sizes in a histogram with threshold demarcated.
Parameters
----------
clusters : pandas dataframe returned by sa.get_clusters()
(centroid_x | centroid_y | members)
centroid_x = int x coord of cluster centroid
centroid_y = int y coord of cluster centroid
members = list of annotations belonging to the cluster
each annotation is a numpy ndarray of properties:
[int x coord, int y coord, int time spent, str worker ID]
threshold : float threshold demarcation shown on histogram
Returns
-------
figure : matplotlib figure object
axes : matplotlib axes object
"""
fig = plt.figure()
hist_list = []
for index, row in clusters.iterrows():
members = row['members']
worker_list = [member[3] for member in members]
hist_list.append(len(np.unique(worker_list)))
width = max(hist_list)
plt.hist(hist_list, bins= | np.arange(0, width+4, 2) | numpy.arange |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
# -----------------------------------------------------------------------------
from guidedprojectionbase import GuidedProjectionBase
# -----------------------------------------------------------------------------
# try:
from constraints_basic import columnnew,con_planarity_constraints,\
con_isometry
from constraints_net import con_unit_edge,con_orthogonal_midline,\
con_isogonal,con_isogonal_diagnet,\
con_anet,con_anet_diagnet,con_gnet,con_gnet_diagnet,\
con_anet_geodesic,con_polyline_ruling,con_osculating_tangents,\
con_planar_1familyof_polylines,con_nonsquare_quadface,\
con_singular_Anet_diag_geodesic,con_gonet, \
con_diag_1_asymptotic_or_geodesic,\
con_ctrlnet_symmetric_1_diagpoly, con_AGnet
from singularMesh import quadmesh_with_1singularity
from constraints_glide import con_alignment,con_alignments,con_fix_vertices
# -----------------------------------------------------------------------------
__author__ = '<NAME>'
# -----------------------------------------------------------------------------
class GuidedProjection_AGNet(GuidedProjectionBase):
_N1 = 0
_N5 = 0
_N6 = 0
_Nanet = 0
_Ndgeo = 0
_Ndgeoliou = 0
_Ndgeopc = 0
_Nruling = 0
_Noscut = 0
_Nnonsym = 0
_Npp = 0
_Ncd = _Ncds = 0
_Nag = 0
def __init__(self):
GuidedProjectionBase.__init__(self)
weights = {
## Commen setting:
'geometric' : 0, ##NOTE SHOULD BE 1 ONCE planarity=1
'planarity' : 0,
## shared used:
'unit_edge' : 0,
'unit_diag_edge' : 0,
'orthogonal' :0,
'isogonal' : 0,
'isogonal_diagnet' :0,
'Anet' : 0,
'Anet_diagnet' : 0,
'Gnet' : 0,
'Gnet_diagnet' : 0,
'GOnet' : 0,
'diag_1_asymptotic': 0,
'diag_1_geodesic': 0,
'ctrlnet_symmetric_1diagpoly': 0,
'nonsymmetric' :0,
'isometry' : 0,
'z0' : 0,
'boundary_glide' :0, #Hui in gpbase.py doesn't work, replace here.
'i_boundary_glide' :0,
'fix_point' :0,
## only for AGNet:
'GGGnet': 0,
'GGG_diagnet': 0, #TODO
'AGnet': 0,
'AAGnet': 0,
'GAAnet': 0,
'GGAnet': 0,
'AGGnet': 0,
'AAGGnet': 0,
'GGAAnet': 0,
'planar_geodesic' : 0,
'agnet_liouville': 0,
'ruling': 0,# opt for ruling quadratic mesh, straight lines-mesh
'oscu_tangent' :0,
'AAG_singular' :0,
'planar_ply1' : 0,
'planar_ply2' : 0,
}
self.add_weights(weights)
self.switch_diagmeth = False
self.is_initial = True
self.if_angle = False
self._angle = 90
self._glide_reference_polyline = None
self.i_glide_bdry_crv, self.i_glide_bdry_ver = [],[]
self.ind_fixed_point, self.fixed_value = None,None
self.set_another_polyline = 0
self._ver_poly_strip1,self._ver_poly_strip2 = None,None
self.nonsym_eps = 0.01
self.ind_nonsym_v124,self.ind_nonsym_l12 = None,None
self.is_singular = False
self._singular_polylist = None
self._ind_rr_vertex = None
self.weight_checker = 1
### isogonal AGnet:
self.is_AG_or_GA = True
self.opt_AG_ortho = False
self.opt_AG_const_rii = False
self.opt_AG_const_r0 = False
#--------------------------------------------------------------------------
#
#--------------------------------------------------------------------------
@property
def mesh(self):
return self._mesh
@mesh.setter
def mesh(self, mesh):
self._mesh = mesh
self.initialization()
@property
def max_weight(self):
return max(self.get_weight('boundary_glide'),
self.get_weight('i_boundary_glide'),
self.get_weight('geometric'),
self.get_weight('planarity'),
self.get_weight('unit_edge'),
self.get_weight('unit_diag_edge'),
self.get_weight('orthogonal'),
self.get_weight('isometry'),
self.get_weight('oscu_tangent'),
self.get_weight('Anet'),
self.get_weight('Anet_diagnet'),
self.get_weight('diag_1_asymptotic'), #n defined from only ctrl-net
self.get_weight('diag_1_geodesic'),
self.get_weight('ctrlnet_symmetric_1diagpoly'),
self.get_weigth('nonsymmetric'),
self.get_weight('AAG_singular'),
self.get_weight('planar_plys'),
1)
@property
def angle(self):
return self._angle
@angle.setter
def angle(self,angle):
if angle != self._angle:
self.mesh.angle=angle
self._angle = angle
@property
def glide_reference_polyline(self):
if self._glide_reference_polyline is None:
polylines = self.mesh.boundary_curves(corner_split=False)[0]
N = 5
for polyline in polylines:
polyline.refine(N)
self._glide_reference_polyline = polyline
return self._glide_reference_polyline
# @glide_reference_polyline.setter##NOTE: used by reference-mesh case
# def glide_reference_polyline(self,polyline):
# self._glide_reference_polyline = polyline
@property
def ver_poly_strip1(self):
if self._ver_poly_strip1 is None:
if self.get_weight('planar_ply1') or self.opt_AG_const_rii:
self.index_of_mesh_polylines()
else:
self.index_of_strip_along_polyline()
return self._ver_poly_strip1
@property
def ver_poly_strip2(self):
if self._ver_poly_strip2 is None:
if self.get_weight('planar_ply2'):
self.index_of_mesh_polylines()
return self._ver_poly_strip2
@property
def singular_polylist(self):
if self._singular_polylist is None:
self.get_singularmesh_diagpoly()
return self._singular_polylist
@property
def ind_rr_vertex(self):
if self._ind_rr_vertex is None:
self.get_singularmesh_diagpoly()
return self._ind_rr_vertex
#--------------------------------------------------------------------------
# Initialization
#--------------------------------------------------------------------------
def set_weights(self):
#------------------------------------
if self.get_weight('isogonal'):
self.set_weight('unit_edge', 1*self.get_weight('isogonal'))
elif self.get_weight('isogonal_diagnet'):
self.set_weight('unit_diag_edge', 1*self.get_weight('isogonal_diagnet'))
if self.get_weight('Gnet') or self.get_weight('GOnet'):
self.set_weight('unit_edge', 1)
elif self.get_weight('Gnet_diagnet'):
self.set_weight('unit_diag_edge', 1)
if self.get_weight('GGGnet'):
self.set_weight('Gnet', 1)
self.set_weight('diag_1_geodesic',1)
if self.get_weight('AAGnet'):
self.set_weight('Anet', 1)
elif self.get_weight('GAAnet'):
self.set_weight('Anet_diagnet', 1)
elif self.get_weight('GGAnet'):
self.set_weight('Gnet', 1)
elif self.get_weight('AGGnet'):
self.set_weight('Gnet_diagnet', 1)
elif self.get_weight('AAGGnet'):
self.set_weight('Anet', 1)
self.set_weight('Gnet_diagnet', 1)
elif self.get_weight('GGAAnet'):
self.set_weight('Gnet', 1)
self.set_weight('Anet_diagnet', 1)
if self.get_weight('AGnet'):
self.set_weight('oscu_tangent', self.get_weight('AGnet'))
if self.get_weight('AAG_singular'):
self.set_weight('Anet', 1*self.get_weight('AAG_singular'))
if self.get_weight('diag_1_asymptotic') or self.get_weight('diag_1_geodesic'):
self.set_weight('unit_edge',1)
if self.get_weight('ctrlnet_symmetric_1diagpoly'):
pass
#--------------------------------------
def set_dimensions(self): # Huinote: be used in guidedprojectionbase
V = self.mesh.V
F = self.mesh.F
num_regular = self.mesh.num_regular
N = 3*V
N1 = N5 = N6 = N
Nanet = N
Ndgeo = Ndgeoliou = Ndgeopc = Nruling = Noscut = N
Nnonsym = N
Npp = N
Ncd = Ncds = N
Nag = N
#---------------------------------------------
if self.get_weight('planarity'):
N += 3*F
N1 = N
if self.get_weight('unit_edge'): #Gnet
"le1,le2,le3,le4,ue1,ue2,ue3,ue4 "
if self.get_weight('isogonal'):
N += 16*num_regular
else:
"for Anet"
N += 16*len(self.mesh.ind_rr_star_v4f4)
N5 = N
elif self.get_weight('unit_diag_edge'): #Gnet_diagnet
"le1,le2,le3,le4,ue1,ue2,ue3,ue4 "
N += 16*len(self.mesh.ind_rr_star_v4f4)
N5 = N
if self.get_weight('isogonal'):
"lt1,lt2, ut1,ut2, cos0"
N += 8*num_regular+1
N6 = N
elif self.get_weight('isogonal_diagnet'):
"lt1,lt2, ut1,ut2, cos0"
N += 8*len(self.mesh.ind_rr_star_v4f4)+1
N6 = N
if self.get_weight('Anet') or self.get_weight('Anet_diagnet'):
N += 3*len(self.mesh.ind_rr_star_v4f4)#3*num_regular
Nanet = N
if self.get_weight('AAGnet') or self.get_weight('GAAnet'):
N += 3*len(self.mesh.ind_rr_star_v4f4)
Ndgeo = N
elif self.get_weight('GGAnet') or self.get_weight('AGGnet'):
N += 9*len(self.mesh.ind_rr_star_v4f4)
Ndgeo = N
elif self.get_weight('AAGGnet') or self.get_weight('GGAAnet'):
N += 6*len(self.mesh.ind_rr_star_v4f4)
Ndgeo = N
if self.get_weight('oscu_tangent'):
"X +=[ll1,ll2,ll3,ll4,lu1,lu2,u1,u2]"
N += 12*len(self.mesh.ind_rr_star_v4f4)
Noscut = N
if self.get_weight('AGnet'):
"osculating tangents; X += [surfN; ogN]; if const.ri, X+=[Ri]"
N += 6*len(self.mesh.ind_rr_star_v4f4)
if self.opt_AG_const_rii:
"const rii for each geodesic polylines, default v2-v-v4"
N += len(self.ver_poly_strip1)#TODO
elif self.opt_AG_const_r0:
"unique r"
N += 1
Nag = N
if self.get_weight('agnet_liouville'):
"X +=[lu1,tu1; lla,llc,g1, lg1,tg1, c]"
N += 13*len(self.mesh.ind_rr_star_v4f4) +1
Ndgeoliou = N
if self.get_weight('planar_geodesic'):
N += 3*len(self.ver_poly_strip1[0])
Ndgeopc = N
if self.get_weight('ruling'):
N += 3*len(self.mesh.get_both_isopolyline(self.switch_diagmeth))
Nruling = N
if self.get_weight('nonsymmetric'):
"X += [E,s]"
N += self.mesh.E + len(self.ind_nonsym_v124[0]) ##self.mesh.num_rrf ##len=self.rr_quadface
Nnonsym = N
if self.get_weight('AAG_singular'):
"X += [on]"
N += 3*len(self.singular_polylist[1])
Ndgeo = N
### PPQ-project:
if self.get_weight('planar_ply1'):
N += 3*len(self.ver_poly_strip1)
## only for \obj_cheng\every_5_PPQ.obj'
##matrix = self.ver_poly_strip1
#matrix = self.mesh.rot_patch_matrix[:,::5].T
#N += 3*len(matrix)
Nppq = N
if self.get_weight('planar_ply2'):
N += 3*len(self.ver_poly_strip2)
Nppo = N
### CG / CA project:
if self.get_weight('diag_1_asymptotic') or self.get_weight('diag_1_geodesic'):
if self.get_weight('diag_1_asymptotic'):
"[ln,v_N]"
N += 4*len(self.mesh.ind_rr_star_v4f4)
elif self.get_weight('diag_1_geodesic'):
if self.is_singular:
"[ln,v_N;la[ind],lc[ind],ea[ind],ec[ind]]"
N += (1+3)*len(self.mesh.ind_rr_star_v4f4)+8*len(self.ind_rr_vertex)
else:
"[ln,v_N;la,lc,ea,ec]"
N += (1+3+3+3+1+1)*len(self.mesh.ind_rr_star_v4f4)
Ncd = N #ctrl-diag net
if self.get_weight('ctrlnet_symmetric_1diagpoly'):
N += (1+1+3+3+1+3)*len(self.mesh.ind_rr_star_v4f4) #[e_ac,l_ac]
Ncds = N
#---------------------------------------------
if N1 != self._N1:
self.reinitialize = True
if N5 != self._N5 or N6 != self._N6:
self.reinitialize = True
if Nanet != self._Nanet:
self.reinitialize = True
if Ndgeo != self._Ndgeo:
self.reinitialize = True
if Nag != self._Nag:
self.reinitialize = True
if Ndgeoliou != self._Ndgeoliou:
self.reinitialize = True
if Ndgeopc != self._Ndgeopc:
self.reinitialize = True
if Nruling != self._Nruling:
self.reinitialize = True
if Noscut != self._Noscut:
self.reinitialize = True
if Nnonsym != self._Nnonsym:
self.reinitialize = True
if Npp != self._Npp:
self.reinitialize = True
if Ncd != self._Ncd:
self.reinitialize = True
if Ncds != self._Ncds:
self.reinitialize = True
#----------------------------------------------
self._N = N
self._N1 = N1
self._N5 = N5
self._N6 = N6
self._Nanet = Nanet
self._Ndgeo = Ndgeo
self._Ndgeoliou = Ndgeoliou
self._Ndgeopc = Ndgeopc
self._Nruling = Nruling
self._Noscut = Noscut
self._Nnonsym = Nnonsym
self._Npp = Npp
self._Ncd = Ncd
self._Ncds = Ncds
self._Nag = Nag
self.build_added_weight() # Hui add
def initialize_unknowns_vector(self):
X = self.mesh.vertices.flatten('F')
if self.get_weight('planarity'):
normals = self.mesh.face_normals()
normals = normals.flatten('F')
X = np.hstack((X, normals))
if self.get_weight('unit_edge'):
if True:
"self.get_weight('Gnet')"
rr=True
l1,l2,l3,l4,E1,E2,E3,E4 = self.mesh.get_v4_unit_edge(rregular=rr)
X = np.r_[X,l1,l2,l3,l4]
X = np.r_[X,E1.flatten('F'),E2.flatten('F'),E3.flatten('F'),E4.flatten('F')]
elif self.get_weight('unit_diag_edge'):
l1,l2,l3,l4,E1,E2,E3,E4 = self.mesh.get_v4_diag_unit_edge()
X = np.r_[X,l1,l2,l3,l4]
X = np.r_[X,E1.flatten('F'),E2.flatten('F'),E3.flatten('F'),E4.flatten('F')]
if self.get_weight('isogonal'):
lt1,lt2,ut1,ut2,_,_ = self.mesh.get_v4_unit_tangents()
cos0 = np.mean(np.einsum('ij,ij->i', ut1, ut2))
X = np.r_[X,lt1,lt2,ut1.flatten('F'),ut2.flatten('F'),cos0]
elif self.get_weight('isogonal_diagnet'):
lt1,lt2,ut1,ut2,_,_ = self.mesh.get_v4_diag_unit_tangents()
cos0 = np.mean(np.einsum('ij,ij->i', ut1, ut2))
X = np.r_[X,lt1,lt2,ut1.flatten('F'),ut2.flatten('F'),cos0]
if self.get_weight('Anet'):
if True:
"only r-regular vertex"
v = self.mesh.rr_star[self.mesh.ind_rr_star_v4f4][:,0]
else:
v = self.mesh.ver_regular
V4N = self.mesh.vertex_normals()[v]
X = np.r_[X,V4N.flatten('F')]
elif self.get_weight('Anet_diagnet'):
v = self.mesh.rr_star_corner[0]
V4N = self.mesh.vertex_normals()[v]
X = np.r_[X,V4N.flatten('F')]
if self.get_weight('AAGnet'):
on = self.get_agweb_initial(diagnet=False,
another_poly_direction=self.set_another_polyline,
AAG=True)
X = np.r_[X,on]
elif self.get_weight('GAAnet'):
on = self.get_agweb_initial(diagnet=True,
another_poly_direction=self.set_another_polyline,
AAG=True)
X = np.r_[X,on]
elif self.get_weight('GGAnet'):
vNoN1oN2 = self.get_agweb_initial(diagnet=False,
another_poly_direction=self.set_another_polyline,
GGA=True)
X = np.r_[X,vNoN1oN2]
elif self.get_weight('AGGnet'):
vNoN1oN2 = self.get_agweb_initial(diagnet=True,
another_poly_direction=self.set_another_polyline,
GGA=True)
X = np.r_[X,vNoN1oN2]
elif self.get_weight('AAGGnet'):
oN1oN2 = self.get_agweb_initial(diagnet=False,
another_poly_direction=self.set_another_polyline,
AAGG=True)
X = np.r_[X,oN1oN2]
elif self.get_weight('GGAAnet'):
oN1oN2 = self.get_agweb_initial(diagnet=True,
another_poly_direction=self.set_another_polyline,
AAGG=True)
X = np.r_[X,oN1oN2]
if self.get_weight('oscu_tangent'):
"X +=[ll1,ll2,ll3,ll4,lu1,lu2,u1,u2]"
if self.get_weight('GAAnet') or self.get_weight('AGGnet') or self.get_weight('GGAAnet'):
diag=True
else:
diag=False
l,t,lt1,lt2 = self.mesh.get_net_osculating_tangents(diagnet=diag)
[ll1,ll2,ll3,ll4],[lt1,t1],[lt2,t2] = l,lt1,lt2
X = np.r_[X,ll1,ll2,ll3,ll4]
X = np.r_[X,lt1,lt2,t1.flatten('F'),t2.flatten('F')]
if self.get_weight('AGnet'):
"osculating tangent"
v,v1,v2,v3,v4 = self.mesh.rr_star[self.mesh.ind_rr_star_v4f4].T
V = self.mesh.vertices
_,_,lt1,lt2 = self.mesh.get_net_osculating_tangents()
srfN = np.cross(lt1[1],lt2[1])
srfN = srfN / np.linalg.norm(srfN,axis=1)[:,None]
if not self.is_AG_or_GA:
v2,v4 = v1,v3
biN = np.cross(V[v2]-V[v], V[v4]-V[v])
ogN = biN / np.linalg.norm(biN,axis=1)[:,None]
X = np.r_[X,srfN.flatten('F'),ogN.flatten('F')]
if self.opt_AG_const_rii:
"const rii for each geodesic polylines, default v2-v-v4"
pass #TODO
elif self.opt_AG_const_r0:
"unique r"
from frenet_frame import FrenetFrame
allr = FrenetFrame(V[v],V[v2],V[v4]).radius
X = np.r_[X,np.mean(allr)]
if self.get_weight('agnet_liouville'): # no need now
"X +=[lu1,tu1; lla,llc,g1, lg1,tg1, c]"
lulg = self.get_agweb_liouville(diagnet=True)
X = np.r_[X,lulg]
if self.get_weight('planar_geodesic'):
sn = self.get_poly_strip_normal()
X = np.r_[X,sn.flatten('F')]
if self.get_weight('ruling'): # no need now
sn = self.get_poly_strip_ruling_tangent()
X = np.r_[X,sn.flatten('F')]
if self.get_weight('nonsymmetric'):
E, s = self.get_nonsymmetric_edge_ratio(diagnet=False)
X = np.r_[X, E, s]
if self.get_weight('AAG_singular'):
"X += [on]"
on = self.get_initial_singular_diagply_normal(is_init=True)
X = np.r_[X,on.flatten('F')]
if self.get_weight('planar_ply1'):
sn = self.get_poly_strip_normal(pl1=True)
X = np.r_[X,sn.flatten('F')]
if self.get_weight('planar_ply2'):
sn = self.get_poly_strip_normal(pl2=True)
X = np.r_[X,sn.flatten('F')]
### CG / CA project:
if self.get_weight('diag_1_asymptotic') or self.get_weight('diag_1_geodesic'):
"X += [ln,uN;la,lc,ea,ec]"
v,v1,v2,v3,v4 = self.mesh.rr_star[self.mesh.ind_rr_star_v4f4].T
V = self.mesh.vertices
v4N = np.cross(V[v3]-V[v1], V[v4]-V[v2])
ln = np.linalg.norm(v4N,axis=1)
un = v4N / ln[:,None]
if self.get_weight('diag_1_asymptotic'):
"X += [ln,un]"
X = np.r_[X,ln,un.flatten('F')]
elif self.get_weight('diag_1_geodesic'):
"X += [ln,un; la,lc,ea,ec]"
if self.is_singular:
"new, different from below"
vl,vc,vr = self.singular_polylist
la = np.linalg.norm(V[vl]-V[vc],axis=1)
lc = np.linalg.norm(V[vr]-V[vc],axis=1)
ea = (V[vl]-V[vc]) / la[:,None]
ec = (V[vr]-V[vc]) / lc[:,None]
X = np.r_[X,ln,un.flatten('F'),la,lc,ea.flatten('F'),ec.flatten('F')]
else:
"no singular case"
l1,l2,l3,l4,E1,E2,E3,E4 = self.mesh.get_v4_diag_unit_edge()
if self.set_another_polyline:
"switch to another diagonal polyline"
ea,ec,la,lc = E2,E4,l2,l4
else:
ea,ec,la,lc = E1,E3,l1,l3
X = np.r_[X,ln,un.flatten('F'),la,lc,ea.flatten('F'),ec.flatten('F')]
if self.get_weight('ctrlnet_symmetric_1diagpoly'):
"X += [lt1,lt2,ut1,ut2; lac,ud1]"
lt1,lt2,ut1,ut2,_,_ = self.mesh.get_v4_unit_tangents()
ld1,ld2,ud1,ud2,_,_ = self.mesh.get_v4_diag_unit_tangents()
if self.set_another_polyline:
"switch to another diagonal polyline"
eac,lac = ud2,ld2
else:
eac,lac = ud1,ld1
X = np.r_[X,lt1,lt2,ut1.flatten('F'),ut2.flatten('F')]
X = np.r_[X,lac,eac.flatten('F')]
self._X = X
self._X0 = np.copy(X)
self.build_added_weight() # Hui add
#--------------------------------------------------------------------------
# Errors strings
#--------------------------------------------------------------------------
def make_errors(self):
self.planarity_error()
self.isogonal_error()
self.isogonal_diagnet_error()
self.anet_error()
self.gnet_error()
self.gonet_error()
#self.oscu_tangent_error() # good enough: mean=meax=90
#self.liouville_error()
def planarity_error(self):
if self.get_weight('planarity') == 0:
return None
P = self.mesh.face_planarity()
Emean = np.mean(P)
Emax = np.max(P)
self.add_error('planarity', Emean, Emax, self.get_weight('planarity'))
def isogonal_error(self):
if self.get_weight('isogonal') == 0:
return None
cos,cos0 = self.unit_tangent_vectors()
err = np.abs(cos-cos0) # no divided by cos
emean = np.mean(err)
emax = np.max(err)
self.add_error('isogonal', emean, emax, self.get_weight('isogonal'))
def isogonal_diagnet_error(self):
if self.get_weight('isogonal_diagnet') == 0:
return None
cos,cos0 = self.unit_tangent_vectors_diagnet()
err = np.abs(cos-cos0) # no divided by cos
emean = np.mean(err)
emax = np.max(err)
self.add_error('isogonal_diagnet', emean, emax, self.get_weight('isogonal_diagnet'))
def isometry_error(self): # Hui
"compare all edge_lengths"
if self.get_weight('isometry') == 0:
return None
L = self.edge_lengths_isometry()
L0 = self.edge_lengths_isometry(initialized=True)
norm = np.mean(L)
Err = np.abs(L-L0) / norm
Emean = np.mean(Err)
Emax = np.max(Err)
self.add_error('isometry', Emean, Emax, self.get_weight('isometry'))
def anet_error(self):
if self.get_weight('Anet') == 0 and self.get_weight('Anet_diagnet')==0:
return None
if self.get_weight('Anet'):
name = 'Anet'
if True:
star = self.mesh.rr_star
v,v1,v2,v3,v4 = star[self.mesh.ind_rr_star_v4f4].T
else:
v,v1,v2,v3,v4 = self.mesh.ver_regular_star.T
elif self.get_weight('Anet_diagnet'):
name = 'Anet_diagnet'
v,v1,v2,v3,v4 = self.mesh.rr_star_corner
if self.is_initial:
Nv = self.mesh.vertex_normals()[v]
else:
num = len(v)
c_n = self._Nanet-3*num+np.arange(3*num)
Nv = self.X[c_n].reshape(-1,3,order='F')
V = self.mesh.vertices
err1 = np.abs(np.einsum('ij,ij->i',Nv,V[v1]-V[v]))
err2 = np.abs(np.einsum('ij,ij->i',Nv,V[v2]-V[v]))
err3 = np.abs(np.einsum('ij,ij->i',Nv,V[v3]-V[v]))
err4 = np.abs(np.einsum('ij,ij->i',Nv,V[v4]-V[v]))
Err = err1+err2+err3+err4
Emean = np.mean(Err)
Emax = np.max(Err)
self.add_error(name, Emean, Emax, self.get_weight(name))
def gnet_error(self):
if self.get_weight('Gnet') == 0 and self.get_weight('Gnet_diagnet')==0:
return None
if self.get_weight('Gnet'):
name = 'Gnet'
if True:
star = self.mesh.rr_star
v,v1,v2,v3,v4 = star[self.mesh.ind_rr_star_v4f4].T
else:
v,v1,v2,v3,v4 = self.mesh.ver_regular_star.T
elif self.get_weight('Gnet_diagnet'):
name = 'Gnet_diagnet'
v,v1,v2,v3,v4 = self.mesh.rr_star_corner
V = self.mesh.vertices
E1 = (V[v1]-V[v]) / np.linalg.norm(V[v1]-V[v],axis=1)[:,None]
E2 = (V[v2]-V[v]) / np.linalg.norm(V[v2]-V[v],axis=1)[:,None]
E3 = (V[v3]-V[v]) / np.linalg.norm(V[v3]-V[v],axis=1)[:,None]
E4 = (V[v4]-V[v]) / np.linalg.norm(V[v4]-V[v],axis=1)[:,None]
err1 = np.abs(np.einsum('ij,ij->i',E1,E2)-np.einsum('ij,ij->i',E3,E4))
err2 = np.abs(np.einsum('ij,ij->i',E2,E3)-np.einsum('ij,ij->i',E4,E1))
Err = err1+err2
Emean = np.mean(Err)
Emax = np.max(Err)
self.add_error(name, Emean, Emax, self.get_weight(name))
def gonet_error(self):
if self.get_weight('GOnet') == 0:
return None
name = 'GOnet'
if True:
star = self.mesh.rr_star
v,v1,v2,v3,v4 = star[self.mesh.ind_rr_star_v4f4].T
else:
v,v1,v2,v3,v4 = self.mesh.ver_regular_star.T
V = self.mesh.vertices
E1 = (V[v1]-V[v]) / np.linalg.norm(V[v1]-V[v],axis=1)[:,None]
E2 = (V[v2]-V[v]) / np.linalg.norm(V[v2]-V[v],axis=1)[:,None]
E3 = (V[v3]-V[v]) / np.linalg.norm(V[v3]-V[v],axis=1)[:,None]
E4 = (V[v4]-V[v]) / np.linalg.norm(V[v4]-V[v],axis=1)[:,None]
if self.is_AG_or_GA:
err1 = np.abs(np.einsum('ij,ij->i',E1,E2)-np.einsum('ij,ij->i',E2,E3))
err2 = np.abs(np.einsum('ij,ij->i',E3,E4)-np.einsum('ij,ij->i',E4,E1))
else:
err1 = np.abs(np.einsum('ij,ij->i',E1,E2)-np.einsum('ij,ij->i',E1,E4))
err2 = np.abs(np.einsum('ij,ij->i',E2,E3)-np.einsum('ij,ij->i',E3,E4))
Err = err1+err2
Emean = np.mean(Err)
Emax = np.max(Err)
self.add_error(name, Emean, Emax, self.get_weight(name))
def oscu_tangent_error(self):
if self.get_weight('oscu_tangent') == 0:
return None
if self.get_weight('GAAnet') or self.get_weight('AGGnet') or self.get_weight('GGAAnet'):
diag=True
else:
diag=False
angle = self.mesh.get_net_osculating_tangents(diagnet=diag,printerr=True)
emean = '%.2f' % np.mean(angle)
emax = '%.2f' % np.max(angle)
print('ortho:',emean,emax)
#self.add_error('orthogonal', emean, emax, self.get_weight('oscu_tangent'))
def liouville_error(self):
if self.get_weight('agnet_liouville') == 0:
return None
cos,cos0 = self.agnet_liouville_const_angle()
err = np.abs(cos-cos0) # no divided by cos
emean = np.mean(err)
emax = np.max(err)
self.add_error('Liouville', emean, emax, self.get_weight('agnet_liouville'))
def planarity_error_string(self):
return self.error_string('planarity')
def isogonal_error_string(self):
return self.error_string('isogonal')
def isogonal_diagnet_error_string(self):
return self.error_string('isogonal_diagnet')
def isometry_error_string(self):
return self.error_string('isometry')
def anet_error_string(self):
return self.error_string('Anet')
def liouville_error_string(self):
return self.error_string('agnet_liouville')
#--------------------------------------------------------------------------
# Getting (initilization + Plotting):
#--------------------------------------------------------------------------
def unit_tangent_vectors(self, initialized=False):
if self.get_weight('isogonal') == 0:
return None
if initialized:
X = self._X0
else:
X = self.X
N6 = self._N6
num = self.mesh.num_regular
ut1 = X[N6-6*num-1:N6-3*num-1].reshape(-1,3,order='F')
ut2 = X[N6-3*num-1:N6-1].reshape(-1,3,order='F')
cos = np.einsum('ij,ij->i',ut1,ut2)
cos0 = X[N6-1]
return cos,cos0
def unit_tangent_vectors_diagnet(self, initialized=False):
if self.get_weight('isogonal_diagnet') == 0:
return None
if initialized:
X = self._X0
else:
X = self.X
N6 = self._N6
num = len(self.mesh.ind_rr_star_v4f4)
ut1 = X[N6-6*num-1:N6-3*num-1].reshape(-1,3,order='F')
ut2 = X[N6-3*num-1:N6-1].reshape(-1,3,order='F')
cos = np.einsum('ij,ij->i',ut1,ut2)
cos0 = X[N6-1]
return cos,cos0
def edge_lengths_isometry(self, initialized=False): # Hui
"isometry: keeping all edge_lengths"
if self.get_weight('isometry') == 0:
return None
if initialized:
X = self._X0
else:
X = self.X
vi, vj = self.mesh.vertex_ring_vertices_iterators(order=True) # later should define it as global
Vi = X[columnnew(vi,0,self.mesh.V)].reshape(-1,3,order='F')
Vj = X[columnnew(vj,0,self.mesh.V)].reshape(-1,3,order='F')
el = np.linalg.norm(Vi-Vj,axis=1)
return el
def get_agweb_initial(self,diagnet=False,another_poly_direction=False,
AAG=False,GGA=False,AAGG=False):
"initilization of AG-net project"
V = self.mesh.vertices
v,v1,v2,v3,v4 = self.mesh.rr_star[self.mesh.ind_rr_star_v4f4].T # regular
v,va,vb,vc,vd = self.mesh.rr_star_corner# in diagonal direction
V0,V1,V2,V3,V4,Va,Vb,Vc,Vd = V[v],V[v1],V[v2],V[v3],V[v4],V[va],V[vb],V[vc],V[vd]
vnn = self.mesh.vertex_normals()[v]
if diagnet:
"GGAA / GAA"
Vg1,Vg2,Vg3,Vg4 = V1,V2,V3,V4
else:
"AAGG / AAG"
Vg1,Vg2,Vg3,Vg4 = Va,Vb,Vc,Vd
"X +=[ln, vN] + [oNi]; oNi not need to be unit; all geodesics matter"
if AAGG:
"oN1,oN2 from Gnet-osculating_normals,s.t. anetN*oN1(oN2)=0"
oN1,oN2 = np.cross(Vg3-V0,Vg1-V0),np.cross(Vg4-V0,Vg2-V0)
X = np.r_[oN1.flatten('F'),oN2.flatten('F')]
elif AAG:
"oN from geodesic-osculating-normal (not unit)"
if another_poly_direction:
Vl,Vr = Vg2, Vg4
else:
Vl,Vr = Vg1, Vg3
oN = np.cross(Vr-V0,Vl-V0)
X = np.r_[oN.flatten('F')]
elif GGA:
"X +=[vN, oN1, oN2]; oN1,oN2 from Gnet-osculating_normals"
if diagnet:
"AGG"
Vg1,Vg2,Vg3,Vg4 = Va,Vb,Vc,Vd # different from above
else:
"GGA"
Vg1,Vg2,Vg3,Vg4 = V1,V2,V3,V4 # different from above
oN1,oN2 = np.cross(Vg3-V0,Vg1-V0),np.cross(Vg4-V0,Vg2-V0)
vn = np.cross(oN1,oN2)
vN = vn / np.linalg.norm(vn,axis=1)[:,None]
ind = np.where(np.einsum('ij,ij->i',vnn,vN)<0)[0]
vN[ind]=-vN[ind]
X = np.r_[vN.flatten('F'),oN1.flatten('F'),oN2.flatten('F')]
return X
def get_agweb_an_n_on(self,is_n=False,is_on=False,is_all_n=False):
V = self.mesh.vertices
v = self.mesh.rr_star[:,0]#self.mesh.rr_star_corner[0]
an = V[v]
n = self.mesh.vertex_normals()[v]
on1=on2=n
num = len(self.mesh.ind_rr_star_v4f4)
if self.is_initial:
if self.get_weight('AAGnet') or self.get_weight('GAAnet'):
"vertex normal from A-net"
X = self.get_agweb_initial(AAG=True)
#on = X[:3*num].reshape(-1,3,order='F')
elif self.get_weight('GGAnet') or self.get_weight('AGGnet'):
"X=+[N,oN1,oN2]"
X = self.get_agweb_initial(GGA=True)
n = X[:3*num].reshape(-1,3,order='F')
on1 = X[3*num:6*num].reshape(-1,3,order='F')
on2 = X[6*num:9*num].reshape(-1,3,order='F')
elif self.get_weight('AAGGnet') or self.get_weight('GGAAnet'):
"vertex-normal from Anet, X+=[on1,on2]"
X = self.get_agweb_initial(AAGG=True)
on1 = X[:3*num].reshape(-1,3,order='F')
on2 = X[3*num:6*num].reshape(-1,3,order='F')
elif self.get_weight('Anet'):
pass
# v = v[self.mesh.ind_rr_star_v4f4]
# n = n[v]
elif self.get_weight('AGnet'):
if False:
_,_,lt1,lt2 = self.mesh.get_net_osculating_tangents()
n = np.cross(lt1[1],lt2[1])
n = n / np.linalg.norm(n,axis=1)[:,None]
else:
_,_,ut1,ut2,_,_ = self.mesh.get_v4_unit_tangents(False,True)
n = np.cross(ut1,ut2)
n = n / np.linalg.norm(n,axis=1)[:,None]
else:
X = self.X
if self.get_weight('AAGnet') or self.get_weight('GAAnet'):
"X=+[oNg]"
##print(v,self.mesh.ind_rr_star_v4f4,len(v),len(self.mesh.ind_rr_star_v4f4))
v = v[self.mesh.ind_rr_star_v4f4]
n = X[self._Nanet-3*num:self._Nanet].reshape(-1,3,order='F')
d = self._Ndgeo-3*num
#on = X[d:d+3*num].reshape(-1,3,order='F')
elif self.get_weight('GGAnet') or self.get_weight('AGGnet'):
d = self._Ndgeo-9*num
n = X[d:d+3*num].reshape(-1,3,order='F')
on1 = X[d+3*num:d+6*num].reshape(-1,3,order='F')
on2 = X[d+6*num:d+9*num].reshape(-1,3,order='F')
elif self.get_weight('AAGGnet') or self.get_weight('GGAAnet'):
v = v[self.mesh.ind_rr_star_v4f4]
n = X[self._Nanet-3*num:self._Nanet].reshape(-1,3,order='F')
d = self._Ndgeo-6*num
on1 = X[d:d+3*num].reshape(-1,3,order='F')
on2 = X[d+3*num:d+6*num].reshape(-1,3,order='F')
elif self.get_weight('Anet'):
v = v[self.mesh.ind_rr_star_v4f4]
n = X[self._Nanet-3*num:self._Nanet].reshape(-1,3,order='F')
elif self.get_weight('AGnet'):
if False:
Nag = self._Nag
arr3 = np.arange(3*num)
if self.opt_AG_const_rii or self.opt_AG_const_r0:
if self.opt_AG_const_rii:
#k = len(igeo)
#c_ri = Nag-k+np.arange(k)
pass
#c_srfN = Nag-6*num+arr3-k
#c_ogN = Nag-4*num+arr3-k
elif self.opt_AG_const_r0:
#c_r = Nag-1
c_srfN = Nag-6*num+arr3-1
#c_ogN = Nag-4*num+arr3-1
else:
c_srfN = Nag-6*num+arr3
#c_ogN = Nag-3*num+arr3
n = X[c_srfN].reshape(-1,3,order='F')
#on = X[c_ogN].reshape(-1,3,order='F')
elif False:
ie1 = self._N5-12*num+np.arange(3*num)
ue1 = X[ie1].reshape(-1,3,order='F')
ue2 = X[ie1+3*num].reshape(-1,3,order='F')
ue3 = X[ie1+6*num].reshape(-1,3,order='F')
ue4 = X[ie1+9*num].reshape(-1,3,order='F')
#try:
if self.is_AG_or_GA:
n = ue2+ue4
else:
n = ue1+ue3
n = n / np.linalg.norm(n,axis=1)[:,None]
# except:
# t1,t2 = ue1-ue3,ue2-ue4
# n = np.cross(t1,t2)
# n = n / np.linalg.norm(n,axis=1)[:,None]
v = v[self.mesh.ind_rr_star_v4f4]
else:
c_srfN = self._Nag-3*num+np.arange(3*num)
n = X[c_srfN].reshape(-1,3,order='F')
if is_n:
n = n / np.linalg.norm(n,axis=1)[:,None]
alln = self.mesh.vertex_normals()
n0 = alln[v]
j = np.where(np.einsum('ij,ij->i',n0,n)<0)[0]
n[j] = -n[j]
return V[v],n
elif is_on:
on1 = on1 / np.linalg.norm(on1,axis=1)[:,None]
on2 = on2 / np.linalg.norm(on2,axis=1)[:,None]
return an,on1,on2
elif is_all_n:
alln = self.mesh.vertex_normals()
n0 = alln[v]
j = np.where(np.einsum('ij,ij->i',n0,n)<0)[0]
n[j] = -n[j]
alln[v] = n
return alln
def get_agnet_normal(self,is_biN=False):
V = self.mesh.vertices
v,v1,v2,v3,v4 = self.mesh.rr_star[self.mesh.ind_rr_star_v4f4].T
an = V[v]
if is_biN:
"AGnet: Asy(v1-v-v3), Geo(v2-v-v4), binormal of geodesic crv"
if self.is_AG_or_GA:
eb = (V[v2]-V[v])#/np.linalg.norm(V[v2]-V[v],axis=1)[:,None]
ed = (V[v4]-V[v])#/np.linalg.norm(V[v4]-V[v],axis=1)[:,None]
else:
eb = (V[v1]-V[v])#/np.linalg.norm(V[v1]-V[v],axis=1)[:,None]
ed = (V[v3]-V[v])#/np.linalg.norm(V[v3]-V[v],axis=1)[:,None]
n = | np.cross(eb,ed) | numpy.cross |
from crossSection import sigma_with_masses, PMNS_matrix, neutrino_masses, mfp_gpc
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sys
import random
import warnings
import sys
import os
warnings.filterwarnings("ignore")
plt.style.use('ja')
data_dir = '/Users/james/allMyStuff/Neutrinos/Constraints/highenergy/'
if __name__ == '__main__':
Enu_TeV_arr = [290., 3000., 6000.]
labels = ['290 TeV', '3 PeV', '6 PeV']
colors = ['#357DED', '#0D0221', '#0D0221']
lss = ['-', '--', ':']
plt.figure(figsize=(8, 5))
for idx, Enu_TeV in enumerate(Enu_TeV_arr):
min_nu_mass = 0.03 # GeV
hierarchy = 'normal'
nu_masses = neutrino_masses(min_nu_mass, hierarchy)
Ecom_MeV = np.sqrt(0.5*nu_masses*Enu_TeV)
s_arr = 4 * np.power(Ecom_MeV, 2)
ge = 0
gt = 3*np.power(10.0, -1)
gm = np.power(10.0, -2)
# Fix neutrino number density and mass (multiply by 3 in complex case assuming small splitting)
n_nu = 340 # cm^-3
n_eff = (340/6.0) * 3.0
# Conversion factors
cm = 3.240755 * np.power(10.0, -28) # Gpc
MeV = 8065.54429 * np.power(10.0, 6) # cm^-1
# Distance to blazar
D_blazar = 1.3 # Gpc
# PMNS matrix
t12 = 33.63
t23 = 47.2
t13 = 8.54
dcp = 234
pmns = PMNS_matrix(t12, t23, t13, dcp)
mn = np.linspace(0.0, 15.0, 500)
mp = np.linspace(0.0, 15.0, 500)
MN, MP = np.meshgrid(mn, mp)
sigma_cm = sigma_with_masses(s_arr, ge, gm, gt, MP, MN, pmns)*np.power(MeV, -2)
mfp = mfp_gpc(n_eff, sigma_cm, cm)
region = (MN <= MP)
mfp[region] = np.ma.masked
ctr = plt.contour(MP, MN, mfp,
colors=colors[idx],
levels=[D_blazar],
linewidths=0.0)
mp_trace, mn_trace = ctr.allsegs[0][0].T
mask = (mp_trace < 0.9*mn_trace)
plt.plot(mp_trace[mask], mn_trace[mask],
c=colors[idx],
ls=lss[idx],
label=labels[idx])
if idx == 0:
plt.plot([mp_trace[0], mp_trace[0]], [mn_trace[0], mp_trace[0]],
c=colors[idx],
ls=lss[idx],)
plt.fill(np.append(mp_trace, [0, mp_trace[0]]), np.append(mn_trace, [0, mp_trace[0]]),
color=colors[idx],
alpha=0.1)
plt.plot(np.linspace(0.1, 10), | np.linspace(0.1, 10) | numpy.linspace |
from __future__ import absolute_import
import logging
import numpy as np
from . import numpy as npext
from ..exceptions import ValidationError
logger = logging.getLogger(__name__)
def spikes2events(t, spikes):
"""Return an event-based representation of spikes (i.e. spike times)"""
spikes = npext.array(spikes, copy=False, min_dims=2)
if spikes.ndim > 2:
raise ValidationError("Cannot handle %d-dimensional arrays"
% spikes.ndim, attr='spikes')
if spikes.shape[-1] != len(t):
raise ValidationError("Last dimension of 'spikes' must equal 'len(t)'",
attr='spikes')
# find nonzero elements (spikes) in each row, and translate to times
return [t[spike != 0] for spike in spikes]
def _rates_isi_events(t, events, midpoint, interp):
import scipy.interpolate
if len(events) == 0:
return np.zeros_like(t)
isis = | np.diff(events) | numpy.diff |
# %%
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created/Last Edited: December 30, 2019
@author: <NAME>
@maintainer: <NAME>
Notes:
Script for calculating the cartridge masks and the center of rotation.
"""
# %% All imports
import numpy as np
from skimage.transform import hough_circle, hough_circle_peaks
from skimage.feature import canny
import nibabel as nib, nilearn as nil
import matplotlib.patches as mpatches
from skimage.draw import circle_perimeter,line, polygon,circle, line_aa
import matplotlib.pyplot as plt
from skimage import exposure
from skimage.measure import find_contours
from skimage.transform import (rotate as rt,rescale,downscale_local_mean)
from skimage.filters import sobel
# %%
# =============================================================================
# Finding the inner cartridge
# =============================================================================
def findcartridge(data,slice_num,volume_num,sig=2,lt=0,ht=100,rad1=8,rad2=52, step=1, n =3):
image = data.get_data()[:,:,slice_num,volume_num]
edges = canny(image, sigma=sig, low_threshold=lt, high_threshold=ht)
hough_radii = np.arange(rad1, rad2, step)
hough_res = hough_circle(edges, hough_radii)
accums, cr, cc, radii = hough_circle_peaks(hough_res, hough_radii,
total_num_peaks=n)
return [image,edges,cr,cc,radii]
# %%
# =============================================================================================================
# Mask calculation for the inner cartridge (Obsolete!! Changed to the new algorith based on finding the notch!)
# =============================================================================================================
#def inner_mask(data,findcartridge_parameters,slice_num,volume_num):
#data_best_slices = data
#temp_ind = findcartridge_parameters
#count = 0
#choice = 0
#while(choice != 1):
#if count == 0:
#r_cord_ind = np.argmin(temp_ind[4])
#r_cord = temp_ind[4][r_cord_ind]
#x_cord = temp_ind[2][r_cord_ind]
#y_cord = temp_ind[3][r_cord_ind]
#else:
#user_input = [float(p) for p in input('Enter x,y,r with a space').split()]
#x_cord = user_input[0]
#y_cord = user_input[1]
#r_cord = user_input[2]
#mask_image = np.zeros(data_best_slices.get_data()[:,:,slice_num,volume_num].shape)
#patch = mpatches.Wedge((y_cord,x_cord),r_cord,0,360)
#vertices = patch.get_path().vertices
#x=[]
#y=[]
#for k in range(len(vertices)):
#x.append(int(vertices[k][0]))
#y.append(int(vertices[k][1]))
#x.append(x[0])
#y.append(y[0])
#rr,cc = polygon(x,y)
#mask_image[rr, cc] = 1
#plt.figure()
#plt.imshow(mask_image*np.mean(data_best_slices.get_data()[:,:,slice_num,volume_num].flatten())*5 + data_best_slices.get_data()[:,:,slice_num,volume_num])
#plt.show()
#print('Currently used x,y,r',[x_cord,y_cord,r_cord])
#choice_list = [int(x) for x in input('Enter 1 to go to next slice, 0 to change x,y,r').split()]
#choice = choice_list[0]
#if choice == 1:
#mask = mask_image
#center = [x_cord,y_cord,r_cord] # this is the center of the mask
#count +=1
#return mask,center
# %%
# =================================================================================================
# Mask calculation for the inner cartridge
# =================================================================================================
def inner_mask(data_path,slice_num,volume_num=0,lvl=0.004,rad1=7,rad2=50,step=1, img_path=None):
im = nib.load(data_path).get_data()[:,:,slice_num,volume_num]
im_sobel = sobel(im)
repeat = 1
while(repeat):
contours =find_contours(im_sobel,level=lvl,fully_connected='high')
for n, contour in enumerate(contours):
plt.plot(contour[:, 1], contour[:, 0], linewidth=2)
if img_path:
plt.savefig(img_path)
plt.close()
repeat = 0
else:
plt.show()
print('If this is not showing four circle boundaries, clearly - you need to change the thresholding level for finding contours again. If not changed, all subsequent estimation might fail.')
repeat = int(input('Do you want to repeat and change the thresholding level? 1 for yes, 0 for no'))
if repeat:
print('Current level is:',lvl)
print('\n')
lvl = input('Enter the new lvl (integer)')
smallest_circle = [] #detects the inner circle with notch
for i in range(len(contours)):
smallest_circle.append(contours[i].shape[0])
temp_var = np.array(smallest_circle)
temp_var = np.delete(temp_var,np.argmax(temp_var))
temp_var = np.delete(temp_var,np.argmax(temp_var))
temp_var = np.delete(temp_var,np.argmax(temp_var))
index = np.argwhere(np.array(smallest_circle)==np.max(temp_var))[0][0]
img = np.zeros(im.shape)
img[(contours[index][:,0]).astype('int'),(contours[index][:,1]).astype('int')]=1
hough_radii = np.arange(rad1, rad2, step)
hough_res = hough_circle(img, hough_radii)
accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii,
total_num_peaks=2)
radii_complete = radii[np.argmax(radii)] # complete refers to the full circle with notch
cx_complete = cx[np.argmax(radii)]
cy_complete = cy[np.argmax(radii)]
radii_incomplete = radii[np.argmin(radii)] # complete refers to the circle without notch
cx_incomplete = cx[np.argmin(radii)]
cy_incomplete = cy[np.argmin(radii)]
rr,cc = circle(cy_complete,cx_complete,radii_complete-1) # Erroded by 1 voxel for removing the notch
img_complete = np.zeros(im.shape)
img_complete[rr,cc]=1
rr,cc = circle(cy_incomplete,cx_incomplete,radii_incomplete)
img_incomplete = np.zeros(im.shape)
img_incomplete[rr,cc]=1
return img_complete,cy_complete,cx_complete,radii_complete
# %%
# =================================================================================================
# Finding the center of rotation
# =================================================================================================
def cen_rotation(data_path,slice_num,img_complete,cy_complete,cx_complete,radii_complete,canny_sgm=1,img_path=None):
temp_img= img_complete * (nib.load(data_path).get_data()[:,:,slice_num,0])
cir_mask = np.zeros(temp_img.shape)
rr,cc = circle(cy_complete,cx_complete,radii_complete-2) # erosion to get rid of boundaries
cir_mask[rr,cc] = 1
contrast_enh= exposure.equalize_hist(temp_img)
sobel_edges = sobel(contrast_enh)
sobel_masked = sobel_edges *cir_mask
im = np.power(sobel_masked,5) # increases the contrast such that the quadrant intersection is visible; depends on T2* relaxation, so can vary with the age of the cartridge.
dotp_all = []
for i in range(len(np.nonzero(cir_mask)[0])):
possible_angles = | np.linspace(0,360,720) | numpy.linspace |
# %%
from multiprocessing import Pool
import time
import numpy as np
from scipy.stats import mvn
import os
import pickle
import copy
import matplotlib.pyplot as plt
from scipy import interpolate
from scipy.stats import norm
# %%
exec(open('../../env_vars.py').read())
dir_picklejar = os.environ['dir_picklejar']
filename = os.path.join(os.path.realpath(dir_picklejar), 'data_day_limits')
infile = open(filename,'rb')
data_day_limits = pickle.load(infile)
infile.close()
filename = os.path.join(os.path.realpath(dir_picklejar), 'init_latent_data_small')
infile = open(filename,'rb')
init_dict_latent_data = pickle.load(infile) # Initialization of the latent smoking times
infile.close()
filename = os.path.join(os.path.realpath(dir_picklejar), 'observed_dict_eod_survey')
infile = open(filename,'rb')
init_dict_observed_eod_survey = pickle.load(infile)
infile.close()
filename = os.path.join(os.path.realpath(dir_picklejar), 'observed_dict_all_ema')
infile = open(filename,'rb')
init_dict_observed_ema = pickle.load(infile)
infile.close()
# %%
def grow_tree(depth):
if depth==1:
current_data = list([0,1])
return current_data
elif depth > 1:
curr_level = 1
current_data = list([0,1])
curr_level = 2
while curr_level <= depth:
# Sweep through all leaves at the current level
list_curr_level = list(np.repeat(np.nan, repeats=2**curr_level))
for i in range(0, len(current_data)):
left_leaf = np.append(np.array(current_data[i]), 0)
right_leaf = np.append(np.array(current_data[i]), 1)
list_curr_level[2*i] = list(left_leaf)
list_curr_level[2*i + 1] = list(right_leaf)
# Go one level below
current_data = list_curr_level
curr_level += 1
return current_data
else:
return 0
# %%
class Latent:
'''
A collection of objects and methods related to latent process subcomponent
'''
def __init__(self, participant = None, day = None, latent_data = None, params = None, index = None):
self.participant = participant
self.day = day
self.latent_data = copy.deepcopy(latent_data)
self.params = copy.deepcopy(params)
self.index = index
def update_params(self, new_params):
'''
Update parameters
'''
self.params = copy.deepcopy(new_params)
def calc_loglik(self):
'''
Calculate loglikelihood for latent process subcomponent
'''
smoking_times = self.latent_data['hours_since_start_day']
day_length = self.latent_data['day_length']
lambda_prequit = self.params['lambda_prequit']
lambda_postquit = self.params['lambda_postquit']
# Calculate the total number of latent smoking times in the current iteration
m = len(smoking_times)
# lambda_prequit: number of events per hour during prequit period
# lambda_postquit: number of events per hour during postquit period
# day_length: total number of hours between wakeup time to sleep time on a given participant day
if self.day <4:
lik = np.exp(-lambda_prequit*day_length) * ((lambda_prequit*day_length) ** m) / np.math.factorial(m)
loglik = np.log(lik)
else:
lik = np.exp(-lambda_postquit*day_length) * ((lambda_postquit*day_length) ** m) / np.math.factorial(m)
loglik = np.log(lik)
return loglik
# %%
class EODSurvey:
'''
A collection of objects and methods related to end-of-day survey subcomponent
'''
def __init__(self, participant = None, day = None, latent_data = None, observed_data = None, params = None, index = None):
self.participant = participant
self.day = day
self.latent_data = copy.deepcopy(latent_data)
self.observed_data = copy.deepcopy(observed_data)
self.params = copy.deepcopy(params)
self.index = index
def update_params(self, new_params):
'''
Update parameters
'''
self.params = copy.deepcopy(new_params)
def calc_loglik(self):
'''
Calculate loglikelihood corresponding to end-of-day EMA subcomponent
'''
# Inputs to be checked ----------------------------------------------------------------------------
any_eod_ema = len(self.observed_data['assessment_begin'])
if any_eod_ema > 0:
# Begin after checks on inputs have been passed ---------------------------------------------------
# Go through each box one by one
collect_box_probs = np.array([])
arr_ticked = self.observed_data['ticked_box_raw'] # which boxes were ticked?
m = len(self.latent_data['hours_since_start_day']) # are there any latent smoking events?
all_boxes = np.array([8,9,10,11,12,13,14,15,16,17,18,19,20])
if (m == 0) and (len(arr_ticked) == 0):
collect_box_probs = np.repeat(1, len(all_boxes))
elif (m == 0) and (len(arr_ticked) > 0):
collect_box_probs = np.repeat(0, len(all_boxes))
else:
start_day = 0
end_day = 24
# Rescale time to be within 24 hour clock
all_true_smoke_times = self.latent_data['hours_since_start_day'] + self.observed_data['start_time_hour_of_day']
for k in range(0, len(all_boxes)):
curr_box = all_boxes[k] # lower limit of Box k; setting curr_lk and curr_box to be separate variables in case change of scale is needed for curr_lk
curr_lk = all_boxes[k] # lower limit of Box k
curr_uk = curr_lk + 1 # upper limit of Box k; add one hour to lower limit
recall_epsilon = self.params['recall_epsilon'] # in hours
num_points_to_sample = self.params['budget']
if len(all_true_smoke_times) <= num_points_to_sample:
true_smoke_times = all_true_smoke_times
else:
true_smoke_times = all_true_smoke_times[(all_true_smoke_times > curr_lk - recall_epsilon) * (all_true_smoke_times < curr_uk + recall_epsilon)]
if len(true_smoke_times) > num_points_to_sample:
true_smoke_times = np.random.choice(a = true_smoke_times, size = num_points_to_sample, replace = False)
# At this point, the length of true_smoke_times will always be at most num_points_to_sample
if len(true_smoke_times) > 0:
# Specify covariance matrix based on an exchangeable correlation matrix
rho = self.params['rho']
use_cormat = np.eye(len(true_smoke_times)) + rho*(np.ones((len(true_smoke_times),1)) * np.ones((1,len(true_smoke_times))) - np.eye(len(true_smoke_times)))
use_sd = self.params['sd']
use_covmat = (use_sd**2) * use_cormat
# Calculate total possible probability
total_possible_prob, error_code_total_possible_prob = mvn.mvnun(lower = np.repeat(start_day, len(true_smoke_times)),
upper = np.repeat(end_day, len(true_smoke_times)),
means = true_smoke_times,
covar = use_covmat)
# Begin calculating edge probabilities
collect_edge_probabilities = np.array([])
limits_of_integration = grow_tree(depth=len(true_smoke_times))
for j in range(0, len(limits_of_integration)):
curr_limits = np.array(limits_of_integration[j])
curr_lower_limits = np.where(curr_limits==0, start_day, curr_uk)
curr_upper_limits = np.where(curr_limits==0, curr_lk, end_day)
edge_probabilities, error_code_edge_probabilities = mvn.mvnun(lower = curr_lower_limits,
upper = curr_upper_limits,
means = true_smoke_times,
covar = use_covmat)
collect_edge_probabilities = np.append(collect_edge_probabilities, edge_probabilities)
total_edge_probabilities = np.sum(collect_edge_probabilities)
prob_none_recalled_within_current_box = total_edge_probabilities/total_possible_prob
# prob_none_recalled_within_current_box may be slightly above 1, e.g., 1.000000XXXXX
if (prob_none_recalled_within_current_box-1) > 0:
prob_none_recalled_within_current_box = 1
prob_at_least_one_recalled_within_box = 1-prob_none_recalled_within_current_box
else:
prob_none_recalled_within_current_box = 1
prob_at_least_one_recalled_within_box = 1-prob_none_recalled_within_current_box
# Exit the first IF-ELSE statement
if curr_box in arr_ticked:
collect_box_probs = np.append(collect_box_probs, prob_at_least_one_recalled_within_box)
else:
collect_box_probs = np.append(collect_box_probs, prob_none_recalled_within_current_box)
# Exit if-else statement
prob_observed_box_checking_pattern = np.prod(collect_box_probs)
loglik = np.log(prob_observed_box_checking_pattern)
self.observed_data['prob_bk'] = collect_box_probs
self.observed_data['product_prob_bk'] = prob_observed_box_checking_pattern
self.observed_data['log_product_prob_bk'] = loglik
else:
# If participant did not complete EOD survey, then this measurement type should NOT contribute to the loglikelihood
loglik = 0
return loglik
# %%
class SelfReport:
def __init__(self, participant = None, day = None, latent_data = None, observed_data = None, params = None, index = None):
self.participant = participant
self.day = day
self.latent_data = copy.deepcopy(latent_data)
self.observed_data = copy.deepcopy(observed_data)
self.params = copy.deepcopy(params)
self.index = index
def update_params(self, new_params):
'''
Update parameters
'''
self.params = copy.deepcopy(new_params)
def match(self):
'''
Matches each EMA with one latent smoking time occurring before the Self Report EMA
After a latent smoking time is matched, it is removed
'''
# Inputs to be checked --------------------------------------------
all_latent_times = self.latent_data['hours_since_start_day']
tot_ema = len(self.observed_data['assessment_type'])
if tot_ema > 0:
self.observed_data['matched_latent_time'] = np.repeat(np.nan, tot_ema)
remaining_latent_times = copy.deepcopy(all_latent_times)
remaining_latent_times = np.sort(remaining_latent_times)
for i in range(0, tot_ema):
current_lb = self.observed_data['assessment_begin_shifted'][i]
current_ub = self.observed_data['assessment_begin'][i]
#current_assessment_type = self.observed_data['assessment_type'][i]
which_within = (remaining_latent_times >= 0) & (remaining_latent_times < current_ub)
if np.sum(which_within)>0:
which_idx = np.where(which_within)
matched_idx = np.max(which_idx)
matched_latent_time = remaining_latent_times[matched_idx]
self.observed_data['matched_latent_time'][i] = matched_latent_time
remaining_latent_times = np.delete(remaining_latent_times, matched_idx)
remaining_latent_times = np.sort(remaining_latent_times)
else:
# This case can occur when between time 0 and time t there is no
# latent smoking time, but a self-report occurred between time 0 and time t
# This case may happen after a dumb death move
self.observed_data['matched_latent_time'][i] = np.nan
else:
self.observed_data['matched_latent_time'] = | np.array([]) | numpy.array |
import numpy as np
from .orcadaq import OrcaDecoder, get_ccc, get_readout_info, get_auxhw_info
from .fcdaq import FlashCamEventDecoder
class ORCAFlashCamListenerConfigDecoder(OrcaDecoder):
'''
Decoder for FlashCam listener config written by ORCA
'''
def __init__(self, *args, **kwargs):
self.decoder_name = 'ORFlashCamListenerConfigDecoder'
self.orca_class_name = 'ORFlashCamListenerModel'
# up through ch_inputnum, these are in order of the fcio data format
# for similicity. append any additional values after this.
self.decoded_values = {
'readout_id': { 'dtype': 'uint16', },
'listener_id': { 'dtype': 'uint16', },
'telid': { 'dtype': 'int32', },
'nadcs': { 'dtype': 'int32', },
'ntriggers': { 'dtype': 'int32', },
'nsamples': { 'dtype': 'int32', },
'adcbits': { 'dtype': 'int32', },
'sumlength': { 'dtype': 'int32', },
'blprecision': { 'dtype': 'int32', },
'mastercards': { 'dtype': 'int32', },
'triggercards': { 'dtype': 'int32', },
'adccards': { 'dtype': 'int32', },
'gps': { 'dtype': 'int32', },
'ch_boardid': { 'dtype': 'uint16',
'datatype':
'array_of_equalsized_arrays<1,1>{real}',
'length': 2400, },
'ch_inputnum': { 'dtype': 'uint16',
'datatype':
'array_of_equalsized_arrays<1,1>{real}',
'length': 2400, },
}
super().__init__(args, kwargs)
def get_decoded_values(self, channel=None):
return self.decoded_values
def max_n_rows_per_packet(self):
return 1
def decode_packet(self, packet, lh5_tables,
packet_id, header_dict, verbose=False):
data = np.frombuffer(packet, dtype=np.int32)
tbl = lh5_tables
ii = tbl.loc
tbl['readout_id'].nda[ii] = (data[0] & 0xffff0000) >> 16
tbl['listener_id'].nda[ii] = data[0] & 0x0000ffff
for i,k in enumerate(self.decoded_values):
if i < 2: continue
tbl[k].nda[ii] = data[i-1]
if k == 'gps': break
data = np.frombuffer(packet, dtype=np.uint32)
data = data[list(self.decoded_values.keys()).index('ch_boardid')-1:]
for i in range(len(data)):
tbl['ch_boardid'].nda[ii][i] = (data[i] & 0xffff0000) >> 16
tbl['ch_inputnum'].nda[ii][i] = data[i] & 0x0000ffff
tbl.push_row()
class ORCAFlashCamListenerStatusDecoder(OrcaDecoder):
'''
Decoder for FlashCam status packets written by ORCA
Some of the card level status data contains an array of values
(temperatures for instance) for each card. Since lh5 currently only
supports a 1d vector of 1d vectors, this (card,value) data has to be
flattened before populating the lh5 table.
'''
def __init__(self, *args, **kwargs):
self.decoder_name = 'ORFlashCamListenerStatusDecoder'
self.orca_class_name = 'ORFlashCamListenerModel'
self.nOtherErrors = np.uint32(5)
self.nEnvMonitors = np.uint32(16)
self.nCardTemps = np.uint32(5)
self.nCardVoltages = np.uint32(6)
self.nADCTemps = np.uint32(2)
self.nCTILinks = np.uint32(4)
self.nCards = np.uint32(1)
self.decoded_values = {
'readout_id': { 'dtype': 'uint16', },
'listener_id': { 'dtype': 'uint16', },
'cards': { 'dtype': 'int32', },
'status': { 'dtype': 'int32', },
'statustime': { 'dtype': 'float64', 'units': 's', },
'cputime': { 'dtype': 'float64', 'units': 's', },
'startoffset': { 'dtype': 'float64', 'units': 's', },
'card_fcio_id': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_status': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_event_number': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_pps_count': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_tick_count': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_max_ticks': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_total_errors': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_env_errors': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_cti_errors': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_link_errors': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards, },
'card_other_errors': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards * self.nOtherErrors, },
'card_temp': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards * self.nCardTemps,
'units': 'mC', },
'card_voltage': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards * self.nCardVoltages,
'units': 'mV', },
'card_current': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards,
'units': 'mA', },
'card_humidity': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards,
'units': 'o/oo', },
'card_adc_temp': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards * self.nADCTemps,
'units': 'mC', },
'card_cti_link': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards * self.nCTILinks, },
'card_card_link_state': {
'dtype': 'uint32',
'datatype': 'array<1>{array<1>{real}}',
'length_guess': self.nCards * self.nCards, },
}
# arrays to temporarily store card-level decoded data
self.cdata = {}
self.resize_card_data(ncards=self.nCards)
super().__init__(args, kwargs)
def resize_card_data(self, ncards):
try: ncards = np.uint32(ncards)
except ValueError: return
if ncards == 0: return
for key in self.decoded_values:
# ignore keys that aren't card level
if key.find('card_') != 0: continue
try:
# skip keys for things that aren't arrays with a length_guess
if self.decoded_values[key]['datatype'].find('array') != 0:
continue
length = self.decoded_values[key]['length_guess']
try:
# resize if ncards differs from the old shape
oldshape = self.cdata[key].shape
if oldshape[0] == ncards: continue
if key.find('card_card_') == 0:
self.cdata[key].resize((ncards,ncards,) + oldshape[2:])
else:
self.cdata[key].resize((ncards,) + oldshape[1:])
except KeyError:
# if the key didn't exist set the ndarray for this key
if ((length == ncards or (length % ncards) != 0) and
key.find('card_card_') == -1):
self.cdata[key] = np.ndarray(shape=(length),
dtype=np.uint32)
else:
nval = np.uint32(length / ncards)
self.cdata[key] = np.ndarray(shape=(ncards, nval),
dtype=np.uint32)
except KeyError: continue
# set nCards to allow for not calling this function during decoding
self.nCards = ncards
def get_decoded_values(self, channel=None):
return self.decoded_values
def max_n_rows_per_packet(self):
return 1
def decode_packet(self, packet, lh5_tables,
packet_id, header_dict, verbose=False):
data = np.frombuffer(packet, dtype=np.uint32)
tbl = lh5_tables
ii = tbl.loc
# populate the packet header information
tbl['readout_id'].nda[ii] = (data[0] & 0xffff0000) >> 16
tbl['listener_id'].nda[ii] = data[0] & 0x0000ffff
tbl['status'].nda[ii] = np.int32(data[1])
tbl['statustime'].nda[ii] = np.float64(data[2] + data[3] / 1.0e6)
tbl['cputime'].nda[ii] = np.float64(data[4] + data[5] / 1.0e6)
tbl['startoffset'].nda[ii] = np.float64(data[7] + data[8] / 1.0e6)
tbl['cards'].nda[ii] = np.int32(data[12])
# resize the card level data if necessary
if data[12] != self.nCards:
print('ORlashCamListenerStatusDecoder: resizing card arrays '
'from', self.nCards, ' cards to', data[12])
self.resize_card_data(ncards=data[12])
# set the local card level data
for i in range(np.int(data[12])):
j = 14 + i * (data[12] + 14 + self.nOtherErrors +
self.nEnvMonitors + self.nCTILinks)
self.cdata['card_fcio_id'][i] = data[j]
self.cdata['card_status'][i] = data[j+1]
self.cdata['card_event_number'][i] = data[j+2]
self.cdata['card_pps_count'][i] = data[j+3]
self.cdata['card_tick_count'][i] = data[j+4]
self.cdata['card_max_ticks'][i] = data[j+5]
self.cdata['card_total_errors'][i] = data[j+10]
self.cdata['card_env_errors'][i] = data[j+11]
self.cdata['card_cti_errors'][i] = data[j+12]
self.cdata['card_link_errors'][i] = data[j+13]
k = j + 14
self.cdata['card_other_errors'][i][:]= data[k:k+self.nOtherErrors]
k += self.nOtherErrors
self.cdata['card_temp'][i][:] = data[k:k+self.nCardTemps]
k += self.nCardTemps
self.cdata['card_voltage'][i][:] = data[k:k+self.nCardVoltages]
k += self.nCardVoltages
self.cdata['card_current'][i] = data[k]
self.cdata['card_humidity'][i] = data[k+1]
k += 2
self.cdata['card_adc_temp'][i][:] = data[k:k+self.nADCTemps]
k += self.nADCTemps
self.cdata['card_cti_link'][i][:] = data[k:k+self.nCTILinks]
k += self.nCTILinks
self.cdata['card_card_link_state'][i][:] = data[k:k+data[12]]
# populate the card level data with the flattened local data, then push
for key in self.cdata:
tbl[key].set_vector(ii, self.cdata[key].flatten())
tbl.push_row()
class ORCAFlashCamADCWaveformDecoder(OrcaDecoder):
"""
Decoder for FlashCam ADC data written by ORCA
"""
def __init__(self, *args, **kwargs):
self.decoder_name = 'ORFlashCamADCWaveformDecoder'
self.orca_class_name = 'ORFlashCamADCModel'
# header values from Orca, then the values defined in fcdaq
self.decoded_values_template = {
'crate': { 'dtype': 'uint8', },
'card': { 'dtype': 'uint8', },
'channel': { 'dtype': 'uint8', },
'fcio_id': { 'dtype': 'uint16', } }
fc = FlashCamEventDecoder()
self.decoded_values_template.update(fc.decoded_values)
super().__init__(*args, **kwargs)
self.decoded_values = {}
self.skipped_channels = {}
def get_decoded_values(self, channel=None):
if channel is None:
dec_vals_list = self.decoded_values.items()
if len(dec_vals_list) == 0:
print('ORFlashCamADCModel: error - decoded_values not built')
return None
return list(dec_vals_list)[0][1] # return first thing found
if channel in self.decoded_values: return self.decoded_values[channel]
print('ORFlashCamADCModel: error - '
'no decoded values for channel ', channel)
return None
def max_n_rows_per_packet(self):
return 1
def set_object_info(self, object_info):
self.object_info = object_info
# get the readout list for looking up the waveform length.
# catch AttributeError for when the header_dict is not yet set.
roi = []
try: roi=get_readout_info(self.header_dict, 'ORFlashCamListenerModel')
except AttributeError: pass
for card_dict in self.object_info:
crate = card_dict['Crate']
card = card_dict['Card']
enabled = card_dict['Enabled']
# find the listener id for this card from the readout list
listener = -1
for ro in roi:
try:
for obj in ro['children']:
if obj['crate'] == crate and obj['station'] == card:
listener = ro['uniqueID']
break
except KeyError: pass
# with the listener id, find the event samples for that listener
samples = 0
if listener >= 0:
aux = get_auxhw_info(self.header_dict,
'ORFlashCamListenerModel', listener)
for info in aux:
try: samples = max(samples, info['eventSamples'])
except KeyError: continue
# for each enabled channel, set the decoded values and wf length
for channel in range(len(enabled)):
if not enabled[channel]: continue
ccc = get_ccc(crate, card, channel)
self.decoded_values[ccc] = {}
self.decoded_values[ccc].update(self.decoded_values_template)
if samples > 0:
self.decoded_values[ccc]['waveform']['length'] = samples
def decode_packet(self, packet, lh5_tables,
packet_id, header_dict, verbose=False):
data = np.frombuffer(packet, dtype=np.uint32)
# unpack lengths and ids from the header words
orca_header_length = (data[0] & 0xf0000000) >> 28
fcio_header_length = (data[0] & 0x0fc00000) >> 22
#wf_samples = (data[0] & 0x003fffc0) >> 6
wf_samples = 2048#(data[0] & 0x003fffc0) >> 6
crate = (data[1] & 0xf8000000) >> 27
card = (data[1] & 0x07c00000) >> 22
channel = (data[1] & 0x00003c00) >> 10
fcio_id = data[1] & 0x000003ff
ccc = get_ccc(crate, card, channel)
# get the table for this crate/card/channel
tbl = lh5_tables
if isinstance(list(tbl.keys())[0], int):
if ccc not in lh5_tables:
if ccc not in self.skipped_channels:
self.skipped_channels[ccc] = 0
self.skipped_channels[ccc] += 1
return
tbl = lh5_tables[ccc]
ii = tbl.loc
# check that the waveform length is as expected
if wf_samples != tbl['waveform']['values'].nda.shape[1]:
print('ORCAFlashCamADCWaveformDecoder warning: '
'waveform of length ', wf_samples,' with expected length ',
self.decoded_values[ccc]['waveform']['length'])
# set the values decoded from the header words
tbl['packet_id'].nda[ii] = packet_id
tbl['crate'].nda[ii] = crate
tbl['card'].nda[ii] = card
tbl['channel'].nda[ii] = channel
tbl['fcio_id'].nda[ii] = fcio_id
tbl['numtraces'].nda[ii] = 1
# set the time offsets
offset = orca_header_length - 1
tbl['to_mu_sec'].nda[ii] = np.int32(data[offset])
tbl['to_mu_usec'].nda[ii] = np.int32(data[offset+1])
tbl['to_master_sec'].nda[ii] = np.int32(data[offset+2])
tbl['to_dt_mu_usec'].nda[ii] = np.int32(data[offset+3])
tbl['to_abs_mu_usec'].nda[ii] = np.int32(data[offset+4])
tbl['to_start_sec'].nda[ii] = np.int32(data[offset+5])
tbl['to_start_usec'].nda[ii] = np.int32(data[offset+6])
toff = np.float64(data[offset+2]) + np.float64(data[offset+3])*1e-6
# set the dead region values
offset += 7
tbl['dr_start_pps'].nda[ii] = np.int32(data[offset])
tbl['dr_start_ticks'].nda[ii] = np.int32(data[offset+1])
tbl['dr_stop_pps'].nda[ii] = np.int32(data[offset+2])
tbl['dr_stop_ticks'].nda[ii] = np.int32(data[offset+3])
tbl['dr_maxticks'].nda[ii] = np.int32(data[offset+4])
# set the event number and clock counters
offset += 5
tbl['ievt'].nda[ii] = np.int32(data[offset])
tbl['ts_pps'].nda[ii] = np.int32(data[offset+1])
tbl['ts_ticks'].nda[ii] = np.int32(data[offset+2])
tbl['ts_maxticks'].nda[ii] = np.int32(data[offset+3])
# set the runtime and timestamp
tstamp = | np.float64(data[offset]+1) | numpy.float64 |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.11.1
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] slideshow={"slide_type": "notes"}
# # Dynamic Experiments: Feature points
# + [markdown] hide_input=false slideshow={"slide_type": "slide"}
# <h1>Dynamic Experiments: Feature points</h1>
#
# <p>
# <b>Quantitative Big Imaging - ETHZ: 227-0966-00L</b>
# <br />
# </p>
# <br />
# <p style="font-size:1em;">April 29, 2021</p>
# <br /><br />
# <p style="font-size:1.5em;padding-bottom: 0.25em;"><NAME></p>
# <p style="font-size:1em;">Laboratory for Neutron Scattering and Imaging<br />Paul Scherrer Institut</p>
# + slideshow={"slide_type": "skip"}
import matplotlib.pyplot as plt
import seaborn as sns
# %load_ext autoreload
# %autoreload 2
plt.rcParams["figure.figsize"] = (8, 8)
plt.rcParams["figure.dpi"] = 150
plt.rcParams["font.size"] = 14
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['DejaVu Sans']
plt.style.use('ggplot')
sns.set_style("whitegrid", {'axes.grid': False})
# + [markdown] slideshow={"slide_type": "slide"}
# ### Papers / Sites
#
# - Keypoint and Corner Detection
# - Distinctive Image Features from Scale-Invariant Keypoints - https://www.cs.ubc.ca/~lowe/papers/ijcv04.pdf
# - https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_feature2d/py_sift_intro/py_sift_intro.html
#
# + [markdown] slideshow={"slide_type": "slide"}
# # Key Points (or feature points)
#
# - Registration using the full data set is time demaning.
# - We can detect feature points in an image and use them to make a registration.
#
# + [markdown] slideshow={"slide_type": "subslide"}
# # Identifying key points
# We first focus on the detection of points.
#
# A [Harris corner detector](https://en.wikipedia.org/wiki/Harris_Corner_Detector) helps us here:
# + slideshow={"slide_type": "-"}
from skimage.feature import corner_peaks, corner_harris, BRIEF
from skimage.transform import warp, AffineTransform
from skimage import data
from skimage.io import imread
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
# %matplotlib inline
tform = AffineTransform(scale=(1.3, 1.1), rotation=0, shear=0.1,
translation=(0, 0))
image = warp(data.checkerboard(), tform.inverse, output_shape=(200, 200))
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
ax1.imshow(image); ax1.set_title('Raw Image')
ax2.imshow(corner_harris(image)); ax2.set_title('Corner Features')
peak_coords = corner_peaks(corner_harris(image),threshold_rel=0)
ax3.imshow(image); ax3.set_title('Raw Image')
ax3.plot(peak_coords[:, 1], peak_coords[:, 0], 'rs');
# + [markdown] slideshow={"slide_type": "subslide"}
# ## Let's try the corner detection on real data
# + slideshow={"slide_type": "-"}
full_img = imread("figures/bonegfiltslice.png").mean(axis=2)
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
ax1.imshow(full_img,cmap='bone')
ax1.set_title('Raw Image')
ax2.imshow(2e8<corner_harris(full_img),cmap='viridis'), ax2.set_title('Corner Features')
peak_coords = corner_peaks(corner_harris(full_img),threshold_rel=0.1)
ax3.imshow(full_img,cmap='bone'), ax3.set_title('Raw Image')
ax3.plot(peak_coords[:, 1], peak_coords[:, 0], 'rs');
# + [markdown] slideshow={"slide_type": "slide"}
#
# # Tracking with Points
#
# __Goal:__ To reducing the tracking efforts
#
# We can use the corner points to track features between multiple frames.
#
# In this sample, we see that they are
# - quite stable
# - and fixed
#
# on the features.
# + [markdown] slideshow={"slide_type": "subslide"}
# ## We need data - a series transformed images
# + slideshow={"slide_type": "-"}
from matplotlib.animation import FuncAnimation
from IPython.display import HTML
fig, c_ax = plt.subplots(1, 1, figsize=(5, 5), dpi=100)
def update_frame(i):
c_ax.cla()
tform = AffineTransform(scale=(1.3+i/20, 1.1-i/20), rotation=-i/10, shear=i/20,
translation=(0, 0))
image = warp(data.checkerboard(), tform.inverse, output_shape=(200, 200))
c_ax.imshow(image)
peak_coords = corner_peaks(corner_harris(image),threshold_rel=0.1)
c_ax.plot(peak_coords[:, 1], peak_coords[:, 0], 'rs')
# write animation frames
anim_code = FuncAnimation(fig,
update_frame,
frames=np.linspace(0, 5, 10),
interval=1000,
repeat_delay=2000).to_html5_video()
plt.close('all')
HTML(anim_code)
# + [markdown] slideshow={"slide_type": "slide"}
# # Features and Descriptors
# We can move beyond just key points to keypoints and feature vectors (called descriptors) at those points.
#
# A descriptor is a vector that describes a given keypoint uniquely.
#
# This will be demonstrated using two methods in the following notebook cells...
#
# + slideshow={"slide_type": "subslide"}
from skimage.feature import ORB
full_img = imread("figures/bonegfiltslice.png").mean(axis=2)
orb_det = ORB(n_keypoints=10)
det_obj = orb_det.detect_and_extract(full_img)
fig, (ax3, ax4, ax5) = plt.subplots(1, 3, figsize=(15, 5))
ax3.imshow(full_img, cmap='gray')
ax3.set_title('Raw Image')
for i in range(orb_det.keypoints.shape[0]):
ax3.plot(orb_det.keypoints[i, 1], orb_det.keypoints[i,
0], 's', label='Keypoint {}'.format(i))
ax4.bar(np.arange(10)+i/10.0, orb_det.descriptors[i][:10]+1e-2, width=1/10.0,
alpha=0.5, label='Keypoint {}'.format(i))
ax5.imshow(np.stack([x[:20] for x in orb_det.descriptors], 0))
ax5.set_title('Descriptor')
ax3.legend(facecolor='white', framealpha=0.5)
ax4.legend();
# + [markdown] slideshow={"slide_type": "subslide"}
# ### Defining a supporting function to show the matches
# + slideshow={"slide_type": "-"}
from skimage.feature import match_descriptors, plot_matches
import matplotlib.pyplot as plt
def show_matches(img1, img2, feat1, feat2):
matches12 = match_descriptors(
feat1['descriptors'], feat2['descriptors'], cross_check=True)
fig, (ax3, ax2) = plt.subplots(1, 2, figsize=(15, 5))
c_matches = match_descriptors(feat1['descriptors'],
feat2['descriptors'], cross_check=True)
plot_matches(ax3,
img1, img2,
feat1['keypoints'], feat1['keypoints'],
matches12)
ax2.plot(feat1['keypoints'][:, 1],
feat1['keypoints'][:, 0],
'.',
label='Before')
ax2.plot(feat2['keypoints'][:, 1],
feat2['keypoints'][:, 0],
'.', label='After')
for i, (c_idx, n_idx) in enumerate(c_matches):
x_vec = [feat1['keypoints'][c_idx, 0], feat2['keypoints'][n_idx, 0]]
y_vec = [feat1['keypoints'][c_idx, 1], feat2['keypoints'][n_idx, 1]]
dist = np.sqrt(np.square(np.diff(x_vec))+np.square(np.diff(y_vec)))
alpha = | np.clip(50/dist, 0, 1) | numpy.clip |
# author: <NAME>
# <EMAIL>
# 1/15/2022
import jax.numpy as jnp
from jax import vmap, jit
from jax.config import config;
config.update("jax_enable_x64", True)
# numpy
import numpy as onp
from numpy import random
import argparse
import logging
import datetime
from time import time
import os
# solving Burgers: u_t+ u u_x- nu u_xx=0
def get_parser():
parser = argparse.ArgumentParser(description='Burgers equation GP solver')
# equation parameters
parser.add_argument("--nu", type=float, default = 0.01/onp.pi)
# parser.add_argument("--nu", type=float, default = 0.02)
# kernel setting
parser.add_argument("--kernel", type=str, default="gaussian", choices=["gaussian","inv_quadratics","Matern_3half","Matern_5half","Matern_7half","Matern_9half","Matern_11half"])
parser.add_argument("--sigma", type = float, default = 0.01)
# sampling points
parser.add_argument("--dt", type = float, default = 0.04)
parser.add_argument("--T", type = float, default = 1.0)
parser.add_argument("--N_domain", type = int, default = 500)
parser.add_argument("--time_stepping",type=str, default = "CrankNicolson", choices = ["CrankNicolson", "BackwardEuler"])
# GN iterations
parser.add_argument("--nugget", type = float, default = 1e-10)
parser.add_argument("--GNsteps", type = int, default = 2)
parser.add_argument("--logroot", type=str, default='./logs/')
parser.add_argument("--randomseed", type=int, default=9999)
parser.add_argument("--show_figure", type=bool, default=True)
args = parser.parse_args()
return args
# sample points according to a grid
def sample_points(num_pts, dt, T, option = 'grid'):
Nt = int(T/dt)+1
X_domain = onp.zeros((Nt,num_pts,2))
X_boundary = onp.zeros((Nt,2,2))
if option == 'grid':
for i in range(Nt):
X_domain[i,:,0] = i*dt
X_domain[i,:,1] = onp.linspace(-1.0,1.0, num_pts)
X_boundary[i,:,0] = i*dt
X_boundary[i,:,1] = [-1.0,1.0]
return X_domain, X_boundary
@jit
def get_GNkernel_train(x,y,wx0,wx1,wxg,wy0,wy1,wyg,d,sigma):
# wx0 * delta_x + wxg * nabla delta_x + wx1 * Delta delta_x
return wx0*wy0*kappa(x,y,d,sigma) + wx0*wy1*Delta_y_kappa(x,y,d,sigma) + wy0*wx1*Delta_x_kappa(x,y,d,sigma) + wx1*wy1*Delta_x_Delta_y_kappa(x,y,d,sigma) + wx0*D_wy_kappa(x,y,d,sigma,wyg) + wy0*D_wx_kappa(x,y,d,sigma,wxg) + wx1*Delta_x_D_wy_kappa(x,y,d,sigma,wyg) + wy1*D_wx_Delta_y_kappa(x,y,d,sigma,wxg) + D_wx_D_wy_kappa(x,y,d,sigma,wxg,wyg)
@jit
def get_GNkernel_train_boundary(x,y,wy0,wy1,wyg,d,sigma):
return wy0*kappa(x,y,d,sigma) + wy1*Delta_y_kappa(x,y,d,sigma) + D_wy_kappa(x,y,d,sigma,wyg)
@jit
def get_GNkernel_val_predict(x,y,wy0,wy1,wyg,d,sigma):
return wy0*kappa(x,y,d,sigma) + wy1*Delta_y_kappa(x,y,d,sigma) + D_wy_kappa(x,y,d,sigma,wyg)
@jit
def get_GNkernel_ux_predict(x,y,wy0,wy1,wyg,d,sigma):
wxg = 1.0
return wy0*D_wx_kappa(x,y,d,sigma,wxg) + wy1*D_wx_Delta_y_kappa(x,y,d,sigma,wxg) + D_wx_D_wy_kappa(x,y,d,sigma,wxg, wyg)
@jit
def get_GNkernel_uxx_predict(x,y,wy0,wy1,wyg,d,sigma):
return wy0*Delta_x_kappa(x,y,d,sigma) + wy1*Delta_x_Delta_y_kappa(x,y,d,sigma) + Delta_x_D_wy_kappa(x,y,d,sigma,wyg)
def assembly_Theta(X_domain, X_boundary, w0, w1, wg, sigma):
# X_domain, dim: N_domain*d;
# w0 col vec: coefs of Diracs, dim: N_domain;
# w1 coefs of Laplacians, dim: N_domain
N_domain,d = onp.shape(X_domain)
N_boundary,_ = onp.shape(X_boundary)
Theta = onp.zeros((N_domain+N_boundary,N_domain+N_boundary))
XdXd0 = onp.reshape(onp.tile(X_domain,(1,N_domain)),(-1,d))
XdXd1 = onp.tile(X_domain,(N_domain,1))
XbXd0 = onp.reshape(onp.tile(X_boundary,(1,N_domain)),(-1,d))
XbXd1 = onp.tile(X_domain,(N_boundary,1))
XbXb0 = onp.reshape(onp.tile(X_boundary,(1,N_boundary)),(-1,d))
XbXb1 = onp.tile(X_boundary,(N_boundary,1))
arr_wx0 = onp.reshape(onp.tile(w0,(1,N_domain)),(-1,1))
arr_wx1 = onp.reshape(onp.tile(w1,(1,N_domain)),(-1,1))
arr_wxg = onp.reshape(onp.tile(wg,(1,N_domain)),(-1,d))
arr_wy0 = onp.tile(w0,(N_domain,1))
arr_wy1 = onp.tile(w1,(N_domain,1))
arr_wyg = onp.tile(wg,(N_domain,1))
arr_wy0_bd = onp.tile(w0,(N_boundary,1))
arr_wy1_bd = onp.tile(w1,(N_boundary,1))
arr_wyg_bd = | onp.tile(wg,(N_boundary,1)) | numpy.tile |
import numpy as np
import copy
from ..Utils.geometry import *
class LinearLeastSquare:
"""
Linear Least Square Fitting solution.
Parameters
----------
parameter_space : :obj:`ParaMol.Parameter_space.parameter_space.ParameterSpace`
Instance of the parameter space.
include_regulatization : bool
Flag that signal whether or not to include regularization.
method : str
Type of regularization. Options are 'L2' or 'hyperbolic'.
scaling_factor : float
Scaling factor of the regularization value.
hyperbolic_beta : float
Hyperbolic beta value. Only used if `regularization_type` is `hyperbolic`.
weighting_method : str
Method used to weight the conformations. Available methods are "uniform, "boltzmann" and "manual".
weighting_temperature : unit.simtk.Quantity
Temperature used in the weighting. Only relevant if `weighting_method` is "boltzmann".
Attributes
----------
include_regulatization : bool
Flag that signal whether or not to include regularization.
regularization_type : str
Type of regularization. Options are 'L2' or 'hyperbolic'.
scaling_factor : float
Scaling factor of the regularization value.
hyperbolic_beta : float
Hyperbolic beta value. Only used if `regularization_type` is `hyperbolic`.
weighting_method : str
Method used to weight the conformations. Available methods are "uniform, "boltzmann" and "manual".
weighting_temperature : unit.simtk.Quantity
Temperature used in the weighting. Only relevant if `weighting_method` is "boltzmann".
"""
def __init__(self, parameter_space, include_regularization, method, scaling_factor, hyperbolic_beta, weighting_method, weighting_temperature, **kwargs):
# Matrices used in the explicit solution of the LLS equations
self._parameter_space = parameter_space
self._parameters = None
self._n_parameters = None
# Private variables
self._A = None
self._B = None
self._Aw = None
self._Bw = None
self._param_keys_list = None
self._p0 = None
self._initial_param_regularization = None
# Regularization variables
self._include_regularization = include_regularization
self._regularization_type = method
self._scaling_factor = scaling_factor
self._hyperbolic_beta = hyperbolic_beta
# Weighting variables
self._weighting_method = weighting_method
self._weighting_temperature = weighting_temperature
def fit_parameters_lls(self, systems, alpha_bond=0.05, alpha_angle=0.05):
"""
Method that fits bonded parameters using LLS.
Notes
-----
Only one ParaMol system is supported at once.
Parameters
----------
systems : list of :obj:`ParaMol.System.system.ParaMolSystem`
List containing instances of ParaMol systems.
alpha_bond : float
alpha_angle : float
Returns
-------
systems, parameter_space, objective_function, optimizer
"""
assert self._weighting_method.upper() != "NON_BOLTZMANN", "LLS does not support {} weighting method.".format(self._weighting_method)
# TODO: In the future, adapt this to multiple systems
system = systems[0]
# Compute A matrix
self._calculate_a(system, alpha_bond, alpha_angle)
self._n_parameters = self._A.shape[1]
# Compute B matrix
self._calculate_b(system)
# ---------------------------------------------------------------- #
# Calculate conformations weights #
# ---------------------------------------------------------------- #
system.compute_conformations_weights(temperature=self._weighting_temperature, weighting_method=self._weighting_method, emm=None)
# Weight conformations
for row in range(system.n_structures):
self._A[row, :] = self._A[row, :] * np.sqrt(system.weights[row]) / np.sqrt(np.var(system.ref_energies))
self._B = self._B * np.sqrt(system.weights) / np.sqrt(np.var(system.ref_energies))
# ---------------------------------------------------------------- #
# ---------------------------------------------------------------- #
# Preconditioning #
# ---------------------------------------------------------------- #
# Preconditioning
self._calculate_scaling_constants()
for row in range(system.n_structures):
self._A[row, :] = self._A[row, :] / self._scaling_constants
# ---------------------------------------------------------------- #
# ---------------------------------------------------------------- #
# Regularization #
# ---------------------------------------------------------------- #
if self._include_regularization:
# Add regularization
self._A, self._B = self._add_regularization()
# ---------------------------------------------------------------- #
# ---------------------------------------------------------------- #
# Symmetries #
# ---------------------------------------------------------------- #
self._add_symmetries(system)
# ---------------------------------------------------------------- #
# Perform LLS
self._parameters = np.linalg.lstsq(self._A, self._B, rcond=None)[0]
# Revert scaling
self._parameters = self._parameters / self._scaling_constants
# Reconstruct parameters
self._reconstruct_parameters(self._parameters)
# Get optimizable parameters
self._parameter_space.get_optimizable_parameters([system], symmetry_constrained=False)
return self._parameter_space.optimizable_parameters_values
def fit_parameters_lls2(self, systems, alpha_bond=0.05, alpha_angle=0.05):
"""
Method that fits bonded parameters using LLS.
Notes
-----
Only one ParaMol system is supported at once.
Experimental function.
Parameters
----------
systems : list of :obj:`ParaMol.System.system.ParaMolSystem`
List containing instances of ParaMol systems.
alpha_bond : float
alpha_angle : float
Returns
-------
systems, parameter_space, objective_function, optimizer
"""
# TODO: In the future, adapt this to multiple systems
system = systems[0]
n_iter = 1
rmsd = 999
rmsd_tol = 1e-20
max_iter = 100000
# Self-consistent solution
while n_iter < max_iter and rmsd > rmsd_tol:
# Compute A matrix
self._calculate_a(system, alpha_bond, alpha_angle)
self._n_parameters = self._A.shape[1]
# Compute B matrix
self._calculate_b(system)
# ---------------------------------------------------------------- #
# Calculate conformations weights #
# ---------------------------------------------------------------- #
system.compute_conformations_weights(temperature=self._weighting_temperature, weighting_method=self._weighting_method, emm=system.get_energies_ensemble())
print(system.get_energies_ensemble())
# Weight conformations
for row in range(system.n_structures):
self._A[row, :] = self._A[row, :] * np.sqrt(system.weights[row])
self._B = self._B * np.sqrt(system.weights)
# ---------------------------------------------------------------- #
# ---------------------------------------------------------------- #
# Preconditioning #
# ---------------------------------------------------------------- #
# Preconditioning
self._calculate_scaling_constants()
for row in range(system.n_structures):
self._A[row, :] = self._A[row, :] / self._scaling_constants
# ---------------------------------------------------------------- #
new_param = self._parameter_space.optimizable_parameters_values / self._parameter_space.scaling_constants
# ---------------------------------------------------------------- #
# Regularization #
# ---------------------------------------------------------------- #
if self._include_regularization:
# Add regularization
self._A, self._B = self._add_regularization()
# ---------------------------------------------------------------- #
# ---------------------------------------------------------------- #
# Symmetries #
# ---------------------------------------------------------------- #
self._add_symmetries(system)
# ---------------------------------------------------------------- #
# Perform LLS
self._parameters = np.linalg.lstsq(self._A, self._B, rcond=None)[0]
# Revert scaling
self._parameters = self._parameters / self._scaling_constants
# Reconstruct parameters
self._reconstruct_parameters(self._parameters)
# Get optimizable parameters
self._parameter_space.get_optimizable_parameters([system], symmetry_constrained=False)
self._parameter_space.update_systems(systems, self._parameter_space.optimizable_parameters_values, symmetry_constrained=False)
old_param = copy.deepcopy(new_param)
new_param = self._parameter_space.optimizable_parameters_values /self._parameter_space.scaling_constants
rmsd = np.sqrt(np.sum((old_param - new_param) ** 2) / len(self._parameter_space.optimizable_parameters_values))
a = np.sum(system.weights * (system.get_energies_ensemble() - system.ref_energies - np.mean(system.get_energies_ensemble() - system.ref_energies)) ** 2) / (np.var(system.ref_energies))
n_iter+=1
print("RMSD",n_iter, rmsd, a)
print("RMSD",n_iter, rmsd)
system.compute_conformations_weights(temperature=self._weighting_temperature, weighting_method=self._weighting_method, emm=system.get_energies_ensemble())
a = np.sum(system.weights*(system.get_energies_ensemble()-system.ref_energies-np.mean(system.get_energies_ensemble()-system.ref_energies)) **2) / (np.var(system.ref_energies))
print("FINAL",a)
return self._parameter_space.optimizable_parameters_values
def _add_regularization(self):
"""
Method that adds the regularization part of the A and B matrices.
Returns
-------
self._A, self._B
"""
# Create alpha=scaling_factor / scaling_constants
alpha = self._scaling_factor / self._scaling_constants
# TODO: think of how to make this division general
# Divide by two to make this approach equivalent to the remainder of ParaMol
# alpha = 0.5 * alpha
# Calculate prior widths
self._calculate_prior_widths()
# Calculate A_reg
A_reg = np.identity(self._n_parameters)
for row in range(A_reg.shape[0]):
A_reg[row, :] = (A_reg[row, :]) / self._prior_widths
A_reg = A_reg * alpha
# Update A matrix
self._A = np.vstack((self._A, A_reg))
# Calculate B_reg
#B_reg = np.zeros((n_parameters))
B_reg = alpha * self._initial_param_regularization
# Update B matrix
self._B = np.concatenate((self._B, B_reg))
print("Added regularization.")
return self._A, self._B
def _add_symmetries(self, system):
"""
Method that adds the symmetrie part of the A and B matrices.
Returns
-------
self._A, self._B
"""
n_symmetries = 0
symm_covered = []
A_symm = []
for i in range(len(self._param_symmetries_list)):
symm_i = self._param_symmetries_list[i]
if symm_i in symm_covered or symm_i in ["X_x", "X_y", "X"]:
continue
for j in range(i + 1, len(self._param_symmetries_list)):
symm_j = self._param_symmetries_list[j]
if symm_i == symm_j:
A_symm_row = np.zeros((self._n_parameters))
A_symm_row[i] = 1.0
A_symm_row[j] = -1.0
A_symm.append(A_symm_row)
n_symmetries += 1
symm_covered.append(symm_i)
A_symm = np.asarray(A_symm)
# Update matrices
if n_symmetries > 0:
self._A = np.vstack((self._A, A_symm))
# Calculate B_reg
B_symm = np.zeros((n_symmetries))
# Update B matrix
self._B = np.concatenate((self._B, B_symm))
print("{} symmetries were found".format(n_symmetries))
return self._A, self._B
def _calculate_prior_widths(self, method=None):
""""
Method that generates the prior_widths vector.
Parameters
----------
method : str, optional
Method used to generate the prior widths.
Returns
-------
self._prior_widths : np.array
Array containing the prior widths.
"""
self._prior_widths = []
prior_widths_dict, prior_widths = self._parameter_space.calculate_prior_widths(method=method)
for i in range(self._n_parameters):
self._prior_widths.append(prior_widths_dict[self._param_keys_list[i]])
self._prior_widths = np.asarray(self._prior_widths)
return self._prior_widths
def _calculate_scaling_constants(self, method=None):
"""
Method that generates the scaling constant's vector.
Parameters
----------
method : str, optional
Method used to generate the prior widths.
Returns
-------
self._prior_widths : np.array
Array containing the scaling constants.
"""
self._scaling_constants = []
scaling_constants_dict, scaling_constants = self._parameter_space.calculate_scaling_constants(method=method)
for i in range(self._n_parameters):
self._scaling_constants.append(scaling_constants_dict[self._param_keys_list[i]])
self._scaling_constants = np.asarray(self._scaling_constants)
return self._scaling_constants
def _reconstruct_parameters(self, final_parameters):
"""
Method that reconstructs the parameters after the LLS.
Parameters
----------
final_parameters : np.array or list
List containing the final parameters.
Returns
-------
"""
m = 0
for parameter in self._parameter_space.optimizable_parameters:
ff_term = parameter.ff_term
# ---------------------------------------------------------------- #
# Bonds #
# ---------------------------------------------------------------- #
if parameter.param_key == "bond_k":
if ff_term.parameters["bond_eq"].optimize:
k_xy = np.asarray(final_parameters[m:m + 2])
x0_xy = np.asarray(self._p0[m:m+2])
# Update value of "bond_k"
parameter.value = np.sum(k_xy)
# Update value of "bond_eq"
ff_term.parameters["bond_eq"].value = np.sum(k_xy*x0_xy) / np.sum(k_xy)
m += 2
else:
k_xy = final_parameters[m]
# Update value of "bond_k"
parameter.value = k_xy
m += 1
# ---------------------------------------------------------------- #
# Angles #
# ---------------------------------------------------------------- #
elif parameter.param_key == "angle_k":
if ff_term.parameters["angle_eq"].optimize:
k_xy = np.asarray(final_parameters[m:m + 2])
theta0_xy = np.asarray(self._p0[m:m+2])
# Update value of "bond_k"
parameter.value = np.sum(k_xy)
# Update value of "bond_eq"
ff_term.parameters["angle_eq"].value = np.sum(k_xy*theta0_xy) / np.sum(k_xy)
m += 2
else:
k_xy = final_parameters[m]
# Update value of "bond_k"
parameter.value = k_xy
m += 1
# ---------------------------------------------------------------- #
# Torsions #
# ---------------------------------------------------------------- #
elif parameter.param_key == "torsion_k":
if ff_term.parameters["torsion_phase"].optimize:
k_xy = np.asarray(final_parameters[m:m + 2])
delta_xy = np.asarray(self._p0[m:m + 2])
# Define phasors
p_x = k_xy[0]*np.exp(1j*delta_xy[0])
p_y = k_xy[1]*np.exp(1j*delta_xy[1])
p_xy = p_x + p_y
# Update value of "bond_k"
parameter.value = np.linalg.norm(p_xy)
# parameter.value = np.sqrt(np.sum(k_xy*k_xy)) # alternative expression
# Update value of "bond_eq"
ff_term.parameters["torsion_phase"].value = np.angle(p_xy)
m += 2
else:
k_xy = final_parameters[m]
# Update value of "bond_k"
parameter.value = k_xy
m += 1
elif parameter.param_key not in ["torsion_phase", "bond_eq", "angle_eq"]:
raise NotImplementedError("Fitting of {} not implemented in LLS.".format(parameter.param_key))
return
def _calculate_a(self, system, alpha_bond=None, alpha_angle=None):
"""
Method that calculates the A matrix.
Parameters
----------
system : :obj:`ParaMol.System.system.ParaMolSystem`
Instance of a ParaMol System.
alpha_bond : float
alpha_angle : float
Returns
-------
self._A : np.array
Array containing the A matrix.
"""
self._initial_param_regularization = []
self._param_keys_list = []
self._p0 = []
self._param_symmetries_list = []
r_matrix = []
for parameter in self._parameter_space.optimizable_parameters:
ff_term = parameter.ff_term
# ---------------------------------------------------------------- #
# Bonds #
# ---------------------------------------------------------------- #
if parameter.param_key == "bond_k":
# Calculate distances
distances = []
at1, at2 = ff_term.atoms
for conformation in system.ref_coordinates:
distances.append(calculate_distance(conformation[at1], conformation[at2]))
distances = np.asarray(distances)
if ff_term.parameters["bond_eq"].optimize:
#x0_x = np.min(distances)
#x0_y = np.max(distances)
# Alternative way of calculating x0_x and x0_y, leave it here
x0_x = ff_term.parameters["bond_eq"].value * (1 - alpha_bond)
x0_y = ff_term.parameters["bond_eq"].value * (1 + alpha_bond)
r_vec = np.empty((system.n_structures, 2))
for m in range(system.n_structures):
r_vec[m, 0] = 0.5 * (distances[m] - x0_x) * (distances[m] - x0_x)
r_vec[m, 1] = 0.5 * (distances[m] - x0_y) * (distances[m] - x0_y)
r_matrix.append(r_vec)
self._p0.append(x0_x)
self._p0.append(x0_y)
self._param_keys_list.append(parameter.param_key)
self._param_keys_list.append(parameter.param_key)
self._initial_param_regularization.append(parameter.value)
self._initial_param_regularization.append(parameter.value)
self._param_symmetries_list.append(parameter.symmetry_group+"_x")
self._param_symmetries_list.append(parameter.symmetry_group+"_y")
else:
x0 = ff_term.parameters["bond_eq"].value
r_vec = np.empty((system.n_structures, 1))
for m in range(system.n_structures):
r_vec[m, 0] = 0.5 * (distances[m] - x0) * (distances[m] - x0)
r_matrix.append(r_vec)
self._p0.append(x0)
self._param_keys_list.append(parameter.param_key)
self._initial_param_regularization.append(parameter.value)
self._param_symmetries_list.append(parameter.symmetry_group)
# ---------------------------------------------------------------- #
# Angles #
# ---------------------------------------------------------------- #
elif parameter.param_key == "angle_k":
# Calculate angles
angles = []
at1, at2, at3 = ff_term.atoms
for conformation in system.ref_coordinates:
v1 = conformation[at1]-conformation[at2]
v2 = conformation[at3]-conformation[at2]
angles.append(calculate_angle(v1, v2))
angles = | np.asarray(angles) | numpy.asarray |
#!/usr/bin/python2.7
'''
---------------------------
Licensing and Distribution
---------------------------
Program name: Pilgrim
Version : 1.0
License : MIT/x11
Copyright (c) 2019, <NAME> (<EMAIL>) and
<NAME> (<EMAIL>)
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.
---------------------------
*----------------------------------*
| Package : common |
| Module : internal |
| Last Update: 2019/04/03 (Y/M/D) |
| Main Author: <NAME> |
*----------------------------------*
This module contains some functions related
to internal coordinates
Functions (internal.py):
* ic2string(ic)
* string2ic(icstring)
* merge_ics(ics_st,ics_ab,ics_lb,ics_it,ics_pt)
* unmerge_ics(all_ics)
* count_ics(all_ics)
* get_adjmatrix(xcc,symbols,scale=1.2,mode="bool")
* get_numbonds(amatrix)
* adjacency_matrix2list(amatrix)
* get_subgraph(node,alist,fragment=[])
* get_fragments(alist)
* distance_2fragments(frg1,frg2,xcc)
* distance_allfragments(fragments,xcc)
* frags_distances(fragments)
* link_fragments(xcc,amatrix,nfrags=1)
* ics_value(xcc,ic)
* ics_get_stretchings(cmatrix,natoms)
* ics_get_iccentral(adj_list)
* ics_classify_bends(xcc,ic_3ats,eps_lin=5.0)
* ics_get_ptorsions(ics_st,adj_list,xcc,epslin=5.0)
* ics_get_ltorsions(ics_lb,adj_list)
* ics_from_geom(xcc,symbols,scale=1.3,nfrags=1,eps_lin=5.0)
* ics_from_gts(gtsfile,scale=1.3,nfrags=1,eps_lin=5.0)
* ics_depure_bendings(ic_3ats,keep=[])
* ics_depure_itorsions(ic_4ats,keep=[])
* ics_depure_ptorsions(ic_4ats,keep=[])
* ics_depure(ics,keep=[])
* ics_correctdir(x1,evec,ic,sign)
* ics_idir(xcc,symbols,masses,freqs,ms_evecs,ics=[],mu=1.0/AMU)
* wilson_bvecs(xcc)
* wilson_stretch(bond_vectors,ij,natoms)
* wilson_abend(bond_vectors,ijk,natoms)
* wilson_auxlinB(m,o,n,k)
* wilson_auxlinC(m,o,n,k,Bk=None,Dk=None)
* wilson_lbend(m,o,n,MON,natoms)
* wilson_torsion(bond_vectors,ijkl,natoms)
* wilson_getBC(xcc,all_ics)
* wilson_getu(masses)
* wilson_getG(u,B)
* wilson_gf_internal(u,B,C,Ginv,gcc,Fcc)
* wilson_gf_nonred(G,Ginv,g,f)
* wilson_prj_rc(gnr,fnr,G,nics)
* wilson_evecsincart(L,G,A,masses)
* calc_icfreqs(Fcc,masses,xcc,gcc,all_ics,bool_prc=False)
* nonredundant(xcc,masses,gcc,Fcc,all_ics,ccfreqs,unremov=[],ncycles=None)
* nonredundant_gtsfiles(gtsfiles,all_ics,unremov=[],ncycles=None)
'''
import random
import os
import sys
import numpy as np
import fncs as fncs
from scipy.optimize import brenth
from dicts import dpt_s2cr
from physcons import AMU
from files import read_gtsfile
from criteria import EPS_SCX
from criteria import EPS_SVD
from criteria import EPS_GIV
from criteria import EPS_ICF
from criteria import EPS_SMALLANGLE
#===============================================#
# Internal coordinates / Graph Theory #
#===============================================#
def ic2string(ic):
ictype, icatoms = ic
if ictype == "st": return "-".join(["%i"%(at+1) for at in icatoms])
if ictype == "ab": return "-".join(["%i"%(at+1) for at in icatoms])
if ictype == "pt": return "-".join(["%i"%(at+1) for at in icatoms])
if ictype == "lb": return "=".join(["%i"%(at+1) for at in icatoms])
if ictype == "it": return "_".join(["%i"%(at+1) for at in icatoms])
#---------------------------------------------#
def string2ic(icstring):
if "-" in icstring:
atoms = [int(at)-1 for at in icstring.split("-")]
if len(atoms) == 2: case = "st"
elif len(atoms) == 3: case = "ab"
elif len(atoms) == 4: case = "pt"
else: exit("Problems with internal coordinate!")
if atoms[0] > atoms[-1]: atoms = atoms[::-1]
if "=" in icstring:
atoms = [int(at)-1 for at in icstring.split("=")]
case = "lb"
if len(atoms) != 3: exit("Problems with internal coordinate!")
if atoms[0] > atoms[-1]: atoms = atoms[::-1]
if "_" in icstring:
atoms = [int(at)-1 for at in icstring.split("_")]
case = "it"
if len(atoms) != 4: exit("Problems with internal coordinate!")
atoms = tuple(sorted(atoms[0:3])+atoms[3:4])
return (case,atoms)
#-----------------------------------------------#
def merge_ics(ics_st,ics_ab,ics_lb,ics_it,ics_pt):
all_ics = [ ("st",ic) for ic in sorted(ics_st)] # stretching
all_ics += [ ("ab",ic) for ic in sorted(ics_ab)] # angular bending
all_ics += [ ("lb",ic) for ic in sorted(ics_lb)] # linear bending
all_ics += [ ("it",ic) for ic in sorted(ics_it)] # improper torsion
all_ics += [ ("pt",ic) for ic in sorted(ics_pt)] # proper torsion
return all_ics
#-----------------------------------------------#
def unmerge_ics(all_ics):
ics_st = [ ic for ic_type,ic in all_ics if ic_type=="st"]
ics_ab = [ ic for ic_type,ic in all_ics if ic_type=="ab"]
ics_lb = [ ic for ic_type,ic in all_ics if ic_type=="lb"]
ics_it = [ ic for ic_type,ic in all_ics if ic_type=="it"]
ics_pt = [ ic for ic_type,ic in all_ics if ic_type=="pt"]
return ics_st,ics_ab,ics_lb,ics_it,ics_pt
#-----------------------------------------------#
def count_ics(all_ics):
ics_st,ics_ab,ics_lb,ics_it,ics_pt = unmerge_ics(all_ics)
nICs = len(ics_st)+len(ics_ab)+2*len(ics_lb)+len(ics_it)+len(ics_pt)
return nICs
#-----------------------------------------------#
def get_adjmatrix(xcc,symbols,scale=1.2,mode="bool"):
'''
returns adjacency matrix (connection matrix);
also distance matrix and number of bonds
* mode = bool, int
'''
nbonds = 0
nat = fncs.howmanyatoms(xcc)
dmatrix = fncs.get_distmatrix(xcc)
if mode == "bool": no, yes = False, True
if mode == "int" : no, yes = 0 , 1
cmatrix = [ [no for ii in range(nat)] for jj in range(nat)]
for ii in range(nat):
cr_ii = dpt_s2cr[symbols[ii]] # covalent radius
for jj in range(ii+1,nat):
cr_jj = dpt_s2cr[symbols[jj]]
dref = (cr_ii+cr_jj)*scale
if dmatrix[ii][jj] < dref:
nbonds += 1
cmatrix[ii][jj] = yes
cmatrix[jj][ii] = yes
return cmatrix, dmatrix, nbonds
#-----------------------------------------------#
def get_numbonds(amatrix):
nbonds = 0
nnodes = len(amatrix)
for node1 in range(nnodes):
for node2 in range(node1+1,nnodes):
if amatrix[node1][node2] in [True,1]: nbonds += 1
return nbonds
#-----------------------------------------------#
def adjacency_matrix2list(amatrix):
alist = {}
for node1,row in enumerate(amatrix):
alist[node1]= [node2 for node2, bonded in enumerate(row) if bonded in [True,1]]
return alist
#-----------------------------------------------#
def get_subgraph(node,alist,fragment=[]):
fragment += [node]
neighbors = alist[node]
for neighbor in neighbors:
if neighbor not in fragment:
fragment = get_subgraph(neighbor,alist,fragment)
return fragment
#-----------------------------------------------#
def get_fragments(alist):
fragments = []
visited = set([])
for node in alist.keys():
if node in visited: continue
fragment = set(get_subgraph(node,alist,[]))
if fragment not in fragments: fragments.append(fragment)
visited = visited.union(fragment)
return fragments
#-----------------------------------------------#
def distance_2fragments(frg1,frg2,xcc):
min_dist = float("inf")
pair = (None,None)
for at1 in frg1:
x1 = fncs.xyz(xcc,at1)
for at2 in frg2:
x2 = fncs.xyz(xcc,at2)
dist = fncs.distance(x1,x2)
if dist < min_dist:
min_dist = dist
pair = (at1,at2)
return min_dist, pair
#-----------------------------------------------#
def distance_allfragments(fragments,xcc):
nfrags = len(fragments)
the_list = []
for idx1 in range(nfrags):
frg1 = fragments[idx1]
for idx2 in range(idx1+1,nfrags):
frg2 = fragments[idx2]
dist, (at1,at2) = distance_2fragments(frg1,frg2,xcc)
the_list.append( (dist,idx1,idx2,at1,at2) )
return sorted(the_list)
#-----------------------------------------------#
def frags_distances(fragments):
''' use distance_allfragments - this one returns distance
of 1 and just first atom in each fragment'''
fdists = []
nfrags = len(fragments)
for idx1 in range(nfrags):
for idx2 in range(idx1+1,nfrags):
dist = 1.0
atf1 = list(fragments[idx1])[0]
atf2 = list(fragments[idx2])[0]
fdists.append( (1.0,idx1,idx2,atf1,atf2) )
fdists.sort()
return fdists
#-----------------------------------------------#
def link_fragments(xcc,amatrix,nfrags=1):
if amatrix[0][0] is False: bonded = True
elif amatrix[0][0] is 0 : bonded = 1
else: exit("sth wrong in adjacency matrix!")
alist = adjacency_matrix2list(amatrix)
fragments = get_fragments(alist)
#fdists = frags_distances(fragments)
fdists = distance_allfragments(fragments,xcc)
inumfrags = len(fragments)
fnumfrags = len(fragments)
for dist,idx1,idx2,atf1,atf2 in fdists:
fragments[idx1] = fragments[idx1].union(fragments[idx2])
fragments[idx2] = set([])
amatrix[atf1][atf2] = bonded
amatrix[atf2][atf1] = bonded
fnumfrags = sum([1 for frag in fragments if len(frag)!=0])
if fnumfrags == nfrags: break
fragments = [frag for frag in fragments if len(frag) != 0]
return amatrix, fragments, inumfrags, fnumfrags
#-----------------------------------------------#
def ics_value(xcc,ic):
''' ic = (ic_type,ic_atoms)'''
if type(ic) == type("string"):
ic_type,ic_atoms = string2ic(ic)
else:
ic_type,ic_atoms = ic
if ic_type == "st": return fncs.distance( *(fncs.xyz(xcc,at) for at in ic_atoms) )
if ic_type == "ab": return fncs.angle( *(fncs.xyz(xcc,at) for at in ic_atoms) )
if ic_type == "lb": return fncs.angle( *(fncs.xyz(xcc,at) for at in ic_atoms) )
if ic_type == "it": return fncs.dihedral( *(fncs.xyz(xcc,at) for at in ic_atoms) )
if ic_type == "pt": return fncs.dihedral( *(fncs.xyz(xcc,at) for at in ic_atoms) )
#-----------------------------------------------#
def ics_get_stretchings(cmatrix,natoms):
ics_st = [(at1,at2) for at1 in range(natoms) for at2 in range(at1,natoms) if cmatrix[at1][at2] in [True,1]]
return ics_st
#-----------------------------------------------#
def ics_get_iccentral(adj_list):
ic_3ats = []
ic_4ats = []
for at2 in adj_list.keys():
bonded = adj_list[at2]
nbonded = len(bonded)
if nbonded < 2: continue
for idx1 in range(nbonded):
for idx3 in range(idx1+1,nbonded):
bending = (bonded[idx1],at2,bonded[idx3])
ic_3ats.append(bending)
if nbonded < 3: continue
for idx4 in range(idx3+1,nbonded):
improper_torsion = (bonded[idx1],bonded[idx3],bonded[idx4],at2)
ic_4ats.append(improper_torsion)
return ic_3ats, ic_4ats
#-----------------------------------------------#
def ics_classify_bends(xcc,ic_3ats,eps_lin=5.0):
ics_lb = []
ics_ab = []
thetas = {}
for at1,at2,at3 in ic_3ats:
x1 = fncs.xyz(xcc,at1)
x2 = fncs.xyz(xcc,at2)
x3 = fncs.xyz(xcc,at3)
theta = abs(fncs.rad2deg(fncs.angle(x1,x2,x3)))
if theta < eps_lin or theta > 180-eps_lin:
ics_lb.append( (at1,at2,at3) )
else:
ics_ab.append( (at1,at2,at3) )
thetas[(at1,at2,at3)] = theta
return ics_lb, ics_ab, thetas
#-----------------------------------------------#
def ics_get_ptorsions(ics_st,adj_list,xcc,epslin=5.0):
'''epslin in degrees'''
ics_pt = []
for at2,at3 in ics_st:
x2 = fncs.xyz(xcc,at2)
x3 = fncs.xyz(xcc,at3)
bondedto2 = list(adj_list[at2])
bondedto3 = list(adj_list[at3])
bondedto2.remove(at3)
bondedto3.remove(at2)
if len(bondedto2) == 0: continue
if len(bondedto3) == 0: continue
for at1 in bondedto2:
x1 = fncs.xyz(xcc,at1)
for at4 in bondedto3:
if at1 == at4: continue
x4 = fncs.xyz(xcc,at4)
# the two angles
angA = fncs.rad2deg(fncs.angle(x1,x2,x3))
angB = fncs.rad2deg(fncs.angle(x2,x3,x4))
# linear?
booleanA = angA < epslin or angA > 180-epslin
booleanB = angB < epslin or angB > 180-epslin
if booleanA or booleanB: continue
ptorsion = (at1,at2,at3,at4)
ics_pt.append(ptorsion)
return ics_pt
#-----------------------------------------------#
def ics_get_ltorsions(ics_lb,adj_list):
ic_ltors = []
for at1,at2,at3 in ics_lb:
bondedto1 = list(adj_list[at1])
bondedto3 = list(adj_list[at3])
if at1 in bondedto3: bondedto3.remove(at1)
if at2 in bondedto3: bondedto3.remove(at2)
if at2 in bondedto1: bondedto1.remove(at2)
if at3 in bondedto1: bondedto1.remove(at3)
for at0 in bondedto1:
for at4 in bondedto3:
if at0 == at4: continue
ltorsion = (at0,at1,at3,at4)
ic_ltors.append(ltorsion)
return ic_ltors
#-----------------------------------------------#
def ics_from_geom(xcc,symbols,scale=1.3,nfrags=1,eps_lin=5.0):
natoms = len(symbols)
amatrix, dmatrix, nbonds = get_adjmatrix(xcc,symbols,scale=scale,mode="bool")
amatrix, fragments, inumfrags, fnumfrags = link_fragments(xcc,amatrix,nfrags=nfrags)
if inumfrags != fnumfrags:
nbonds = get_numbonds(amatrix)
alist = adjacency_matrix2list(amatrix)
ics_st = ics_get_stretchings(amatrix,natoms)
ic_3ats, ics_it = ics_get_iccentral(alist)
ics_lb, ics_ab, angles = ics_classify_bends(xcc,ic_3ats,eps_lin)
ics_pt = ics_get_ptorsions(ics_st,alist,xcc,eps_lin)
ics_pt += ics_get_ltorsions(ics_lb,alist)
return merge_ics(ics_st,ics_ab,ics_lb,ics_it,ics_pt)
#-----------------------------------------------#
def ics_from_gts(gtsfile,scale=1.3,nfrags=1,eps_lin=5.0):
xcc,atonums,ch,mtp,E,gcc,Fcc,masses,pgroup,rotsigma,freq_list = read_gtsfile(gtsfile)
symbols = fncs.get_symbols(atonums)
return ics_from_geom(xcc,symbols,scale,nfrags,eps_lin)
#-----------------------------------------------#
def ics_depure_bendings(ic_3ats,keep=[]):
''' up to 3 bendings per central atom'''
centers = [at2 for at1,at2,at3 in keep]
random.shuffle(ic_3ats)
for at1,at2,at3 in ic_3ats:
if centers.count(at2) >= 3: continue
#if at2 in centers: continue
keep.append( (at1,at2,at3) )
centers.append(at2)
return keep
#-----------------------------------------------#
def ics_depure_itorsions(ic_4ats,keep=[]):
''' up to two improper torsions per atom'''
centers = [at4 for at1,at2,at3,at4 in keep]
random.shuffle(ic_4ats)
for at1,at2,at3,at4 in ic_4ats:
if centers.count(at4) >= 2: continue
#if at4 in centers: continue
keep.append( (at1,at2,at3,at4) )
centers.append(at4)
return keep
#-----------------------------------------------#
def ics_depure_ptorsions(ic_4ats,keep=[]):
''' one torsion per bond'''
centers = [(at2,at3) for at1,at2,at3,at4 in keep]
random.shuffle(ic_4ats)
for at1,at2,at3,at4 in ic_4ats:
if (at2,at3) in centers: continue
if (at3,at2) in centers: continue
keep.append( (at1,at2,at3,at4) )
centers.append((at2,at3))
return keep
#-----------------------------------------------#
def ics_depure(ics,keep=[]):
''' keep: those that cannot be removed '''
ics_st ,ics_ab ,ics_lb ,ics_it ,ics_pt = unmerge_ics(ics)
keep_st,keep_ab,keep_lb,keep_it,keep_pt = unmerge_ics(keep)
# depure angular bendings
ics_ab = ics_depure_bendings(ics_ab,keep_ab)
# depure torsions
ics_it = ics_depure_itorsions(ics_it,keep_it)
ics_pt = ics_depure_ptorsions(ics_pt,keep_pt)
# merge again
ics = merge_ics(ics_st,ics_ab,ics_lb,ics_it,ics_pt)
return ics
#-----------------------------------------------#
def ics_correctdir(x1,evec,ic,sign,masses=None,mu=None):
'''
x1 and evec NOT in mass-scaled
'''
x2 = [xi+ei for xi,ei in zip(x1,evec)]
if masses is not None:
x1 = fncs.ms2cc_x(x1,masses,mu)
x2 = fncs.ms2cc_x(x2,masses,mu)
val1 = ics_value(x1,ic)
val2 = ics_value(x2,ic)
diff = val2-val1
if diff > 0.0:
if sign == "++": return True
if sign == "--": return False
elif diff < 0.0:
if sign == "++": return False
if sign == "--": return True
#-----------------------------------------------#
def ics_idir(xcc,symbols,masses,freqs,ms_evecs,ics=[],mu=1.0/AMU):
'''
returns the IC which varies the most due to the imaginary frequency
'''
if len(ics) == 0: ics = ics_from_geom(xcc,symbols)
for freq,Lms in zip(freqs,ms_evecs):
# only imaginary frequency
if freq >= 0.0: continue
Lcc = fncs.ms2cc_x(Lms,masses,mu)
xfin = [xi+ei for xi,ei in zip(xcc,Lcc)]
target_ic = None
target_sign = None
maxdiff = -float("inf")
for ic in ics:
ival = ics_value(xcc ,ic)
fval = ics_value(xfin,ic)
# the sign
if fval >= ival: sign = "++"
else : sign = "--"
# reference for bonds or angles
if len(ic[1]) == 2: reference = 1.0 # 1.0 bohr
else : reference = np.pi/2.0 # 90 degrees
# get absolute diff
if len(ic[1]) == 4: adiff = abs(fncs.angular_dist(fval,ival,'rad'))
else : adiff = abs(fval - ival)
# get relative difference with regards to reference
reldiff = abs(adiff/reference)
# get the one that changes the most
if reldiff > maxdiff:
target_ic = ic
target_sign = sign
maxdiff = reldiff
return target_ic,target_sign
#===============================================#
#===============================================#
# WILSON method for freqs in internal coords #
#===============================================#
'''
Some references:
[1] <NAME> and <NAME>, The Wilson GF Matrix Method of Vibrational Analysis. Part I, II, and III
Can.J.Spectros., 24, 1-10 (1979) ; Can.J.Spectros., 24, 35-40 (1979) ; Can.J.Spectros., 24, 65-74 (1979)
[2] <NAME>, Torsional Internal Coordinates in Normal Coordinate Calculations
J. Mol. Spectros., 66, 288-301 (1977)
[3] <NAME>, <NAME>, <NAME>, Reaction-path potential and vibrational frequencies in terms of curvilinear internal coordinates
J. Chem. Phys. 102, 3188-3201 (1995)
[4] <NAME> and <NAME>, Reaction-Path Dynamics in Redundant Internal Coordinates
J. Phys. Chem. A, 102, 242-247 (1998)
[5] <NAME> and <NAME>, The efficient optimization of molecular geometries using redundant internal coordinates
J. Chem. Phys., 117, 9160-9174 (2002)
'''
#-----------------------------------------------#
def wilson_bvecs(xcc):
'''
This functions calculates the distance
between each pair of atoms (dij) and also
the unit bond vector eij = (rj - ri)/dij
'''
nat = fncs.howmanyatoms(xcc)
bond_vectors = {}
for ii in range(nat):
ri = np.array(fncs.xyz(xcc,ii))
for jj in range(ii+1,nat):
rj = np.array(fncs.xyz(xcc,jj))
eij = rj-ri
dij = np.linalg.norm(eij)
eij = eij / dij
bond_vectors[(ii,jj)] = ( eij, dij)
bond_vectors[(jj,ii)] = (-eij, dij)
return bond_vectors
#-----------------------------------------------#
def wilson_stretch(bond_vectors,ij,natoms):
'''
Returns the row of the B matrix associated to
the bond length between atom i and atom j and
also the corresponding C matrix.
Check ref [1] and [5].
'''
# Using nomenclature of reference [5]
n = min(ij)
m = max(ij)
u, r = bond_vectors[(n,m)]
# Calculating 1st derivatives: row of B matrix
B_row = [0.0 for idx in range(3*natoms)]
for a in [m,n]:
if a == m: zeta_amn = +1.0
if a == n: zeta_amn = -1.0
for i in [0,1,2]:
dr_dai = zeta_amn * u[i]
B_row[3*a+i] = dr_dai
# Calculating 2nd derivatives: 2D matrix of C tensor
C_matrix = [ [0.0 for idx1 in range(3*natoms)] for idx2 in range(3*natoms)]
#C_matrix = np.zeros( (3*natoms,3*natoms) )
for a in [m,n]:
for i in [0,1,2]:
for b in [m,n]:
for j in [0,1,2]:
if C_matrix[3*a+i][3*b+j] != 0.0: continue
# Get delta values
if a == b: delta_ab = 1.0
else: delta_ab = 0.0
if i == j: delta_ij = 1.0
else: delta_ij = 0.0
# Get C element
dr_daidbj = ((-1.0) ** delta_ab) * (u[i]*u[j] - delta_ij) / r
# Save data in both positions
C_matrix[3*a+i][3*b+j] = dr_daidbj
C_matrix[3*b+j][3*a+i] = dr_daidbj
return [B_row], [C_matrix]
#-----------------------------------------------#
def wilson_abend(bond_vectors,ijk,natoms):
'''
Returns the row of the B matrix associated to the
i-j-k angle bend and the corresponding C matrix.
Check ref [1] and [5].
'''
# Using nomenclature of reference [5]
m, o, n = ijk
u, lambda_u = bond_vectors[(o,m)]
v, lambda_v = bond_vectors[(o,n)]
# Get internal coordinate: bond angle
q = fncs.angle_vecs(u,v)
sinq = np.sin(q)
cosq = np.cos(q)
# Generation of w
w = np.cross(u,v)
w = w / np.linalg.norm(w)
uxw = np.cross(u,w)
wxv = np.cross(w,v)
# Calculating 1st derivatives: row of B matrix
B_row = [0.0 for idx in range(3*natoms)]
for a in [m,o,n]:
# Get zeta values
if a == m: zeta_amo = +1.0; zeta_ano = 0.0
if a == o: zeta_amo = -1.0; zeta_ano = -1.0
if a == n: zeta_amo = 0.0; zeta_ano = +1.0
for i in [0,1,2]:
# Get B element
dq_dai = zeta_amo * uxw[i] / lambda_u + zeta_ano * wxv[i] / lambda_v
B_row[3*a+i] = dq_dai
# Calculating 2nd derivatives: 2D matrix of C tensor
#C_matrix = np.zeros( (3*natoms,3*natoms) )
C_matrix = [ [0.0 for idx1 in range(3*natoms)] for idx2 in range(3*natoms)]
if abs(sinq) < EPS_SCX: return [B_row], [C_matrix]
for a in [m,o,n]:
for i in [0,1,2]:
for b in [m,o,n]:
for j in [0,1,2]:
if C_matrix[3*a+i][3*b+j] != 0.0: continue
# Define all delta and zeta values
if a == m: zeta_amo = +1.0; zeta_ano = 0.0
if a == o: zeta_amo = -1.0; zeta_ano = -1.0
if a == n: zeta_amo = 0.0; zeta_ano = +1.0
if b == m: zeta_bmo = +1.0; zeta_bno = 0.0
if b == o: zeta_bmo = -1.0; zeta_bno = -1.0
if b == n: zeta_bmo = 0.0; zeta_bno = +1.0
if i == j: delta_ij = 1.0
else: delta_ij = 0.0
# Get second derivative
t1 = zeta_amo*zeta_bmo*(u[i]*v[j]+u[j]*v[i]-3*u[i]*u[j]*cosq+delta_ij*cosq)/(lambda_u**2 * sinq)
t2 = zeta_ano*zeta_bno*(v[i]*u[j]+v[j]*u[i]-3*v[i]*v[j]*cosq+delta_ij*cosq)/(lambda_v**2 * sinq)
t3 = zeta_amo*zeta_bno*(u[i]*u[j]+v[j]*v[i]-u[i]*v[j]*cosq-delta_ij)/(lambda_u*lambda_v*sinq)
t4 = zeta_ano*zeta_bmo*(v[i]*v[j]+u[j]*u[i]-v[i]*u[j]*cosq-delta_ij)/(lambda_u*lambda_v*sinq)
t5 = cosq / sinq * B_row[3*a+i] * B_row[3*b+j]
dr_daidbj = t1 + t2 + t3 + t4 - t5
C_matrix[3*a+i][3*b+j] = dr_daidbj
C_matrix[3*b+j][3*a+i] = dr_daidbj
return [B_row], [C_matrix]
#-----------------------------------------------#
def wilson_auxlinB(m,o,n,k):
om = m - o
on = n - o
dom = np.linalg.norm(om)
don = np.linalg.norm(on)
qk = ((n[2]-o[2])*(m[k]-o[k]) - (n[k]-o[k])*(m[2]-o[2])) / dom / don
Bk = []
Dk = []
for a in ["m","o","n"]:
for i in [0,1,2]:
if a == "m": dam, dao, dan = 1.0, 0.0, 0.0
if a == "o": dam, dao, dan = 0.0, 1.0, 0.0
if a == "n": dam, dao, dan = 0.0, 0.0, 1.0
if i == 2 : di2 = 1.0
else : di2 = 0.0
if i == k : dik = 1.0
else : dik = 0.0
# Numerator
N_ai = dik*(dao-dan)*m[2] + di2*(dan-dao)*m[k] +\
dik*(dan-dam)*o[2] + di2*(dam-dan)*o[k] +\
dik*(dam-dao)*n[2] + di2*(dao-dam)*n[k]
# Denominator
D_ai = (dam-dao)*(m[i]-o[i]) * don / dom + \
(dan-dao)*(n[i]-o[i]) * dom / don
Dk.append(D_ai)
# Whole derivative
B_ai = (N_ai - qk*D_ai) / (dom*don)
Bk.append(B_ai)
return np.array(Bk), np.array(Dk)
#-----------------------------------------------#
def wilson_auxlinC(m,o,n,k,Bk=None,Dk=None):
om = m - o
on = n - o
dom = np.linalg.norm(om)
don = | np.linalg.norm(on) | numpy.linalg.norm |
# This module has been generated automatically from space group information
# obtained from the Computational Crystallography Toolbox
#
"""
Space groups
This module contains a list of all the 230 space groups that can occur in
a crystal. The variable space_groups contains a dictionary that maps
space group numbers and space group names to the corresponding space
group objects.
.. moduleauthor:: <NAME> <<EMAIL>>
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2013 The Mosaic Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file LICENSE.txt, distributed as part of this software.
#-----------------------------------------------------------------------------
import numpy as N
class SpaceGroup(object):
"""
Space group
All possible space group objects are created in this module. Other
modules should access these objects through the dictionary
space_groups rather than create their own space group objects.
"""
def __init__(self, number, symbol, transformations):
"""
:param number: the number assigned to the space group by
international convention
:type number: int
:param symbol: the Hermann-Mauguin space-group symbol as used
in PDB and mmCIF files
:type symbol: str
:param transformations: a list of space group transformations,
each consisting of a tuple of three
integer arrays (rot, tn, td), where
rot is the rotation matrix and tn/td
are the numerator and denominator of the
translation vector. The transformations
are defined in fractional coordinates.
:type transformations: list
"""
self.number = number
self.symbol = symbol
self.transformations = transformations
self.transposed_rotations = N.array([N.transpose(t[0])
for t in transformations])
self.phase_factors = N.exp(N.array([(-2j*N.pi*t[1])/t[2]
for t in transformations]))
def __repr__(self):
return "SpaceGroup(%d, %s)" % (self.number, repr(self.symbol))
def __len__(self):
"""
:return: the number of space group transformations
:rtype: int
"""
return len(self.transformations)
def symmetryEquivalentMillerIndices(self, hkl):
"""
:param hkl: a set of Miller indices
:type hkl: Scientific.N.array_type
:return: a tuple (miller_indices, phase_factor) of two arrays
of length equal to the number of space group
transformations. miller_indices contains the Miller
indices of each reflection equivalent by symmetry to the
reflection hkl (including hkl itself as the first element).
phase_factor contains the phase factors that must be applied
to the structure factor of reflection hkl to obtain the
structure factor of the symmetry equivalent reflection.
:rtype: tuple
"""
hkls = N.dot(self.transposed_rotations, hkl)
p = N.multiply.reduce(self.phase_factors**hkl, -1)
return hkls, p
space_groups = {}
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(1, 'P 1', transformations)
space_groups[1] = sg
space_groups['P 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(2, 'P -1', transformations)
space_groups[2] = sg
space_groups['P -1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(3, 'P 1 2 1', transformations)
space_groups[3] = sg
space_groups['P 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(4, 'P 1 21 1', transformations)
space_groups[4] = sg
space_groups['P 1 21 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(5, 'C 1 2 1', transformations)
space_groups[5] = sg
space_groups['C 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(6, 'P 1 m 1', transformations)
space_groups[6] = sg
space_groups['P 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(7, 'P 1 c 1', transformations)
space_groups[7] = sg
space_groups['P 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(8, 'C 1 m 1', transformations)
space_groups[8] = sg
space_groups['C 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(9, 'C 1 c 1', transformations)
space_groups[9] = sg
space_groups['C 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(10, 'P 1 2/m 1', transformations)
space_groups[10] = sg
space_groups['P 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(11, 'P 1 21/m 1', transformations)
space_groups[11] = sg
space_groups['P 1 21/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(12, 'C 1 2/m 1', transformations)
space_groups[12] = sg
space_groups['C 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(13, 'P 1 2/c 1', transformations)
space_groups[13] = sg
space_groups['P 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(14, 'P 1 21/c 1', transformations)
space_groups[14] = sg
space_groups['P 1 21/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(15, 'C 1 2/c 1', transformations)
space_groups[15] = sg
space_groups['C 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(16, 'P 2 2 2', transformations)
space_groups[16] = sg
space_groups['P 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(17, 'P 2 2 21', transformations)
space_groups[17] = sg
space_groups['P 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(18, 'P 21 21 2', transformations)
space_groups[18] = sg
space_groups['P 21 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(19, 'P 21 21 21', transformations)
space_groups[19] = sg
space_groups['P 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(20, 'C 2 2 21', transformations)
space_groups[20] = sg
space_groups['C 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(21, 'C 2 2 2', transformations)
space_groups[21] = sg
space_groups['C 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(22, 'F 2 2 2', transformations)
space_groups[22] = sg
space_groups['F 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(23, 'I 2 2 2', transformations)
space_groups[23] = sg
space_groups['I 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(24, 'I 21 21 21', transformations)
space_groups[24] = sg
space_groups['I 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(25, 'P m m 2', transformations)
space_groups[25] = sg
space_groups['P m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(26, 'P m c 21', transformations)
space_groups[26] = sg
space_groups['P m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(27, 'P c c 2', transformations)
space_groups[27] = sg
space_groups['P c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(28, 'P m a 2', transformations)
space_groups[28] = sg
space_groups['P m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(29, 'P c a 21', transformations)
space_groups[29] = sg
space_groups['P c a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(30, 'P n c 2', transformations)
space_groups[30] = sg
space_groups['P n c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(31, 'P m n 21', transformations)
space_groups[31] = sg
space_groups['P m n 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(32, 'P b a 2', transformations)
space_groups[32] = sg
space_groups['P b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(33, 'P n a 21', transformations)
space_groups[33] = sg
space_groups['P n a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(34, 'P n n 2', transformations)
space_groups[34] = sg
space_groups['P n n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(35, 'C m m 2', transformations)
space_groups[35] = sg
space_groups['C m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(36, 'C m c 21', transformations)
space_groups[36] = sg
space_groups['C m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(37, 'C c c 2', transformations)
space_groups[37] = sg
space_groups['C c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(38, 'A m m 2', transformations)
space_groups[38] = sg
space_groups['A m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(39, 'A b m 2', transformations)
space_groups[39] = sg
space_groups['A b m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(40, 'A m a 2', transformations)
space_groups[40] = sg
space_groups['A m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(41, 'A b a 2', transformations)
space_groups[41] = sg
space_groups['A b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(42, 'F m m 2', transformations)
space_groups[42] = sg
space_groups['F m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(43, 'F d d 2', transformations)
space_groups[43] = sg
space_groups['F d d 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(44, 'I m m 2', transformations)
space_groups[44] = sg
space_groups['I m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(45, 'I b a 2', transformations)
space_groups[45] = sg
space_groups['I b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(46, 'I m a 2', transformations)
space_groups[46] = sg
space_groups['I m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(47, 'P m m m', transformations)
space_groups[47] = sg
space_groups['P m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(48, 'P n n n :2', transformations)
space_groups[48] = sg
space_groups['P n n n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(49, 'P c c m', transformations)
space_groups[49] = sg
space_groups['P c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(50, 'P b a n :2', transformations)
space_groups[50] = sg
space_groups['P b a n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(51, 'P m m a', transformations)
space_groups[51] = sg
space_groups['P m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(52, 'P n n a', transformations)
space_groups[52] = sg
space_groups['P n n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(53, 'P m n a', transformations)
space_groups[53] = sg
space_groups['P m n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(54, 'P c c a', transformations)
space_groups[54] = sg
space_groups['P c c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(55, 'P b a m', transformations)
space_groups[55] = sg
space_groups['P b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(56, 'P c c n', transformations)
space_groups[56] = sg
space_groups['P c c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(57, 'P b c m', transformations)
space_groups[57] = sg
space_groups['P b c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(58, 'P n n m', transformations)
space_groups[58] = sg
space_groups['P n n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(59, 'P m m n :2', transformations)
space_groups[59] = sg
space_groups['P m m n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(60, 'P b c n', transformations)
space_groups[60] = sg
space_groups['P b c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(61, 'P b c a', transformations)
space_groups[61] = sg
space_groups['P b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(62, 'P n m a', transformations)
space_groups[62] = sg
space_groups['P n m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(63, 'C m c m', transformations)
space_groups[63] = sg
space_groups['C m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(64, 'C m c a', transformations)
space_groups[64] = sg
space_groups['C m c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(65, 'C m m m', transformations)
space_groups[65] = sg
space_groups['C m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(66, 'C c c m', transformations)
space_groups[66] = sg
space_groups['C c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(67, 'C m m a', transformations)
space_groups[67] = sg
space_groups['C m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(68, 'C c c a :2', transformations)
space_groups[68] = sg
space_groups['C c c a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(69, 'F m m m', transformations)
space_groups[69] = sg
space_groups['F m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(70, 'F d d d :2', transformations)
space_groups[70] = sg
space_groups['F d d d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(71, 'I m m m', transformations)
space_groups[71] = sg
space_groups['I m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(72, 'I b a m', transformations)
space_groups[72] = sg
space_groups['I b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(73, 'I b c a', transformations)
space_groups[73] = sg
space_groups['I b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(74, 'I m m a', transformations)
space_groups[74] = sg
space_groups['I m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(75, 'P 4', transformations)
space_groups[75] = sg
space_groups['P 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(76, 'P 41', transformations)
space_groups[76] = sg
space_groups['P 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(77, 'P 42', transformations)
space_groups[77] = sg
space_groups['P 42'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(78, 'P 43', transformations)
space_groups[78] = sg
space_groups['P 43'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(79, 'I 4', transformations)
space_groups[79] = sg
space_groups['I 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(80, 'I 41', transformations)
space_groups[80] = sg
space_groups['I 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(81, 'P -4', transformations)
space_groups[81] = sg
space_groups['P -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(82, 'I -4', transformations)
space_groups[82] = sg
space_groups['I -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(83, 'P 4/m', transformations)
space_groups[83] = sg
space_groups['P 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(84, 'P 42/m', transformations)
space_groups[84] = sg
space_groups['P 42/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(85, 'P 4/n :2', transformations)
space_groups[85] = sg
space_groups['P 4/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(86, 'P 42/n :2', transformations)
space_groups[86] = sg
space_groups['P 42/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(87, 'I 4/m', transformations)
space_groups[87] = sg
space_groups['I 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(88, 'I 41/a :2', transformations)
space_groups[88] = sg
space_groups['I 41/a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(89, 'P 4 2 2', transformations)
space_groups[89] = sg
space_groups['P 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(90, 'P 4 21 2', transformations)
space_groups[90] = sg
space_groups['P 4 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(91, 'P 41 2 2', transformations)
space_groups[91] = sg
space_groups['P 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(92, 'P 41 21 2', transformations)
space_groups[92] = sg
space_groups['P 41 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(93, 'P 42 2 2', transformations)
space_groups[93] = sg
space_groups['P 42 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(94, 'P 42 21 2', transformations)
space_groups[94] = sg
space_groups['P 42 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(95, 'P 43 2 2', transformations)
space_groups[95] = sg
space_groups['P 43 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(96, 'P 43 21 2', transformations)
space_groups[96] = sg
space_groups['P 43 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(97, 'I 4 2 2', transformations)
space_groups[97] = sg
space_groups['I 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(98, 'I 41 2 2', transformations)
space_groups[98] = sg
space_groups['I 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(99, 'P 4 m m', transformations)
space_groups[99] = sg
space_groups['P 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(100, 'P 4 b m', transformations)
space_groups[100] = sg
space_groups['P 4 b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(101, 'P 42 c m', transformations)
space_groups[101] = sg
space_groups['P 42 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(102, 'P 42 n m', transformations)
space_groups[102] = sg
space_groups['P 42 n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(103, 'P 4 c c', transformations)
space_groups[103] = sg
space_groups['P 4 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(104, 'P 4 n c', transformations)
space_groups[104] = sg
space_groups['P 4 n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(105, 'P 42 m c', transformations)
space_groups[105] = sg
space_groups['P 42 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(106, 'P 42 b c', transformations)
space_groups[106] = sg
space_groups['P 42 b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(107, 'I 4 m m', transformations)
space_groups[107] = sg
space_groups['I 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(108, 'I 4 c m', transformations)
space_groups[108] = sg
space_groups['I 4 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(109, 'I 41 m d', transformations)
space_groups[109] = sg
space_groups['I 41 m d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(110, 'I 41 c d', transformations)
space_groups[110] = sg
space_groups['I 41 c d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(111, 'P -4 2 m', transformations)
space_groups[111] = sg
space_groups['P -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(112, 'P -4 2 c', transformations)
space_groups[112] = sg
space_groups['P -4 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(113, 'P -4 21 m', transformations)
space_groups[113] = sg
space_groups['P -4 21 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(114, 'P -4 21 c', transformations)
space_groups[114] = sg
space_groups['P -4 21 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(115, 'P -4 m 2', transformations)
space_groups[115] = sg
space_groups['P -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(116, 'P -4 c 2', transformations)
space_groups[116] = sg
space_groups['P -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(117, 'P -4 b 2', transformations)
space_groups[117] = sg
space_groups['P -4 b 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(118, 'P -4 n 2', transformations)
space_groups[118] = sg
space_groups['P -4 n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(119, 'I -4 m 2', transformations)
space_groups[119] = sg
space_groups['I -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(120, 'I -4 c 2', transformations)
space_groups[120] = sg
space_groups['I -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(121, 'I -4 2 m', transformations)
space_groups[121] = sg
space_groups['I -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(122, 'I -4 2 d', transformations)
space_groups[122] = sg
space_groups['I -4 2 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(123, 'P 4/m m m', transformations)
space_groups[123] = sg
space_groups['P 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(124, 'P 4/m c c', transformations)
space_groups[124] = sg
space_groups['P 4/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(125, 'P 4/n b m :2', transformations)
space_groups[125] = sg
space_groups['P 4/n b m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(126, 'P 4/n n c :2', transformations)
space_groups[126] = sg
space_groups['P 4/n n c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(127, 'P 4/m b m', transformations)
space_groups[127] = sg
space_groups['P 4/m b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(128, 'P 4/m n c', transformations)
space_groups[128] = sg
space_groups['P 4/m n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(129, 'P 4/n m m :2', transformations)
space_groups[129] = sg
space_groups['P 4/n m m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(130, 'P 4/n c c :2', transformations)
space_groups[130] = sg
space_groups['P 4/n c c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(131, 'P 42/m m c', transformations)
space_groups[131] = sg
space_groups['P 42/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(132, 'P 42/m c m', transformations)
space_groups[132] = sg
space_groups['P 42/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(133, 'P 42/n b c :2', transformations)
space_groups[133] = sg
space_groups['P 42/n b c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(134, 'P 42/n n m :2', transformations)
space_groups[134] = sg
space_groups['P 42/n n m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(135, 'P 42/m b c', transformations)
space_groups[135] = sg
space_groups['P 42/m b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(136, 'P 42/m n m', transformations)
space_groups[136] = sg
space_groups['P 42/m n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(137, 'P 42/n m c :2', transformations)
space_groups[137] = sg
space_groups['P 42/n m c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(138, 'P 42/n c m :2', transformations)
space_groups[138] = sg
space_groups['P 42/n c m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(139, 'I 4/m m m', transformations)
space_groups[139] = sg
space_groups['I 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(140, 'I 4/m c m', transformations)
space_groups[140] = sg
space_groups['I 4/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(141, 'I 41/a m d :2', transformations)
space_groups[141] = sg
space_groups['I 41/a m d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(142, 'I 41/a c d :2', transformations)
space_groups[142] = sg
space_groups['I 41/a c d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(143, 'P 3', transformations)
space_groups[143] = sg
space_groups['P 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(144, 'P 31', transformations)
space_groups[144] = sg
space_groups['P 31'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(145, 'P 32', transformations)
space_groups[145] = sg
space_groups['P 32'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(146, 'R 3 :H', transformations)
space_groups[146] = sg
space_groups['R 3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(147, 'P -3', transformations)
space_groups[147] = sg
space_groups['P -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(148, 'R -3 :H', transformations)
space_groups[148] = sg
space_groups['R -3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(149, 'P 3 1 2', transformations)
space_groups[149] = sg
space_groups['P 3 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(150, 'P 3 2 1', transformations)
space_groups[150] = sg
space_groups['P 3 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(151, 'P 31 1 2', transformations)
space_groups[151] = sg
space_groups['P 31 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(152, 'P 31 2 1', transformations)
space_groups[152] = sg
space_groups['P 31 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(153, 'P 32 1 2', transformations)
space_groups[153] = sg
space_groups['P 32 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(154, 'P 32 2 1', transformations)
space_groups[154] = sg
space_groups['P 32 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(155, 'R 3 2 :H', transformations)
space_groups[155] = sg
space_groups['R 3 2 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(156, 'P 3 m 1', transformations)
space_groups[156] = sg
space_groups['P 3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(157, 'P 3 1 m', transformations)
space_groups[157] = sg
space_groups['P 3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(158, 'P 3 c 1', transformations)
space_groups[158] = sg
space_groups['P 3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(159, 'P 3 1 c', transformations)
space_groups[159] = sg
space_groups['P 3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(160, 'R 3 m :H', transformations)
space_groups[160] = sg
space_groups['R 3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(161, 'R 3 c :H', transformations)
space_groups[161] = sg
space_groups['R 3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(162, 'P -3 1 m', transformations)
space_groups[162] = sg
space_groups['P -3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(163, 'P -3 1 c', transformations)
space_groups[163] = sg
space_groups['P -3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(164, 'P -3 m 1', transformations)
space_groups[164] = sg
space_groups['P -3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(165, 'P -3 c 1', transformations)
space_groups[165] = sg
space_groups['P -3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(166, 'R -3 m :H', transformations)
space_groups[166] = sg
space_groups['R -3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(167, 'R -3 c :H', transformations)
space_groups[167] = sg
space_groups['R -3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(168, 'P 6', transformations)
space_groups[168] = sg
space_groups['P 6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(169, 'P 61', transformations)
space_groups[169] = sg
space_groups['P 61'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(170, 'P 65', transformations)
space_groups[170] = sg
space_groups['P 65'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(171, 'P 62', transformations)
space_groups[171] = sg
space_groups['P 62'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(172, 'P 64', transformations)
space_groups[172] = sg
space_groups['P 64'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(173, 'P 63', transformations)
space_groups[173] = sg
space_groups['P 63'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(174, 'P -6', transformations)
space_groups[174] = sg
space_groups['P -6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(175, 'P 6/m', transformations)
space_groups[175] = sg
space_groups['P 6/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(176, 'P 63/m', transformations)
space_groups[176] = sg
space_groups['P 63/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(177, 'P 6 2 2', transformations)
space_groups[177] = sg
space_groups['P 6 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(178, 'P 61 2 2', transformations)
space_groups[178] = sg
space_groups['P 61 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(179, 'P 65 2 2', transformations)
space_groups[179] = sg
space_groups['P 65 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(180, 'P 62 2 2', transformations)
space_groups[180] = sg
space_groups['P 62 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(181, 'P 64 2 2', transformations)
space_groups[181] = sg
space_groups['P 64 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(182, 'P 63 2 2', transformations)
space_groups[182] = sg
space_groups['P 63 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(183, 'P 6 m m', transformations)
space_groups[183] = sg
space_groups['P 6 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(184, 'P 6 c c', transformations)
space_groups[184] = sg
space_groups['P 6 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(185, 'P 63 c m', transformations)
space_groups[185] = sg
space_groups['P 63 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(186, 'P 63 m c', transformations)
space_groups[186] = sg
space_groups['P 63 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(187, 'P -6 m 2', transformations)
space_groups[187] = sg
space_groups['P -6 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(188, 'P -6 c 2', transformations)
space_groups[188] = sg
space_groups['P -6 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(189, 'P -6 2 m', transformations)
space_groups[189] = sg
space_groups['P -6 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(190, 'P -6 2 c', transformations)
space_groups[190] = sg
space_groups['P -6 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(191, 'P 6/m m m', transformations)
space_groups[191] = sg
space_groups['P 6/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(192, 'P 6/m c c', transformations)
space_groups[192] = sg
space_groups['P 6/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(193, 'P 63/m c m', transformations)
space_groups[193] = sg
space_groups['P 63/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(194, 'P 63/m m c', transformations)
space_groups[194] = sg
space_groups['P 63/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(195, 'P 2 3', transformations)
space_groups[195] = sg
space_groups['P 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(196, 'F 2 3', transformations)
space_groups[196] = sg
space_groups['F 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(197, 'I 2 3', transformations)
space_groups[197] = sg
space_groups['I 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(198, 'P 21 3', transformations)
space_groups[198] = sg
space_groups['P 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(199, 'I 21 3', transformations)
space_groups[199] = sg
space_groups['I 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(200, 'P m -3', transformations)
space_groups[200] = sg
space_groups['P m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(201, 'P n -3 :2', transformations)
space_groups[201] = sg
space_groups['P n -3 :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(202, 'F m -3', transformations)
space_groups[202] = sg
space_groups['F m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(203, 'F d -3 :2', transformations)
space_groups[203] = sg
space_groups['F d -3 :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(204, 'I m -3', transformations)
space_groups[204] = sg
space_groups['I m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = | N.array([2,1,2]) | numpy.array |
import numpy as np
def ptiread(file_name):
fid = open(file_name, "r", encoding='utf-8', errors='ignore')
headerlinecnt = 1
numref = 1
## Get all information
# get hearder information setup
# first 15 lines are setup info
tline = fid.readline()
# determine start header line
while tline != '[SETUP START]\n':
numref += 1
headerlinecnt += 1
end_setup = numref + 13
tline = fid.readline()
while headerlinecnt<end_setup:
tline = fid.readline()
headerlinecnt = headerlinecnt + 1
if headerlinecnt == (numref+2):
RECInfoSectionSize = int(tline.partition('=')[2])
if headerlinecnt == (numref+3):
RECInfoSectionPos = int(tline.partition('=')[2])
if headerlinecnt==(numref + 4):
SampleFrequency = int(float(tline.partition('=')[2]))
if headerlinecnt==(numref+5):
numchannels = int(tline.partition('=')[2])
if headerlinecnt==(numref+11):
Sample = int(tline.partition('=')[2])
if headerlinecnt==(numref+12):
Date = tline.partition('=')[2]
if headerlinecnt==(numref+13):
Time = tline.partition('=')[2]
## Get channel info
# the most important infor is correction factor
CorrectionFactor = []
for nchann in range(numchannels):
for i in range(10):
tline = fid.readline()
if tline.partition('=')[0] == 'CorrectionFactor':
CorrectionFactor.append(float(tline.partition('=')[2]))
if tline.partition('=')[0] == 'SampleFrequency':
SampleFrequency = int(tline.partition('=')[2])
## Read binary data
# poiter to main data
# 20 bytes may a subheader which may not important
fid.seek( RECInfoSectionPos + RECInfoSectionSize + 20, 0)
# the size of each segment, it around 250 ms
# fro Fs = 8192 Hz, it is 2048*4 bytes data + 4*4 bytes info (channel id)
dsize = | np.fromfile(fid, dtype=np.int16, count=1) | numpy.fromfile |
""" Implements exhaustive best subset regression for ESL."""
import numpy as np
import copy
import itertools as itr
from typing import List
from sklearn.linear_model import LinearRegression
from .esl_regressor import EslRegressor
class BestSubsetRegression(EslRegressor):
""" Exhaustive best subset regression for ESL."""
def __init__(self, subset_size: int):
""" Instantiates a Best Subset regressor.
Args:
regressor: regressor used for regression after subset selection.
subset_size: subset size.
"""
self.subset_size = subset_size
self.__best_models = None # type: List[LinearRegression]
self.__best_preds = None # type: np.ndarray # shape: (n_responses, subset_size)
def best_preds(self, i_resp: int):
""" Returns the array of best predictors for a specific response."""
return self.__best_preds[i_resp, :]
def _fit(self, X: np.ndarray, Y: np.ndarray = None):
""" Trains the regressor.
Args:
X: numpy matrix of input features, dimensions ``(N, n_features)``.
Y: 2d numpy array of responses, dimensions ``(N, n_responses)``.
"""
best_scores = np.full(shape=(self._n_responses,), fill_value=-np.inf)
self.__best_models = [None] * self._n_responses
self.__best_preds = | np.zeros((self._n_responses, self.subset_size), dtype=int) | numpy.zeros |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Join Hypocenter-Velocity Inversion on Tetrahedral meshes (JHVIT).
6 functions can be called and run in this package:
1- jntHypoVel_T : Joint hypocenter-velocity inversion of P wave data,
parametrized via the velocity model.
2- jntHyposlow_T : Joint hypocenter-velocity inversion of P wave data,
parametrized via the slowness model.
3- jntHypoVelPS_T : Joint hypocenter-velocity inversion of P- and S-wave data,
parametrized via the velocity models.
4- jntHyposlowPS_T : Joint hypocenter-velocity inversion of P- and S-wave data,
parametrized via the slowness models.
5-jointHypoVel_T : Joint hypocenter-velocity inversion of P wave data.
Input data and inversion parameters are downloaded automatically
from external text files.
6-jointHypoVelPS_T : Joint hypocenter-velocity inversion of P- and S-wave data.
Input data and inversion parameters are downloaded automatically
from external text files.
Notes:
- The package ttcrpy must be installed in order to perform the raytracing step.
This package can be downloaded from: https://ttcrpy.readthedocs.io/en/latest/
- To prevent bugs, it would be better to use python 3.7
Created on Sat Sep 14 2019
@author: <NAME>
"""
import numpy as np
import scipy.sparse as sp
import scipy.sparse.linalg as spl
import scipy.stats as scps
import re
import sys
import copy
from mesh import MSHReader
from ttcrpy import tmesh
from multiprocessing import Pool, cpu_count, current_process, Manager
import multiprocessing as mp
from collections import OrderedDict
try:
import vtk
from vtk.util.numpy_support import numpy_to_vtk
except BaseException:
print('VTK module not found, saving velocity model in vtk form is disabled')
def msh2vtk(nodes, cells, velocity, outputFilename, fieldname="Velocity"):
"""
Generate a vtk file to store the velocity model.
Parameters
----------
nodes : np.ndarray, shape (nnodes, 3)
Node coordinates.
cells : np.ndarray of int, shape (number of cells, 4)
Indices of nodes forming each cell.
velocity : np.ndarray, shape (nnodes, 1)
Velocity model.
outputFilename : string
The output vtk filename.
fieldname : string, optional
The saved field title. The default is "Velocity".
Returns
-------
float
return 0.0 if no bugs occur.
"""
ugrid = vtk.vtkUnstructuredGrid()
tPts = vtk.vtkPoints()
tPts.SetNumberOfPoints(nodes.shape[0])
for n in range(nodes.shape[0]):
tPts.InsertPoint(n, nodes[n, 0], nodes[n, 1], nodes[n, 2])
ugrid.SetPoints(tPts)
VtkVelocity = numpy_to_vtk(velocity, deep=0, array_type=vtk.VTK_DOUBLE)
VtkVelocity.SetName(fieldname)
ugrid.GetPointData().SetScalars(VtkVelocity)
Tetra = vtk.vtkTetra()
for n in np.arange(cells.shape[0]):
Tetra.GetPointIds().SetId(0, cells[n, 0])
Tetra.GetPointIds().SetId(1, cells[n, 1])
Tetra.GetPointIds().SetId(2, cells[n, 2])
Tetra.GetPointIds().SetId(3, cells[n, 3])
ugrid.InsertNextCell(Tetra.GetCellType(), Tetra.GetPointIds())
gWriter = vtk.vtkUnstructuredGridWriter()
gWriter.SetFileName(outputFilename)
gWriter.SetInputData(ugrid)
gWriter.SetFileTypeToBinary()
gWriter.Update()
return 0.0
def check_hypo_indomain(Hypo_new, P_Dimension, Mesh=None):
"""
Check if the new hypocenter is still inside the domain and
project it onto the domain surface otherwise.
Parameters
----------
Hypo_new : np.ndarray, shape (3, ) or (3,1)
The updated hypocenter coordinates.
P_Dimension : np.ndarray, shape (6, )
Domain borders: the maximum and minimum of its 3 dimensions.
Mesh : instance of the class tmesh, optional
The domain discretization. The default is None.
Returns
-------
Hypo_new : np.ndarray, shape (3, )
The input Hypo_new or its projections on the domain surface.
outside : boolean
True if Hypo_new was outside the domain.
"""
outside = False
Hypo_new = Hypo_new.reshape([1, -1])
if Hypo_new[0, 0] < P_Dimension[0]:
Hypo_new[0, 0] = P_Dimension[0]
outside = True
if Hypo_new[0, 0] > P_Dimension[1]:
Hypo_new[0, 0] = P_Dimension[1]
outside = True
if Hypo_new[0, 1] < P_Dimension[2]:
Hypo_new[0, 1] = P_Dimension[2]
outside = True
if Hypo_new[0, 1] > P_Dimension[3]:
Hypo_new[0, 1] = P_Dimension[3]
outside = True
if Hypo_new[0, 2] < P_Dimension[4]:
Hypo_new[0, 2] = P_Dimension[4]
outside = True
if Hypo_new[0, 2] > P_Dimension[5]:
Hypo_new[0, 2] = P_Dimension[5]
outside = True
if Mesh:
if Mesh.is_outside(Hypo_new):
outside = True
Hypout = copy.copy(Hypo_new)
Hypin = np.array([[Hypo_new[0, 0], Hypo_new[0, 1], P_Dimension[4]]])
distance = np.sqrt(np.sum((Hypin - Hypout)**2))
while distance > 1.e-5:
Hmiddle = 0.5 * Hypout + 0.5 * Hypin
if Mesh.is_outside(Hmiddle):
Hypout = Hmiddle
else:
Hypin = Hmiddle
distance = np.sqrt(np.sum((Hypout - Hypin)**2))
Hypo_new = Hypin
return Hypo_new.reshape([-1, ]), outside
class Parameters:
def __init__(self, maxit, maxit_hypo, conv_hypo, Vlim, VpVslim, dmax,
lagrangians, max_sc, invert_vel=True, invert_VsVp=False,
hypo_2step=False, use_sc=True, save_vel=False, uncrtants=False,
confdce_lev=0.95, verbose=False):
"""
Parameters
----------
maxit : int
Maximum number of iterations.
maxit_hypo : int
Maximum number of iterations to update hypocenter coordinates.
conv_hypo : float
Convergence criterion.
Vlim : tuple of 3 or 6 floats
Vlmin holds the maximum and the minimum values of P- and S-wave
velocity models and the slopes of the penalty functions,
example Vlim = (Vpmin, Vpmax, PAp, Vsmin, Vsmax, PAs).
VpVslim : tuple of 3 floats
Upper and lower limits of Vp/Vs ratio and
the slope of the corresponding Vp/Vs penalty function.
dmax : tuple of four floats
It holds the maximum admissible corrections for the velocity models
(dVp_max and dVs_max), the origin time (dt_max) and
the hypocenter coordinates (dx_max).
lagrangians : tuple of 6 floats
Penalty and constraint weights: λ (smoothing constraint weight),
γ (penalty constraint weight), α (weight of velocity data point const-
raint), wzK (vertical smoothing weight), γ_vpvs (penalty constraint
weight of Vp/Vs ratio), stig (weight of the constraint used to impose
statistical moments on Vp/Vs model).
invert_vel : boolean, optional
Perform velocity inversion if True. The default is True.
invert_VsVp : boolean, optional
Find Vp/Vs ratio model rather than S wave model. The default is False.
hypo_2step : boolean, optional
Relocate hypocenter events in 2 steps. The default is False.
use_sc : boolean, optional
Use static corrections. The default is 'True'.
save_vel : string, optional
Save intermediate velocity models or the final model.
The default is False.
uncrtants : boolean, optional
Calculate the uncertainty of the hypocenter parameters.
The default is False.
confdce_lev : float, optional
The confidence coefficient to calculate the uncertainty.
The default is 0.95.
verbose : boolean, optional
Print information messages about inversion progression.
The default is False.
Returns
-------
None.
"""
self.maxit = maxit
self.maxit_hypo = maxit_hypo
self.conv_hypo = conv_hypo
self.Vpmin = Vlim[0]
self.Vpmax = Vlim[1]
self.PAp = Vlim[2]
if len(Vlim) > 3:
self.Vsmin = Vlim[3]
self.Vsmax = Vlim[4]
self.PAs = Vlim[5]
self.VpVsmin = VpVslim[0]
self.VpVsmax = VpVslim[1]
self.Pvpvs = VpVslim[2]
self.dVp_max = dmax[0]
self.dx_max = dmax[1]
self.dt_max = dmax[2]
if len(dmax) > 3:
self.dVs_max = dmax[3]
self.λ = lagrangians[0]
self.γ = lagrangians[1]
self.γ_vpvs = lagrangians[2]
self.α = lagrangians[3]
self.stig = lagrangians[4]
self.wzK = lagrangians[5]
self.invert_vel = invert_vel
self.invert_VpVs = invert_VsVp
self.hypo_2step = hypo_2step
self.use_sc = use_sc
self.max_sc = max_sc
self.p = confdce_lev
self.uncertainty = uncrtants
self.verbose = verbose
self.saveVel = save_vel
def __str__(self):
"""
Encapsulate the attributes of the class Parameters in a string.
Returns
-------
output : string
Attributes of the class Parameters written in string.
"""
output = "-------------------------\n"
output += "\nParameters of Inversion :\n"
output += "\n-------------------------\n"
output += "\nMaximum number of iterations : {0:d}\n".format(self.maxit)
output += "\nMaximum number of iterations to get hypocenters"
output += ": {0:d}\n".format(self.maxit_hypo)
output += "\nVp minimum : {0:4.2f} km/s\n".format(self.Vpmin)
output += "\nVp maximum : {0:4.2f} km/s\n".format(self.Vpmax)
if self.Vsmin:
output += "\nVs minimum : {0:4.2f} km/s\n".format(self.Vsmin)
if self.Vsmax:
output += "\nVs maximum : {0:4.2f} km/s\n".format(self.Vsmax)
if self.VpVsmin:
output += "\nVpVs minimum : {0:4.2f} km/s\n".format(self.VpVsmin)
if self.VpVsmax:
output += "\nVpVs maximum : {0:4.2f} km/s\n".format(self.VpVsmax)
output += "\nSlope of the penalty function (P wave) : {0:3f}\n".format(
self.PAp)
if self.PAs:
output += "\nSlope of the penalty function (S wave) : {0:3f}\n".format(
self.PAs)
if self.Pvpvs:
output += "\nSlope of the penalty function"
output += "(VpVs ratio wave) : {0:3f}\n".format(self.Pvpvs)
output += "\nMaximum time perturbation by step : {0:4.3f} s\n".format(
self.dt_max)
output += "\nMaximum distance perturbation by step : {0:4.3f} km\n".format(
self.dx_max)
output += "\nMaximum P wave velocity correction by step"
output += " : {0:4.3f} km/s\n".format(self.dVp_max)
if self.dVs_max:
output += "\nMaximum S wave velocity correction by step"
output += " : {0:4.3f} km/s\n".format(self.dVs_max)
output += "\nLagrangians parameters : λ = {0:1.1e}\n".format(self.λ)
output += " : γ = {0:1.1e}\n".format(self.γ)
if self.γ_vpvs:
output += " : γ VpVs ratio = {0:1.1e}\n".format(
self.γ_vpvs)
output += " : α = {0:1.1e}\n".format(self.α)
output += " : wzK factor = {0:4.2f}\n".format(
self.wzK)
if self.stig:
output += " : stats. moment. penalty"
output += "coef. = {0:1.1e}\n".format(self.stig)
output += "\nOther parameters : Inverse Velocity = {0}\n".format(
self.invert_vel)
output += "\n : Use Vs/Vp instead of Vs = {0}\n".format(
self.invert_VpVs)
output += "\n : Use static correction = {0}\n".format(
self.use_sc)
output += "\n : Hyp. parameter Uncertainty estimation = "
output += "{0}\n".format(self.uncertainty)
if self.uncertainty:
output += "\n with a confidence level of"
output += " {0:3.2f}\n".format(self.p)
if self.saveVel == 'last':
output += "\n : Save intermediate velocity models = "
output += "last iteration only\n"
elif self.saveVel == 'all':
output += "\n : Save intermediate velocity models = "
output += "all iterations\n"
else:
output += "\n : Save intermediate velocity models = "
output += "False\n"
output += "\n : Relocate hypoctenters using 2 steps = "
output += "{0}\n".format(self.hypo_2step)
output += "\n : convergence criterion = {0:3.4f}\n".format(
self.conv_hypo)
if self.use_sc:
output += "\n : Maximum static correction = "
output += "{0:3.2f}\n".format(self.max_sc)
return output
class fileReader:
def __init__(self, filename):
"""
Parameters
----------
filename : string
List of data files and other inversion parameters.
Returns
-------
None.
"""
try:
open(filename, 'r')
except IOError:
print("Could not read file:", filename)
sys.exit()
self.filename = filename
assert(self.readParameter('base name')), 'invalid base name'
assert(self.readParameter('mesh file')), 'invalid mesh file'
assert(self.readParameter('rcvfile')), 'invalid rcv file'
assert(self.readParameter('Velocity')), 'invalid Velocity file'
assert(self.readParameter('Time calibration')
), 'invalid calibration data file'
def readParameter(self, parameter, dtype=None):
"""
Read the data filename or the inversion parameter value specified by
the argument parameter.
Parameters
----------
parameter : string
Filename or inversion parameter to read.
dtype : data type, optional
Explicit data type of the filename or the parameter read.
The default is None.
Returns
-------
param : string/int/float
File or inversion parameter.
"""
try:
f = open(self.filename, 'r')
for line in f:
if line.startswith(parameter):
position = line.find(':')
param = line[position + 1:]
param = param.rstrip("\n\r")
if dtype is None:
break
if dtype == int:
param = int(param)
elif dtype == float:
param = float(param)
elif dtype == bool:
if param == 'true' or param == 'True' or param == '1':
param = True
elif param == 'false' or param == 'False' or param == '0':
param = False
else:
print(" non recognized format")
break
return param
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to a float for " + parameter + "\n")
except NameError as NErr:
print(
parameter +
" is not indicated or has bad value:{0}".format(NErr))
except BaseException:
print("Unexpected error:", sys.exc_info()[0])
raise
finally:
f.close()
def saveVel(self):
"""
Method to read the specified option for saving the velocity model(s).
Returns
-------
bool/string
Save or not the velocity model(s) and for which iteration.
"""
try:
f = open(self.filename, 'r')
for line in f:
if line.startswith('Save Velocity'):
position = line.find(':')
if position > 0:
sv = line[position + 1:].strip()
break
f.close()
if sv == 'last' or sv == 'Last':
return 'last'
elif sv == 'all' or sv == 'All':
return 'all'
elif sv == 'false' or sv == 'False' or sv == '0':
return False
else:
print('bad option to save velocity: default value will be used')
return False
except OSError as err:
print("OS error: {0}".format(err))
except NameError as NErr:
print("save velocity is not indicated :{0}".format(NErr))
except BaseException:
print("Unexpected error:", sys.exc_info()[0])
raise
def getIversionParam(self):
"""
Read the inversion parameters and
store them in an object of the class Parameters.
Returns
-------
Params : instance of the class Parameters
Inversion parameters and options.
"""
maxit = self.readParameter('number of iterations', int)
maxit_hypo = self.readParameter('num. iters. to get hypo.', int)
conv_hypo = self.readParameter('convergence Criterion', float)
Vpmin = self.readParameter('Vpmin', float)
Vpmax = self.readParameter('Vpmax', float)
PAp = self.readParameter('PAp', float)
if PAp is None or PAp < 0:
print('PAp : default value will be considered\n')
PAp = 1. # default value
Vsmin = self.readParameter('Vsmin', float)
Vsmax = self.readParameter('Vsmax', float)
PAs = self.readParameter('PAs', float)
if PAs is None or PAs < 0:
print('PAs : default value will be considered\n')
PAs = 1. # default value
VpVsmax = self.readParameter('VpVs_max', float)
if VpVsmax is None or VpVsmax < 0:
print('default value will be considered (5)\n')
VpVsmax = 5. # default value
VpVsmin = self.readParameter('VpVs_min', float)
if VpVsmin is None or VpVsmin < 0:
print('default value will be considered (1.5)\n')
VpVsmin = 1.5 # default value
Pvpvs = self.readParameter('Pvpvs', float)
if Pvpvs is None or Pvpvs < 0:
print('default value will be considered\n')
Pvpvs = 1. # default value
dVp_max = self.readParameter('dVp max', float)
dVs_max = self.readParameter('dVs max', float)
dx_max = self.readParameter('dx max', float)
dt_max = self.readParameter('dt max', float)
Alpha = self.readParameter('alpha', float)
Lambda = self.readParameter('lambda', float)
Gamma = self.readParameter('Gamma', float)
Gamma_ps = self.readParameter('Gamma_vpvs', float)
stigma = self.readParameter('stigma', float)
if stigma is None or stigma < 0:
stigma = 0. # default value
VerSmooth = self.readParameter('vertical smoothing', float)
InverVel = self.readParameter('inverse velocity', bool)
InverseRatio = self.readParameter('inverse Vs/Vp', bool)
Hyp2stp = self.readParameter('reloc.hypo.in 2 steps', bool)
Sc = self.readParameter('use static corrections', bool)
if Sc:
Sc_max = self.readParameter('maximum stat. correction', float)
else:
Sc_max = 0.
uncrtants = self.readParameter('uncertainty estm.', bool)
if uncrtants:
confdce_lev = self.readParameter('confidence level', float)
else:
confdce_lev = np.NAN
Verb = self.readParameter('Verbose ', bool)
saveVel = self.saveVel()
Params = Parameters(maxit, maxit_hypo, conv_hypo,
(Vpmin, Vpmax, PAp, Vsmin, Vsmax, PAs),
(VpVsmin, VpVsmax, Pvpvs),
(dVp_max, dx_max, dt_max, dVs_max),
(Lambda, Gamma, Gamma_ps, Alpha, stigma,
VerSmooth), Sc_max, InverVel, InverseRatio,
Hyp2stp, Sc, saveVel, uncrtants, confdce_lev, Verb)
return Params
class RCVReader:
def __init__(self, p_rcvfile):
"""
Parameters
----------
p_rcvfile : string
File holding receiver coordinates.
Returns
-------
None.
"""
self.rcv_file = p_rcvfile
assert(self.__ChekFormat()), 'invalid format for rcv file'
def getNumberOfStation(self):
"""
Return the number of receivers.
Returns
-------
Nstations : int
Receiver number.
"""
try:
fin = open(self.rcv_file, 'r')
Nstations = int(fin.readline())
fin.close()
return Nstations
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer for the station number.")
except BaseException:
print("Unexpected error:", sys.exc_info()[0])
raise
def getStation(self):
"""
Return coordinates of receivers.
Returns
-------
coordonates : np.ndarray, shape(receiver number,3)
Receiver coordinates.
"""
try:
fin = open(self.rcv_file, 'r')
Nsta = int(fin.readline())
coordonates = np.zeros([Nsta, 3])
for n in range(Nsta):
line = fin.readline()
Coord = re.split(r' ', line)
coordonates[n, 0] = float(Coord[0])
coordonates[n, 1] = float(Coord[2])
coordonates[n, 2] = float(Coord[4])
fin.close()
return coordonates
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to a float in rcvfile.")
except BaseException:
print("Unexpected error:", sys.exc_info()[0])
raise
def __ChekFormat(self):
try:
fin = open(self.rcv_file)
n = 0
for line in fin:
if n == 0:
Nsta = int(line)
num_lines = sum(1 for line in fin)
if(num_lines != Nsta):
fin.close()
return False
if n > 0:
Coord = re.split(r' ', line)
if len(Coord) != 5:
fin.close()
return False
n += 1
fin.close()
return True
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to a float in rcvfile.")
except BaseException:
print("Unexpected error:", sys.exc_info()[0])
raise
def readEventsFiles(time_file, waveType=False):
"""
Read a list of seismic events and corresponding data from a text file.
Parameters
----------
time_file : string
Event data filename.
waveType : bool
True if the seismic phase of each event is identified.
The default is False.
Returns
-------
data : np.ndarray or a list of two np.ndarrays
Event arrival time data
"""
if (time_file == ""):
if not waveType:
return (np.array([]))
elif waveType:
return (np.array([]), np.array([]))
try:
fin = open(time_file, 'r')
lstart = 0
for line in fin:
lstart += 1
if line.startswith('Ev_idn'):
break
if not waveType:
data = np.loadtxt(time_file, skiprows=lstart, ndmin=2)
elif waveType:
data = np.loadtxt(fname=time_file, skiprows=2,
dtype='S15', ndmin=2)
ind = np.where(data[:, -1] == b'P')[0]
dataP = data[ind, :-1].astype(float)
ind = np.where(data[:, -1] == b'S')[0]
dataS = data[ind, :-1].astype(float)
data = (dataP, dataS)
return data
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to a float in " + time_file + " file.")
except BaseException:
print("Unexpected error:", sys.exc_info()[0])
raise
def readVelpoints(vlpfile):
"""
Read known velocity points from a text file.
Parameters
----------
vlpfile : string
Name of the file containing the known velocity points.
Returns
-------
data : np.ndarray, shape (number of points , 3)
Data corresponding to the known velocity points.
"""
if (vlpfile == ""):
return (np.array([]))
try:
fin = open(vlpfile, 'r')
lstart = 0
for line in fin:
lstart += 1
if line.startswith('Pt_id'):
break
data = np.loadtxt(vlpfile, skiprows=lstart)
return data
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to a float in " + vlpfile + " file.")
except BaseException:
print("Unexpected error:", sys.exc_info()[0])
raise
def _hypo_relocation(ev, evID, hypo, data, rcv, sc, convergence, par):
"""
Location of a single hypocenter event using P arrival time data.
Parameters
----------
ev : int
Event index in the array evID.
evID : np.ndarray, shape (number of events ,)
Event indices.
hypo : np.ndarray, shape (number of events ,5)
Current hypocenter coordinates and origin time for each event.
data : np.ndarray, shape (arrival times number,3)
Arrival times for all events.
rcv : np.ndarray, shape (receiver number,3)
Coordinates of receivers.
sc : np.ndarray, shape (receiver number or 0 ,1)
Static correction values.
convergence : boolean list, shape (event number)
Convergence state of each event.
par : instance of the class Parameters
The inversion parameters.
Returns
-------
Hypocenter : np.ndarray, shape (5,)
Updated origin time and coordinates of event evID[ev].
"""
indh = np.where(hypo[:, 0] == evID[ev])[0]
if par.verbose:
print("\nEven N {0:d} is relacated in the ".format(
int(hypo[ev, 0])) + current_process().name + '\n')
sys.stdout.flush()
indr = np.where(data[:, 0] == evID[ev])[0]
rcv_ev = rcv[data[indr, 2].astype(int) - 1, :]
if par.use_sc:
sc_ev = sc[data[indr, 2].astype(int) - 1]
else:
sc_ev = 0.
nst = indr.size
Hypocenter = hypo[indh[0]].copy()
if par.hypo_2step:
print("\nEven N {0:d}: Update longitude and latitude\n".format(
int(hypo[ev, 0])))
sys.stdout.flush()
T0 = np.kron(hypo[indh, 1], np.ones([nst, 1]))
for It in range(par.maxit_hypo):
Tx = np.kron(Hypocenter[2:], np.ones([nst, 1]))
src = np.hstack((ev*np.ones([nst, 1]), T0 + sc_ev, Tx))
tcal, rays = Mesh3D.raytrace(source=src, rcv=rcv_ev, slowness=None,
aggregate_src=False, compute_L=False,
return_rays=True)
slow_0 = Mesh3D.get_s0(src)
Hi = np.ones((nst, 2))
for nr in range(nst):
rayi = rays[nr]
if rayi.shape[0] == 1:
print('\033[43m' + '\nWarning: raypath failed to converge'
' for even N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and '
'receiver N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(data[indr[nr], 0]),
Tx[nr, 0], Tx[nr, 1], Tx[nr, 2],
int(data[indr[nr], 2]), rcv_ev[nr, 0],
rcv_ev[nr, 1], rcv_ev[nr, 2]) + '\033[0m')
sys.stdout.flush()
continue
slw0 = slow_0[nr]
dx = rayi[1, 0] - Hypocenter[2]
dy = rayi[1, 1] - Hypocenter[3]
dz = rayi[1, 2] - Hypocenter[4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 0] = -dx * slw0 / ds
Hi[nr, 1] = -dy * slw0 / ds
convrays = np.where(tcal != 0)[0]
res = data[indr, 1] - tcal
if convrays.size < nst:
res = res[convrays]
Hi = Hi[convrays, :]
deltaH = np.linalg.lstsq(Hi, res, rcond=1.e-6)[0]
if not np.all(np.isfinite(deltaH)):
try:
U, S, VVh = np.linalg.svd(Hi.T.dot(Hi) + 1e-9 * np.eye(2))
VV = VVh.T
deltaH = np.dot(VV, np.dot(U.T, Hi.T.dot(res)) / S)
except np.linalg.linalg.LinAlgError:
print('\nEvent could not be relocated (iteration no ' +
str(It) + '), skipping')
sys.stdout.flush()
break
indH = np.abs(deltaH) > par.dx_max
deltaH[indH] = par.dx_max * np.sign(deltaH[indH])
updatedHypo = np.hstack((Hypocenter[2:4] + deltaH, Hypocenter[-1]))
updatedHypo, _ = check_hypo_indomain(updatedHypo, Dimensions,
Mesh3D)
Hypocenter[2:] = updatedHypo
if np.all(np.abs(deltaH[1:]) < par.conv_hypo):
break
if par.verbose:
print("\nEven N {0:d}: Update all parameters\n".format(int(hypo[ev, 0])))
sys.stdout.flush()
for It in range(par.maxit_hypo):
Tx = np.kron(Hypocenter[2:], np.ones([nst, 1]))
T0 = np.kron(Hypocenter[1], np.ones([nst, 1]))
src = np.hstack((ev*np.ones([nst, 1]), T0 + sc_ev, Tx))
tcal, rays = Mesh3D.raytrace(source=src, rcv=rcv_ev, slowness=None,
aggregate_src=False, compute_L=False,
return_rays=True)
slow_0 = Mesh3D.get_s0(src)
Hi = np.ones([nst, 4])
for nr in range(nst):
rayi = rays[nr]
if rayi.shape[0] == 1:
print('\033[43m' + '\nWarning: raypath failed to converge '
'for even N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and '
'receiver N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(data[indr[nr], 0]), Tx[nr, 0],
Tx[nr, 1], Tx[nr, 2], int(data[indr[nr], 2]),
rcv_ev[nr, 0], rcv_ev[nr, 1], rcv_ev[nr, 2]) + '\033[0m')
sys.stdout.flush()
continue
slw0 = slow_0[nr]
dx = rayi[1, 0] - Hypocenter[2]
dy = rayi[1, 1] - Hypocenter[3]
dz = rayi[1, 2] - Hypocenter[4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 1] = -dx * slw0 / ds
Hi[nr, 2] = -dy * slw0 / ds
Hi[nr, 3] = -dz * slw0 / ds
convrays = np.where(tcal != 0)[0]
res = data[indr, 1] - tcal
if convrays.size < nst:
res = res[convrays]
Hi = Hi[convrays, :]
deltaH = np.linalg.lstsq(Hi, res, rcond=1.e-6)[0]
if not np.all(np.isfinite(deltaH)):
try:
U, S, VVh = np.linalg.svd(Hi.T.dot(Hi) + 1e-9 * np.eye(4))
VV = VVh.T
deltaH = np.dot(VV, np.dot(U.T, Hi.T.dot(res)) / S)
except np.linalg.linalg.LinAlgError:
print('\nEvent cannot be relocated (iteration no ' +
str(It) + '), skipping')
sys.stdout.flush()
break
if np.abs(deltaH[0]) > par.dt_max:
deltaH[0] = par.dt_max * np.sign(deltaH[0])
if np.linalg.norm(deltaH[1:]) > par.dx_max:
deltaH[1:] *= par.dx_max / np.linalg.norm(deltaH[1:])
updatedHypo = Hypocenter[2:] + deltaH[1:]
updatedHypo, outside = check_hypo_indomain(updatedHypo,
Dimensions, Mesh3D)
Hypocenter[1:] = np.hstack((Hypocenter[1] + deltaH[0], updatedHypo))
if outside and It == par.maxit_hypo - 1:
print('\nEvent N {0:d} cannot be relocated inside the domain\n'.format(
int(hypo[ev, 0])))
convergence[ev] = 'out'
return Hypocenter
if np.all(np.abs(deltaH[1:]) < par.conv_hypo):
convergence[ev] = True
if par.verbose:
print('\033[42m' + '\nEven N {0:d} has converged at {1:d}'
' iteration(s)\n'.format(int(hypo[ev, 0]), It + 1) + '\n'
+ '\033[0m')
sys.stdout.flush()
break
else:
if par.verbose:
print('\nEven N {0:d} : maximum number of iterations'
' was reached\n'.format(int(hypo[ev, 0])) + '\n')
sys.stdout.flush()
return Hypocenter
def _hypo_relocationPS(ev, evID, hypo, data, rcv, sc, convergence, slow, par):
"""
Relocate a single hypocenter event using P- and S-wave arrival times.
Parameters
----------
ev : int
Event index in the array evID.
evID : np.ndarray, shape (event number ,)
Event indices.
hypo : np.ndarray, shape (event number ,5)
Current hypocenter coordinates and origin times for each event.
data : tuple of two np.ndarrays
Arrival times of P- and S-waves.
rcv : np.ndarray, shape (receiver number,3)
Coordinates of receivers.
sc : tuple of two np.ndarrays (shape(receiver number or 0,1))
Static correction values of P- and S-waves.
convergence : boolean list, shape (event number)
The convergence state of each event.
slow : tuple of two np.ndarrays (shape(nnodes,1))
P and S slowness models.
par : instance of the class Parameters
The inversion parameters.
Returns
-------
Hypocenter : np.ndarray, shape (5,)
Updated origin time and coordinates of event evID[ev].
"""
(slowP, slowS) = slow
(scp, scs) = sc
(dataP, dataS) = data
indh = np.where(hypo[:, 0] == evID[ev])[0]
if par.verbose:
print("Even N {0:d} is relacated in the ".format(
int(hypo[ev, 0])) + current_process().name + '\n')
sys.stdout.flush()
indrp = np.where(dataP[:, 0] == evID[ev])[0]
rcv_evP = rcv[dataP[indrp, 2].astype(int) - 1, :]
nstP = indrp.size
indrs = np.where(dataS[:, 0] == evID[ev])[0]
rcv_evS = rcv[dataS[indrs, 2].astype(int) - 1, :]
nstS = indrs.size
Hypocenter = hypo[indh[0]].copy()
if par.use_sc:
scp_ev = scp[dataP[indrp, 2].astype(int) - 1]
scs_ev = scs[dataS[indrs, 2].astype(int) - 1]
else:
scp_ev = np.zeros([nstP, 1])
scs_ev = np.zeros([nstS, 1])
if par.hypo_2step:
if par.verbose:
print("\nEven N {0:d}: Update longitude and latitude\n".format(
int(hypo[ev, 0])))
sys.stdout.flush()
for It in range(par.maxit_hypo):
Txp = np.kron(Hypocenter[1:], np.ones([nstP, 1]))
Txp[:, 0] += scp_ev[:, 0]
srcP = np.hstack((ev*np.ones([nstP, 1]), Txp))
tcalp, raysP = Mesh3D.raytrace(source=srcP, rcv=rcv_evP, slowness=slowP,
aggregate_src=False, compute_L=False,
return_rays=True)
slowP_0 = Mesh3D.get_s0(srcP)
Txs = np.kron(Hypocenter[1:], np.ones([nstS, 1]))
Txs[:, 0] += scs_ev[:, 0]
srcS = np.hstack((ev*np.ones([nstS, 1]), Txs))
tcals, raysS = Mesh3D.raytrace(source=srcS, rcv=rcv_evS, slowness=slowS,
aggregate_src=False, compute_L=False,
return_rays=True)
slowS_0 = Mesh3D.get_s0(srcS)
Hi = np.ones((nstP + nstS, 2))
for nr in range(nstP):
rayi = raysP[nr]
if rayi.shape[0] == 1:
if par.verbose:
print('\033[43m' +
'\nWarning: raypath failed to converge for even '
'N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f})and receiver '
'N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(dataP[indrp[nr], 0]),
Txp[nr, 1], Txp[nr, 2], Txp[nr, 3],
int(dataP[indrp[nr], 2]),
rcv_evP[nr, 0], rcv_evP[nr, 1],
rcv_evP[nr, 2]) +
'\033[0m')
sys.stdout.flush()
continue
slw0 = slowP_0[nr]
dx = rayi[1, 0] - Hypocenter[2]
dy = rayi[1, 1] - Hypocenter[3]
dz = rayi[1, 2] - Hypocenter[4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 0] = -dx * slw0 / ds
Hi[nr, 1] = -dy * slw0 / ds
for nr in range(nstS):
rayi = raysS[nr]
if rayi.shape[0] == 1:
if par.verbose:
print('\033[43m' +
'\nWarning: raypath failed to converge for even '
'N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver '
'N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(dataS[indrs[nr], 0]),
Txs[nr, 1], Txs[nr, 2],
Txs[nr, 3], int(dataS[indrs[nr], 2]),
rcv_evS[nr, 0], rcv_evS[nr, 1],
rcv_evS[nr, 2]) +
'\033[0m')
sys.stdout.flush()
continue
slw0 = slowS_0[nr]
dx = rayi[1, 0] - Hypocenter[2]
dy = rayi[1, 1] - Hypocenter[3]
dz = rayi[1, 2] - Hypocenter[4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr + nstP, 0] = -dx * slw0 / ds
Hi[nr + nstP, 1] = -dy * slw0 / ds
tcal = np.hstack((tcalp, tcals))
res = np.hstack((dataP[indrp, 1], dataS[indrs, 1])) - tcal
convrays = np.where(tcal != 0)[0]
if convrays.size < (nstP + nstS):
res = res[convrays]
Hi = Hi[convrays, :]
deltaH = np.linalg.lstsq(Hi, res, rcond=1.e-6)[0]
if not np.all(np.isfinite(deltaH)):
try:
U, S, VVh = np.linalg.svd(Hi.T.dot(Hi) + 1e-9 * np.eye(2))
VV = VVh.T
deltaH = np.dot(VV, np.dot(U.T, Hi.T.dot(res)) / S)
except np.linalg.linalg.LinAlgError:
if par.verbose:
print('\nEvent could not be relocated (iteration no ' +
str(It) + '), skipping')
sys.stdout.flush()
break
indH = np.abs(deltaH) > par.dx_max
deltaH[indH] = par.dx_max * np.sign(deltaH[indH])
updatedHypo = np.hstack((Hypocenter[2:4] + deltaH, Hypocenter[-1]))
updatedHypo, _ = check_hypo_indomain(updatedHypo, Dimensions,
Mesh3D)
Hypocenter[2:] = updatedHypo
if np.all(np.abs(deltaH) < par.conv_hypo):
break
if par.verbose:
print("\nEven N {0:d}: Update all parameters\n".format(int(hypo[ev, 0])))
sys.stdout.flush()
for It in range(par.maxit_hypo):
Txp = np.kron(Hypocenter[1:], np.ones([nstP, 1]))
Txp[:, 0] += scp_ev[:, 0]
srcP = np.hstack((ev*np.ones([nstP, 1]), Txp))
tcalp, raysP = Mesh3D.raytrace(source=srcP, rcv=rcv_evP, slowness=slowP,
aggregate_src=False, compute_L=False,
return_rays=True)
slowP_0 = Mesh3D.get_s0(srcP)
Txs = np.kron(Hypocenter[1:], np.ones([nstS, 1]))
Txs[:, 0] += scs_ev[:, 0]
srcS = np.hstack((ev*np.ones([nstS, 1]), Txs))
tcals, raysS = Mesh3D.raytrace(source=srcS, rcv=rcv_evS, slowness=slowS,
aggregate_src=False, compute_L=False,
return_rays=True)
slowS_0 = Mesh3D.get_s0(srcS)
Hi = np.ones((nstP + nstS, 4))
for nr in range(nstP):
rayi = raysP[nr]
if rayi.shape[0] == 1:
if par.verbose:
print('\033[43m' + '\nWarning: raypath failed to converge for '
'even N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver '
'N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(dataP[indrp[nr], 0]), Txp[nr, 1],
Txp[nr, 2], Txp[nr, 3], int(dataP[indrp[nr], 2]),
rcv_evP[nr, 0], rcv_evP[nr, 1],
rcv_evP[nr, 2]) + '\033[0m')
sys.stdout.flush()
continue
slw0 = slowP_0[nr]
dx = rayi[2, 0] - Hypocenter[2]
dy = rayi[2, 1] - Hypocenter[3]
dz = rayi[2, 2] - Hypocenter[4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 1] = -dx * slw0 / ds
Hi[nr, 2] = -dy * slw0 / ds
Hi[nr, 3] = -dz * slw0 / ds
for nr in range(nstS):
rayi = raysS[nr]
if rayi.shape[0] == 1:
if par.verbose:
print('\033[43m' + '\nWarning: raypath failed to converge for '
'even N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver '
'N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(dataS[indrs[nr], 0]), Txs[nr, 1],
Txs[nr, 2], Txs[nr, 3], int(dataS[indrs[nr], 2]),
rcv_evS[nr, 0], rcv_evS[nr, 1],
rcv_evS[nr, 2]) + '\033[0m')
sys.stdout.flush()
continue
slw0 = slowS_0[nr]
dx = rayi[1, 0] - Hypocenter[2]
dy = rayi[1, 1] - Hypocenter[3]
dz = rayi[1, 2] - Hypocenter[4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr + nstP, 1] = -dx * slw0 / ds
Hi[nr + nstP, 2] = -dy * slw0 / ds
Hi[nr + nstP, 3] = -dz * slw0 / ds
tcal = np.hstack((tcalp, tcals))
res = np.hstack((dataP[indrp, 1], dataS[indrs, 1])) - tcal
convrays = np.where(tcal != 0)[0]
if convrays.size < (nstP + nstS):
res = res[convrays]
Hi = Hi[convrays, :]
deltaH = np.linalg.lstsq(Hi, res, rcond=1.e-6)[0]
if not np.all(np.isfinite(deltaH)):
try:
U, S, VVh = np.linalg.svd(Hi.T.dot(Hi) + 1e-9 * np.eye(4))
VV = VVh.T
deltaH = np.dot(VV, np.dot(U.T, Hi.T.dot(res)) / S)
except np.linalg.linalg.LinAlgError:
if par.verbose:
print('\nEvent could not be relocated (iteration no ' +
str(It) + '), skipping\n')
sys.stdout.flush()
break
if np.abs(deltaH[0]) > par.dt_max:
deltaH[0] = par.dt_max * np.sign(deltaH[0])
if np.linalg.norm(deltaH[1:]) > par.dx_max:
deltaH[1:] *= par.dx_max / np.linalg.norm(deltaH[1:])
updatedHypo = Hypocenter[2:] + deltaH[1:]
updatedHypo, outside = check_hypo_indomain(updatedHypo,
Dimensions, Mesh3D)
Hypocenter[1:] = np.hstack((Hypocenter[1] + deltaH[0], updatedHypo))
if outside and It == par.maxit_hypo - 1:
if par.verbose:
print('\nEvent N {0:d} could not be relocated inside '
'the domain\n'.format(int(hypo[ev, 0])))
sys.stdout.flush()
convergence[ev] = 'out'
return Hypocenter
if np.all(np.abs(deltaH[1:]) < par.conv_hypo):
convergence[ev] = True
if par.verbose:
print('\033[42m' + '\nEven N {0:d} has converged at '
' iteration {1:d}\n'.format(int(hypo[ev, 0]), It + 1) +
'\n' + '\033[0m')
sys.stdout.flush()
break
else:
if par.verbose:
print('\nEven N {0:d} : maximum number of iterations was'
' reached'.format(int(hypo[ev, 0])) + '\n')
sys.stdout.flush()
return Hypocenter
def _uncertaintyEstimat(ev, evID, hypo, data, rcv, sc, slow, par, varData=None):
"""
Estimate origin time uncertainty and confidence ellipsoid.
Parameters
----------
ev : int
Event index in the array evID.
evID : np.ndarray, shape (event number,)
Event indices.
hypo : np.ndarray, shape (event number,5)
Estimated hypocenter coordinates and origin time.
data : np.ndarray, shape (arrival time number,3) or
tuple if both P and S waves are used.
Arrival times of seismic events.
rcv : np.ndarray, shape (receiver number ,3)
coordinates of receivers.
sc : np.ndarray, shape (receiver number or 0 ,1) or
tuple if both P and S waves are used.
Static correction values.
slow : np.ndarray or tuple, shape(nnodes,1)
P or P and S slowness models.
par : instance of the class Parameters
The inversion parameters.
varData : list of two lists
Number of arrival times and the sum of residuals needed to
compute the noise variance. See Block's Thesis, 1991 (P. 63)
The default is None.
Returns
-------
to_confInterv : float
Origin time uncertainty interval.
axis1 : np.ndarray, shape(3,)
Coordinates of the 1st confidence ellipsoid axis (vector).
axis2 : np.ndarray, shape(3,)
Coordinates of the 2nd confidence ellipsoid axis (vector).
axis3 : np.ndarray, shape(3,)
Coordinates of the 3rd confidence ellipsoid axis (vector).
"""
if par.verbose:
print("Uncertainty estimation for the Even N {0:d}".format(
int(hypo[ev, 0])) + '\n')
sys.stdout.flush()
indh = np.where(hypo[:, 0] == evID[ev])[0]
if len(slow) == 2:
(slowP, slowS) = slow
(dataP, dataS) = data
(scp, scs) = sc
indrp = np.where(dataP[:, 0] == evID[ev])[0]
rcv_evP = rcv[dataP[indrp, 2].astype(int) - 1, :]
nstP = indrp.size
T0p = np.kron(hypo[indh, 1], np.ones([nstP, 1]))
indrs = np.where(dataS[:, 0] == evID[ev])[0]
rcv_evS = rcv[dataS[indrs, 2].astype(int) - 1, :]
nstS = indrs.size
T0s = np.kron(hypo[indh, 1], np.ones([nstS, 1]))
Txp = np.kron(hypo[indh, 2:], np.ones([nstP, 1]))
Txs = np.kron(hypo[indh, 2:], np.ones([nstS, 1]))
if par.use_sc:
scp_ev = scp[dataP[indrp, 2].astype(int) - 1, :]
scs_ev = scs[dataS[indrs, 2].astype(int) - 1, :]
else:
scp_ev = np.zeros([nstP, 1])
scs_ev = np.zeros([nstS, 1])
srcp = np.hstack((ev*np.ones([nstP, 1]), T0p + scp_ev, Txp))
srcs = np.hstack((ev*np.ones([nstS, 1]), T0s + scs_ev, Txs))
tcalp, raysP = Mesh3D.raytrace(source=srcp, rcv=rcv_evP, slowness=slowP,
aggregate_src=False, compute_L=False,
return_rays=True)
tcals, raysS = Mesh3D.raytrace(source=srcs, rcv=rcv_evS, slowness=slowS,
aggregate_src=False, compute_L=False,
return_rays=True)
slowP_0 = Mesh3D.get_s0(srcp)
slowS_0 = Mesh3D.get_s0(srcs)
Hi = np.ones((nstP + nstS, 4))
for nr in range(nstP):
rayi = raysP[nr]
if rayi.shape[0] == 1:
continue
slw0 = slowP_0[nr]
dx = rayi[1, 0] - hypo[indh, 2]
dy = rayi[1, 1] - hypo[indh, 3]
dz = rayi[1, 2] - hypo[indh, 4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 1] = -dx * slw0 / ds
Hi[nr, 2] = -dy * slw0 / ds
Hi[nr, 3] = -dz * slw0 / ds
for nr in range(nstS):
rayi = raysS[nr]
if rayi.shape[0] == 1:
continue
slw0 = slowS_0[nr]
dx = rayi[1, 0] - hypo[indh, 2]
dy = rayi[1, 1] - hypo[indh, 3]
dz = rayi[1, 2] - hypo[indh, 4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 1] = -dx * slw0 / ds
Hi[nr, 2] = -dy * slw0 / ds
Hi[nr, 3] = -dz * slw0 / ds
tcal = np.hstack((tcalp, tcals))
res = np.hstack((dataP[indrp, 1], dataS[indrs, 1])) - tcal
convrays = np.where(tcal != 0)[0]
if convrays.size < (nstP + nstS):
res = res[convrays]
Hi = Hi[convrays, :]
elif len(slow) == 1:
indr = np.where(data[0][:, 0] == evID[ev])[0]
rcv_ev = rcv[data[0][indr, 2].astype(int) - 1, :]
if par.use_sc:
sc_ev = sc[data[0][indr, 2].astype(int) - 1]
else:
sc_ev = 0.
nst = indr.size
T0 = np.kron(hypo[indh, 1], np.ones([nst, 1]))
Tx = np.kron(hypo[indh, 2:], np.ones([nst, 1]))
src = np.hstack((ev*np.ones([nst, 1]), T0+sc_ev, Tx))
tcal, rays = Mesh3D.raytrace(source=src, rcv=rcv_ev, slowness=slow[0],
aggregate_src=False, compute_L=False,
return_rays=True)
slow_0 = Mesh3D.get_s0(src)
Hi = np.ones([nst, 4])
for nr in range(nst):
rayi = rays[nr]
if rayi.shape[0] == 1: # unconverged ray
continue
slw0 = slow_0[nr]
dx = rayi[1, 0] - hypo[indh, 2]
dy = rayi[1, 1] - hypo[indh, 3]
dz = rayi[1, 2] - hypo[indh, 4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 1] = -dx * slw0 / ds
Hi[nr, 2] = -dy * slw0 / ds
Hi[nr, 3] = -dz * slw0 / ds
convrays = np.where(tcal != 0)[0]
res = data[0][indr, 1] - tcal
if convrays.size < nst:
res = res[convrays]
Hi = Hi[convrays, :]
N = res.shape[0]
try:
Q = np.linalg.inv(Hi.T @ Hi)
except np.linalg.linalg.LinAlgError:
if par.verbose:
print("ill-conditioned Jacobian matrix")
sys.stdout.flush()
U, S, V = np.linalg.svd(Hi.T @ Hi)
Q = V.T @ np.diag(1./(S + 1.e-9)) @ U.T
eigenVals, eigenVec = np.linalg.eig(Q[:3, :3])
ind = np.argsort(eigenVals)
if varData:
s2 = 1
varData[0] += [np.sum(res**2)]
varData[1] += [N]
else:
s2 = np.sum(res**2) / (N - 4)
alpha = 1 - par.p
coef = scps.t.ppf(1 - alpha / 2., N - 4)
axis1 = np.sqrt(eigenVals[ind[2]] * s2) * coef * eigenVec[:, ind[2]]
axis2 = np.sqrt(eigenVals[ind[1]] * s2) * coef * eigenVec[:, ind[1]]
axis3 = np.sqrt(eigenVals[ind[0]] * s2) * coef * eigenVec[:, ind[0]]
to_confInterv = np.sqrt(Q[-1, -1] * s2) * coef
return to_confInterv, axis1, axis2, axis3
def jntHypoVel_T(data, caldata, Vinit, cells, nodes, rcv, Hypo0,
par, threads=1, vPoints=np.array([]), basename='Vel'):
"""
Joint hypocenter-velicoty inversion from P wave arrival time data
parametrized using the velocity model.
Parameters
----------
data : np.ndarray, shape(arrival time number, 3)
Arrival times and corresponding receivers for each event..
caldata : np.ndarray, shape(number of calibration shots, 3)
Calibration shot data.
Vinit : np.ndarray, shape(nnodes,1) or (1,1)
Initial velocity model.
cells : np.ndarray of int, shape (cell number, 4)
Indices of nodes forming the cells.
nodes : np.ndarray, shape (nnodes, 3)
Node coordinates.
rcv : np.ndarray, shape (receiver number,3)
Coordinates of receivers.
Hypo0 : np.ndarray, shape(event number, 5)
First guesses of the hypocenter coordinates (must be all diffirent).
par : instance of the class Parameters
The inversion parameters.
threads : int, optional
Thread number. The default is 1.
vPoints : np.ndarray, shape(point number,4), optional
Known velocity points. The default is np.array([]).
basename : string, optional
The filename used to save the output file. The default is 'Vel'.
Returns
-------
output : python dictionary
It contains the estimated hypocenter coordinates and their origin times,
static correction values, velocity model, convergence states,
parameter uncertainty and residual norm in each iteration.
"""
if par.verbose:
print(par)
print('inversion involves the velocity model\n')
sys.stdout.flush()
if par.use_sc:
nstation = rcv.shape[0]
else:
nstation = 0
Static_Corr = np.zeros([nstation, 1])
nnodes = nodes.shape[0]
# observed traveltimes
if data.shape[0] > 0:
evID = np.unique(data[:, 0]).astype(int)
tObserved = data[:, 1]
numberOfEvents = evID.size
else:
tObserved = np.array([])
numberOfEvents = 0
rcvData = np.zeros([data.shape[0], 3])
for ev in range(numberOfEvents):
indr = np.where(data[:, 0] == evID[ev])[0]
rcvData[indr] = rcv[data[indr, 2].astype(int) - 1, :]
# calibration data
if caldata.shape[0] > 0:
calID = np.unique(caldata[:, 0])
ncal = calID.size
time_calibration = caldata[:, 1]
TxCalib = np.zeros((caldata.shape[0], 5))
TxCalib[:, 2:] = caldata[:, 3:]
TxCalib[:, 0] = caldata[:, 0]
rcvCalib = np.zeros([caldata.shape[0], 3])
if par.use_sc:
Msc_cal = []
for nc in range(ncal):
indr = np.where(caldata[:, 0] == calID[nc])[0]
rcvCalib[indr] = rcv[caldata[indr, 2].astype(int) - 1, :]
if par.use_sc:
Msc_cal.append(sp.csr_matrix(
(np.ones([indr.size, ]),
(range(indr.size), caldata[indr, 2]-1)),
shape=(indr.size, nstation)))
else:
ncal = 0
time_calibration = np.array([])
# initial velocity model
if Vinit.size == 1:
Velocity = Vinit * np.ones([nnodes, 1])
Slowness = 1. / Velocity
elif Vinit.size == nnodes:
Velocity = Vinit
Slowness = 1. / Velocity
else:
print("invalid Velocity Model\n")
sys.stdout.flush()
return 0
# used threads
nThreadsSystem = cpu_count()
nThreads = np.min((threads, nThreadsSystem))
global Mesh3D, Dimensions
Mesh3D = tmesh.Mesh3d(nodes, tetra=cells, method='DSPM', cell_slowness=0,
n_threads=nThreads, n_secondary=2, n_tertiary=1,
process_vel=1, radius_factor_tertiary=2,
translate_grid=1)
Mesh3D.set_slowness(Slowness)
Dimensions = np.empty(6)
Dimensions[0] = min(nodes[:, 0])
Dimensions[1] = max(nodes[:, 0])
Dimensions[2] = min(nodes[:, 1])
Dimensions[3] = max(nodes[:, 1])
Dimensions[4] = min(nodes[:, 2])
Dimensions[5] = max(nodes[:, 2])
# Hypocenter
if numberOfEvents > 0 and Hypo0.shape[0] != numberOfEvents:
print("invalid Hypocenters0 format\n")
sys.stdout.flush()
return 0
else:
Hypocenters = Hypo0.copy()
ResidueNorm = np.zeros([par.maxit])
if par.invert_vel:
if par.use_sc:
U = sp.bsr_matrix(
np.vstack((np.zeros([nnodes, 1]), np.ones([nstation, 1]))))
nbre_param = nnodes + nstation
if par.max_sc > 0. and par.max_sc < 1.:
N = sp.bsr_matrix(
np.hstack((np.zeros([nstation, nnodes]), np.eye(nstation))))
NtN = (1. / par.max_sc**2) * N.T.dot(N)
else:
U = sp.csr_matrix(np.zeros([nnodes, 1]))
nbre_param = nnodes
# build matrix D
if vPoints.size > 0:
if par.verbose:
print('\nBuilding velocity data point matrix D\n')
sys.stdout.flush()
D = Mesh3D.compute_D(vPoints[:, 2:])
D = sp.hstack((D, sp.csr_matrix((D.shape[0], nstation)))).tocsr()
DtD = D.T @ D
nD = spl.norm(DtD)
# Build regularization matrix
if par.verbose:
print('\n...Building regularization matrix K\n')
sys.stdout.flush()
kx, ky, kz = Mesh3D.compute_K(order=2, taylor_order=2,
weighting=1, squared=0,
s0inside=0, additional_points=3)
KX = sp.hstack((kx, sp.csr_matrix((nnodes, nstation))))
KX_Square = KX.transpose().dot(KX)
KY = sp.hstack((ky, sp.csr_matrix((nnodes, nstation))))
KY_Square = KY.transpose().dot(KY)
KZ = sp.hstack((kz, sp.csr_matrix((nnodes, nstation))))
KZ_Square = KZ.transpose().dot(KZ)
KtK = KX_Square + KY_Square + par.wzK * KZ_Square
nK = spl.norm(KtK)
if nThreads == 1:
hypo_convergence = list(np.zeros(numberOfEvents, dtype=bool))
else:
manager = Manager()
hypo_convergence = manager.list(np.zeros(numberOfEvents, dtype=bool))
for i in range(par.maxit):
if par.verbose:
print("Iteration N : {0:d}\n".format(i + 1))
sys.stdout.flush()
if par.invert_vel:
if par.verbose:
print('Iteration {0:d} - Updating velocity model\n'.format(i + 1))
print("Updating penalty vector\n")
sys.stdout.flush()
# Build vector C
cx = kx.dot(Velocity)
cy = ky.dot(Velocity)
cz = kz.dot(Velocity)
# build matrix P and dP
indVmin = np.where(Velocity < par.Vpmin)[0]
indVmax = np.where(Velocity > par.Vpmax)[0]
indPinality = np.hstack([indVmin, indVmax])
dPinality_V = np.hstack(
[-par.PAp * np.ones(indVmin.size), par.PAp * np.ones(indVmax.size)])
pinality_V = np.vstack(
[par.PAp * (par.Vpmin - Velocity[indVmin]), par.PAp *
(Velocity[indVmax] - par.Vpmax)])
d_Pinality = sp.csr_matrix(
(dPinality_V, (indPinality, indPinality)), shape=(
nnodes, nbre_param))
Pinality = sp.csr_matrix(
(pinality_V.reshape([-1, ]),
(indPinality, np.zeros([indPinality.shape[0]]))),
shape=(nnodes, 1))
if par.verbose:
print('Penalties applied at {0:d} nodes\n'.format(
dPinality_V.size))
print('...Start Raytracing\n')
sys.stdout.flush()
if numberOfEvents > 0:
sources = np.empty((data.shape[0], 5))
if par.use_sc:
sc_data = np.empty((data.shape[0], ))
for ev in np.arange(numberOfEvents):
indr = np.where(data[:, 0] == evID[ev])[0]
indh = np.where(Hypocenters[:, 0] == evID[ev])[0]
sources[indr, :] = Hypocenters[indh, :]
if par.use_sc:
sc_data[indr] = Static_Corr[data[indr, 2].astype(int)
- 1, 0]
if par.use_sc:
sources[:, 1] += sc_data
tt, rays, M0 = Mesh3D.raytrace(source=sources,
rcv=rcvData, slowness=None,
aggregate_src=False,
compute_L=True, return_rays=True)
else:
tt, rays, M0 = Mesh3D.raytrace(source=sources,
rcv=rcvData, slowness=None,
aggregate_src=False,
compute_L=True, return_rays=True)
v0 = 1. / Mesh3D.get_s0(sources)
if par.verbose:
inconverged = np.where(tt == 0)[0]
for icr in inconverged:
print('\033[43m' +
'\nWarning: raypath failed to converge for even '
'N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver '
'N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(data[icr, 0]), sources[icr, 2],
sources[icr, 3], sources[icr, 4],
int(data[icr, 2]), rcvData[icr, 0],
rcvData[icr, 1], rcvData[icr, 2])
+ '\033[0m')
print('\033[43m' + 'ray will be temporary removed' +
'\033[0m')
sys.stdout.flush()
else:
tt = np.array([])
if ncal > 0:
if par.use_sc:
TxCalib[:, 1] = Static_Corr[caldata[:, 2].astype(int) - 1, 0]
tt_Calib, Mcalib = Mesh3D.raytrace(
source=TxCalib, rcv=rcvCalib, slowness=None,
aggregate_src=False, compute_L=True, return_rays=False)
else:
tt_Calib, Mcalib = Mesh3D.raytrace(
source=TxCalib, rcv=rcvCalib, slowness=None,
aggregate_src=False, compute_L=True, return_rays=False)
if par.verbose:
inconverged = np.where(tt_Calib == 0)[0]
for icr in inconverged:
print('\033[43m' +
'\nWarning: raypath failed to converge '
'for calibration shot N '
'{0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver'
' N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(caldata[icr, 0]), TxCalib[icr, 2],
TxCalib[icr, 3], TxCalib[icr, 4],
int(caldata[icr, 2]), rcvCalib[icr, 0],
rcvCalib[icr, 1], rcvCalib[icr, 2])
+ '\033[0m')
print('\033[43m' + 'ray will be temporary removed' +
'\033[0m')
sys.stdout.flush()
else:
tt_Calib = np.array([])
Resid = tObserved - tt
convrayData = np.where(tt != 0)[0]
convrayClib = np.where(tt_Calib != 0)[0]
if Resid.size == 0:
Residue = time_calibration[convrayClib] - tt_Calib[convrayClib]
else:
Residue = np.hstack(
(np.zeros([np.count_nonzero(tt) - 4 * numberOfEvents]),
time_calibration[convrayClib] - tt_Calib[convrayClib]))
ResidueNorm[i] = np.linalg.norm(np.hstack(
(Resid[convrayData], time_calibration[convrayClib] -
tt_Calib[convrayClib])))
if par.verbose:
print('...Building matrix M\n')
sys.stdout.flush()
M = sp.csr_matrix((0, nbre_param))
ir = 0
for even in range(numberOfEvents):
indh = np.where(Hypocenters[:, 0] == evID[even])[0]
indr = np.where(data[:, 0] == evID[even])[0]
Mi = M0[even]
nst_ev = Mi.shape[0]
Hi = np.ones([indr.size, 4])
for nr in range(indr.size):
rayi = rays[indr[nr]]
if rayi.shape[0] == 1:
continue
vel0 = v0[indr[nr]]
dx = rayi[1, 0] - Hypocenters[indh[0], 2]
dy = rayi[1, 1] - Hypocenters[indh[0], 3]
dz = rayi[1, 2] - Hypocenters[indh[0], 4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 1] = -dx / (vel0 * ds)
Hi[nr, 2] = -dy / (vel0 * ds)
Hi[nr, 3] = -dz / (vel0 * ds)
convrays = np.where(tt[indr] != 0)[0]
if convrays.shape[0] < nst_ev:
Hi = Hi[convrays, :]
nst_ev = convrays.size
Q, _ = np.linalg.qr(Hi, mode='complete')
Ti = sp.csr_matrix(Q[:, 4:])
Ti = Ti.T
if par.use_sc:
Lsc = sp.csr_matrix((np.ones(nst_ev,),
(range(nst_ev),
data[indr[convrays], 2] - 1)),
shape=(nst_ev, nstation))
Mi = sp.hstack((Mi, Lsc))
Mi = sp.csr_matrix(Ti @ Mi)
M = sp.vstack([M, Mi])
Residue[ir:ir + (nst_ev - 4)] = Ti.dot(Resid[indr[convrays]])
ir += nst_ev - 4
for evCal in range(len(Mcalib)):
Mi = Mcalib[evCal]
if par.use_sc:
indrCal = np.where(caldata[:, 0] == calID[evCal])[0]
convraysCal = np.where(tt_Calib[indrCal] != 0)[0]
Mi = sp.hstack((Mi, Msc_cal[evCal][convraysCal]))
M = sp.vstack([M, Mi])
if par.verbose:
print('Assembling matrices and solving system\n')
sys.stdout.flush()
S = np.sum(Static_Corr)
term1 = (M.T).dot(M)
nM = spl.norm(term1[:nnodes, :nnodes])
term2 = (d_Pinality.T).dot(d_Pinality)
nP = spl.norm(term2)
term3 = U.dot(U.T)
λ = par.λ * nM / nK
if nP != 0:
γ = par.γ * nM / nP
else:
γ = par.γ
A = term1 + λ * KtK + γ * term2 + term3
if par.use_sc and par.max_sc > 0. and par.max_sc < 1.:
A += NtN
term1 = (M.T).dot(Residue)
term1 = term1.reshape([-1, 1])
term2 = (KX.T).dot(cx) + (KY.T).dot(cy) + par.wzK * (KZ.T).dot(cz)
term3 = (d_Pinality.T).dot(Pinality)
term4 = U.dot(S)
b = term1 - λ * term2 - γ * term3 - term4
if vPoints.size > 0:
α = par.α * nM / nD
A += α * DtD
b += α * D.T @ (vPoints[:, 1].reshape(-1, 1) -
D[:, :nnodes] @ Velocity)
x = spl.minres(A, b, tol=1.e-8)
deltam = x[0].reshape(-1, 1)
# update velocity vector and static correction
dVmax = np.max(abs(deltam[:nnodes]))
if dVmax > par.dVp_max:
deltam[:nnodes] *= par.dVp_max / dVmax
if par.use_sc and par.max_sc > 0. and par.max_sc < 1.:
sc_mean = np.mean(abs(deltam[nnodes:]))
if sc_mean > par.max_sc * np.mean(abs(Residue)):
deltam[nnodes:] *= par.max_sc * np.mean(abs(Residue)) / sc_mean
Velocity += np.matrix(deltam[:nnodes])
Slowness = 1. / Velocity
Static_Corr += deltam[nnodes:]
if par.saveVel == 'all':
if par.verbose:
print('...Saving Velocity models\n')
sys.stdout.flush()
try:
msh2vtk(nodes, cells, Velocity, basename +
'it{0}.vtk'.format(i + 1))
except ImportError:
print('vtk module is not installed\n')
sys.stdout.flush()
elif par.saveVel == 'last' and i == par.maxit - 1:
try:
msh2vtk(nodes, cells, Velocity, basename + '.vtk')
except ImportError:
print('vtk module is not installed\n')
sys.stdout.flush()
#######################################
# relocate Hypocenters
#######################################
Mesh3D.set_slowness(Slowness)
if numberOfEvents > 0:
print("\nIteration N {0:d} : Relocation of events\n".format(i + 1))
sys.stdout.flush()
if nThreads == 1:
for ev in range(numberOfEvents):
Hypocenters[ev, :] = _hypo_relocation(
ev, evID, Hypocenters, data, rcv,
Static_Corr, hypo_convergence, par)
else:
p = mp.get_context("fork").Pool(processes=nThreads)
updatedHypo = p.starmap(_hypo_relocation,
[(int(ev), evID, Hypocenters, data,
rcv, Static_Corr, hypo_convergence,
par)for ev in range(numberOfEvents)])
p.close() # pool won't take any new tasks
p.join()
Hypocenters = np.array([updatedHypo])[0]
# Calculate the hypocenter parameter uncertainty
uncertnty = []
if par.uncertainty and numberOfEvents > 0:
print("\nUncertainty evaluation\n")
sys.stdout.flush()
# estimate data variance
if nThreads == 1:
varData = [[], []]
for ev in range(numberOfEvents):
uncertnty.append(
_uncertaintyEstimat(ev, evID, Hypocenters, (data,), rcv,
Static_Corr, (Slowness,), par, varData))
else:
varData = manager.list([[], []])
with Pool(processes=nThreads) as p:
uncertnty = p.starmap(
_uncertaintyEstimat,
[(int(ev), evID, Hypocenters, (data, ),
rcv, Static_Corr, (Slowness, ), par,
varData) for ev in range(numberOfEvents)])
p.close() # pool won't take any new tasks
p.join()
sgmData = np.sqrt(np.sum(varData[0]) /
(np.sum(varData[1]) - 4 *
numberOfEvents -
Static_Corr.size))
for ic in range(numberOfEvents):
uncertnty[ic] = tuple([sgmData * x for x in uncertnty[ic]])
output = OrderedDict()
output['Hypocenters'] = Hypocenters
output['Convergence'] = list(hypo_convergence)
output['Uncertainties'] = uncertnty
output['Velocity'] = Velocity
output['Sts_Corrections'] = Static_Corr
output['Residual_norm'] = ResidueNorm
return output
def jntHyposlow_T(data, caldata, Vinit, cells, nodes, rcv, Hypo0,
par, threads=1, vPoints=np.array([]), basename='Slowness'):
"""
Joint hypocenter-velicoty inversion from P wave arrival time data
parametrized using the slowness model.
Parameters
----------
data : np.ndarray, shape(arrival time number, 3)
Arrival times and corresponding receivers for each event.
caldata : np.ndarray, shape(number of calibration shots, 6)
Calibration shot data.
Vinit : np.ndarray, shape(nnodes,1) or (1,1)
Initial velocity model.
Cells : np.ndarray of int, shape (cell number, 4)
Indices of nodes forming the cells.
nodes : np.ndarray, shape (nnodes, 3)
Node coordinates.
rcv : np.ndarray, shape (receiver number,3)
Coordinates of receivers.
Hypo0 : np.ndarray, shape(event number, 5)
First guesses of the hypocenter coordinates (must be all diffirent).
par : instance of the class Parameters
The inversion parameters.
threads : int, optional
Thread number. The default is 1.
vPoints : np.ndarray, shape(point number,4), optional
Known velocity points. The default is np.array([]).
basename : string, optional
The filename used to save the output files. The default is 'Slowness'.
Returns
-------
output : python dictionary
It contains the estimated hypocenter coordinates and their origin times,
static correction values, velocity model, convergence states,
parameter uncertainty and residual norm in each iteration.
"""
if par.verbose:
print(par)
print('inversion involves the slowness model\n')
sys.stdout.flush()
if par.use_sc:
nstation = rcv.shape[0]
else:
nstation = 0
Static_Corr = np.zeros([nstation, 1])
nnodes = nodes.shape[0]
# observed traveltimes
if data.shape[0] > 0:
evID = np.unique(data[:, 0]).astype(int)
tObserved = data[:, 1]
numberOfEvents = evID.size
else:
tObserved = np.array([])
numberOfEvents = 0
rcvData = np.zeros([data.shape[0], 3])
for ev in range(numberOfEvents):
indr = np.where(data[:, 0] == evID[ev])[0]
rcvData[indr] = rcv[data[indr, 2].astype(int) - 1, :]
# get calibration data
if caldata.shape[0] > 0:
calID = np.unique(caldata[:, 0])
ncal = calID.size
time_calibration = caldata[:, 1]
TxCalib = np.zeros((caldata.shape[0], 5))
TxCalib[:, 2:] = caldata[:, 3:]
TxCalib[:, 0] = caldata[:, 0]
rcvCalib = np.zeros([caldata.shape[0], 3])
if par.use_sc:
Msc_cal = []
for nc in range(ncal):
indr = np.where(caldata[:, 0] == calID[nc])[0]
rcvCalib[indr] = rcv[caldata[indr, 2].astype(int) - 1, :]
if par.use_sc:
Msc_cal.append(sp.csr_matrix(
(np.ones([indr.size, ]),
(range(indr.size), caldata[indr, 2]-1)),
shape=(indr.size, nstation)))
else:
ncal = 0
time_calibration = np.array([])
# initial velocity model
if Vinit.size == 1:
Slowness = 1. / (Vinit * np.ones([nnodes, 1]))
elif Vinit.size == nnodes:
Slowness = 1. / Vinit
else:
print("invalid Velocity Model")
sys.stdout.flush()
return 0
# Hypocenter
if numberOfEvents > 0 and Hypo0.shape[0] != numberOfEvents:
print("invalid Hypocenters0 format\n")
sys.stdout.flush()
return 0
else:
Hypocenters = Hypo0.copy()
# number of threads
nThreadsSystem = cpu_count()
nThreads = np.min((threads, nThreadsSystem))
global Mesh3D, Dimensions
# build mesh object
Mesh3D = tmesh.Mesh3d(nodes, tetra=cells, method='DSPM', cell_slowness=0,
n_threads=nThreads, n_secondary=2, n_tertiary=1,
radius_factor_tertiary=2, translate_grid=1)
Mesh3D.set_slowness(Slowness)
Dimensions = np.empty(6)
Dimensions[0] = min(nodes[:, 0])
Dimensions[1] = max(nodes[:, 0])
Dimensions[2] = min(nodes[:, 1])
Dimensions[3] = max(nodes[:, 1])
Dimensions[4] = min(nodes[:, 2])
Dimensions[5] = max(nodes[:, 2])
ResidueNorm = np.zeros([par.maxit])
if par.invert_vel:
if par.use_sc:
U = sp.bsr_matrix(np.vstack((np.zeros([nnodes, 1]),
np.ones([nstation, 1]))))
nbre_param = nnodes + nstation
if par.max_sc > 0. and par.max_sc < 1.:
N = sp.bsr_matrix(
np.hstack((np.zeros([nstation, nnodes]), np.eye(nstation))))
NtN = (1. / par.max_sc**2) * N.T.dot(N)
else:
U = sp.csr_matrix(np.zeros([nnodes, 1]))
nbre_param = nnodes
# build matrix D
if vPoints.size > 0:
if par.verbose:
print('\nBuilding velocity data point matrix D\n')
sys.stdout.flush()
D = Mesh3D.compute_D(vPoints[:, 2:])
D = sp.hstack((D, sp.csr_matrix((D.shape[0], nstation)))).tocsr()
DtD = D.T @ D
nD = spl.norm(DtD)
# Build regularization matrix
if par.verbose:
print('\n...Building regularization matrix K\n')
sys.stdout.flush()
kx, ky, kz = Mesh3D.compute_K(order=2, taylor_order=2,
weighting=1, squared=0,
s0inside=0, additional_points=3)
KX = sp.hstack((kx, sp.csr_matrix((nnodes, nstation))))
KX_Square = KX.transpose().dot(KX)
KY = sp.hstack((ky, sp.csr_matrix((nnodes, nstation))))
KY_Square = KY.transpose().dot(KY)
KZ = sp.hstack((kz, sp.csr_matrix((nnodes, nstation))))
KZ_Square = KZ.transpose().dot(KZ)
KtK = KX_Square + KY_Square + par.wzK * KZ_Square
nK = spl.norm(KtK)
if nThreads == 1:
hypo_convergence = list(np.zeros(numberOfEvents, dtype=bool))
else:
manager = Manager()
hypo_convergence = manager.list(np.zeros(numberOfEvents, dtype=bool))
for i in range(par.maxit):
if par.verbose:
print("\nIteration N : {0:d}\n".format(i + 1))
sys.stdout.flush()
if par.invert_vel:
if par.verbose:
print(
'\nIteration {0:d} - Updating velocity model\n'.format(i + 1))
print("\nUpdating penalty vector\n")
sys.stdout.flush()
# Build vector C
cx = kx.dot(Slowness)
cy = ky.dot(Slowness)
cz = kz.dot(Slowness)
# build matrix P and dP
indSmin = np.where(Slowness < 1. / par.Vpmax)[0]
indSmax = np.where(Slowness > 1. / par.Vpmin)[0]
indPinality = np.hstack([indSmin, indSmax])
dPinality_V = np.hstack(
[-par.PAp * np.ones(indSmin.size), par.PAp * np.ones(indSmax.size)])
pinality_V = np.vstack([par.PAp *
(1. / par.Vpmax -
Slowness[indSmin]), par.PAp *
(Slowness[indSmax] -
1. / par.Vpmin)])
d_Pinality = sp.csr_matrix(
(dPinality_V, (indPinality, indPinality)), shape=(
nnodes, nbre_param))
Pinality = sp.csr_matrix((
pinality_V.reshape([-1, ]),
(indPinality, np.zeros([indPinality.shape[0]]))),
shape=(nnodes, 1))
if par.verbose:
print('\nPenalties applied at {0:d} nodes\n'.format(
dPinality_V.size))
print('...Start Raytracing\n')
sys.stdout.flush()
if numberOfEvents > 0:
sources = np.empty((data.shape[0], 5))
if par.use_sc:
sc_data = np.empty((data.shape[0], ))
for ev in np.arange(numberOfEvents):
indr = np.where(data[:, 0] == evID[ev])[0]
indh = np.where(Hypocenters[:, 0] == evID[ev])[0]
sources[indr, :] = Hypocenters[indh, :]
if par.use_sc:
sc_data[indr] = Static_Corr[data[indr, 2].astype(int)
- 1, 0]
if par.use_sc:
sources[:, 1] += sc_data
tt, rays, M0 = Mesh3D.raytrace(source=sources,
rcv=rcvData, slowness=None,
aggregate_src=False,
compute_L=True, return_rays=True)
else:
tt, rays, M0 = Mesh3D.raytrace(source=sources,
rcv=rcvData, slowness=None,
aggregate_src=False,
compute_L=True, return_rays=True)
slow_0 = Mesh3D.get_s0(sources)
if par.verbose:
inconverged = np.where(tt == 0)[0]
for icr in inconverged:
print('\033[43m' +
'\nWarning: raypath failed to converge for even '
'N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver'
' N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(data[icr, 0]), sources[icr, 2],
sources[icr, 3], sources[icr, 4],
int(data[icr, 2]), rcvData[icr, 0],
rcvData[icr, 1], rcvData[icr, 2]) +
'\033[0m')
print('\033[43m' + 'ray will be temporary removed' +
'\033[0m')
sys.stdout.flush()
else:
tt = np.array([])
if ncal > 0:
if par.use_sc:
# add static corrections for each station
TxCalib[:, 1] = Static_Corr[caldata[:, 2].astype(int) - 1, 0]
tt_Calib, Mcalib = Mesh3D.raytrace(
source=TxCalib, rcv=rcvCalib, slowness=None,
aggregate_src=False, compute_L=True, return_rays=False)
else:
tt_Calib, Mcalib = Mesh3D.raytrace(
source=TxCalib, rcv=rcvCalib, slowness=None,
aggregate_src=False, compute_L=True, return_rays=False)
if par.verbose:
inconverged = np.where(tt_Calib == 0)[0]
for icr in inconverged:
print('\033[43m' +
'\nWarning: raypath failed to converge'
'for calibration shot N '
'{0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver'
' N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(caldata[icr, 0]), TxCalib[icr, 2],
TxCalib[icr, 3], TxCalib[icr, 4],
int(caldata[icr, 2]), rcvCalib[icr, 0],
rcvCalib[icr, 1], rcvCalib[icr, 2]) +
'\033[0m')
print('\033[43m' + 'ray will be temporary removed' +
'\033[0m')
sys.stdout.flush()
else:
tt_Calib = np.array([])
Resid = tObserved - tt
convrayData = np.where(tt != 0)[0]
convrayClib = np.where(tt_Calib != 0)[0]
if Resid.size == 0:
Residue = time_calibration[convrayClib] - tt_Calib[convrayClib]
else:
Residue = np.hstack((np.zeros([np.count_nonzero(tt) -
4 * numberOfEvents]),
time_calibration[convrayClib]
- tt_Calib[convrayClib]))
ResidueNorm[i] = np.linalg.norm(np.hstack(
(Resid[convrayData], time_calibration[convrayClib] -
tt_Calib[convrayClib])))
if par.verbose:
print('\n...Building matrix M\n')
sys.stdout.flush()
M = sp.csr_matrix((0, nbre_param))
ir = 0
for even in range(numberOfEvents):
indh = np.where(Hypocenters[:, 0] == evID[even])[0]
indr = np.where(data[:, 0] == evID[even])[0]
Mi = M0[even]
nst_ev = Mi.shape[0]
Hi = np.ones([indr.size, 4])
for nr in range(indr.size):
rayi = rays[indr[nr]]
if rayi.shape[0] == 1:
continue
slw0 = slow_0[indr[nr]]
dx = rayi[1, 0] - Hypocenters[indh[0], 2]
dy = rayi[1, 1] - Hypocenters[indh[0], 3]
dz = rayi[1, 2] - Hypocenters[indh[0], 4]
ds = np.sqrt(dx * dx + dy * dy + dz * dz)
Hi[nr, 1] = -slw0 * dx / ds
Hi[nr, 2] = -slw0 * dy / ds
Hi[nr, 3] = -slw0 * dz / ds
convrays = np.where(tt[indr] != 0)[0]
if convrays.shape[0] < indr.size:
Hi = Hi[convrays, :]
Q, _ = np.linalg.qr(Hi, mode='complete')
Ti = sp.csr_matrix(Q[:, 4:])
Ti = Ti.T
if par.use_sc:
Lsc = sp.csr_matrix((np.ones(nst_ev,),
(range(nst_ev),
data[indr[convrays], 2] - 1)),
shape=(nst_ev, nstation))
Mi = sp.hstack((Mi, Lsc))
Mi = sp.csr_matrix(Ti @ Mi)
M = sp.vstack([M, Mi])
Residue[ir:ir + (nst_ev - 4)] = Ti.dot(Resid[indr[convrays]])
ir += nst_ev - 4
for evCal in range(len(Mcalib)):
Mi = Mcalib[evCal]
if par.use_sc:
indrCal = np.where(caldata[:, 0] == calID[evCal])[0]
convraysCal = np.where(tt_Calib[indrCal] != 0)[0]
Mi = sp.hstack((Mi, Msc_cal[evCal][convraysCal]))
M = sp.vstack([M, Mi])
if par.verbose:
print('Assembling matrices and solving system\n')
sys.stdout.flush()
S = np.sum(Static_Corr)
term1 = (M.T).dot(M)
nM = spl.norm(term1[:nnodes, :nnodes])
term2 = (d_Pinality.T).dot(d_Pinality)
nP = spl.norm(term2)
term3 = U.dot(U.T)
λ = par.λ * nM / nK
if nP != 0:
γ = par.γ * nM / nP
else:
γ = par.γ
A = term1 + λ * KtK + γ * term2 + term3
if par.use_sc and par.max_sc > 0. and par.max_sc < 1.:
A += NtN
term1 = (M.T).dot(Residue)
term1 = term1.reshape([-1, 1])
term2 = (KX.T).dot(cx) + (KY.T).dot(cy) + par.wzK * (KZ.T).dot(cz)
term3 = (d_Pinality.T).dot(Pinality)
term4 = U.dot(S)
b = term1 - λ * term2 - γ * term3 - term4
if vPoints.size > 0:
α = par.α * nM / nD
A += α * DtD
b += α * D.T @ (1. / (vPoints[:, 1].reshape(-1, 1)) -
D[:, :nnodes] @ Slowness)
x = spl.minres(A, b, tol=1.e-8)
deltam = x[0].reshape(-1, 1)
# update velocity vector and static correction
deltaV_max = np.max(
abs(1. / (Slowness + deltam[:nnodes]) - 1. / Slowness))
if deltaV_max > par.dVp_max:
print('\n...Rescale P slowness vector\n')
sys.stdout.flush()
L1 = np.max(deltam[:nnodes] / (-par.dVp_max *
(Slowness**2) /
(1 + par.dVp_max * Slowness)))
L2 = np.max(deltam[:nnodes] / (par.dVp_max *
(Slowness**2) /
(1 - par.dVp_max * Slowness)))
deltam[:nnodes] /= np.max([L1, L2])
print('P wave: maximum ds = {0:4.3f}, '
'maximum dV = {1:4.3f}\n'.format(max(abs(
deltam[:nnodes]))[0], np.max(
abs(1. / (Slowness + deltam[:nnodes])
- 1. / Slowness))))
sys.stdout.flush()
if par.use_sc and par.max_sc > 0. and par.max_sc < 1.:
sc_mean = np.mean(abs(deltam[nnodes:]))
if sc_mean > par.max_sc * np.mean(abs(Residue)):
deltam[nnodes:] *= par.max_sc * np.mean(abs(Residue)) / sc_mean
Slowness += np.matrix(deltam[:nnodes])
Mesh3D.set_slowness(Slowness)
Static_Corr += deltam[nnodes:]
if par.saveVel == 'all':
if par.verbose:
print('...Saving Velocity models')
try:
msh2vtk(nodes, cells, 1. / Slowness, basename +
'it{0}.vtk'.format(i + 1))
except ImportError:
print('vtk module is not installed or encouters problems')
elif par.saveVel == 'last' and i == par.maxit - 1:
try:
msh2vtk(nodes, cells, 1. / Slowness, basename + '.vtk')
except ImportError:
print('vtk module is not installed or encouters problems')
#######################################
# relocate Hypocenters
#######################################
if numberOfEvents > 0:
print("\nIteration N {0:d} : Relocation of events".format(
i + 1) + '\n')
sys.stdout.flush()
if nThreads == 1:
for ev in range(numberOfEvents):
Hypocenters[ev, :] = _hypo_relocation(
ev, evID, Hypocenters, data, rcv, Static_Corr,
hypo_convergence, par)
else:
with Pool(processes=nThreads) as p:
updatedHypo = p.starmap(_hypo_relocation,
[(int(ev), evID, Hypocenters, data,
rcv, Static_Corr, hypo_convergence,
par) for ev in range(numberOfEvents)])
p.close() # pool won't take any new tasks
p.join()
Hypocenters = np.array([updatedHypo])[0]
# Calculate the hypocenter parameter uncertainty
uncertnty = []
if par.uncertainty and numberOfEvents > 0:
print("\nUncertainty evaluation\n")
sys.stdout.flush()
# estimate data variance
if nThreads == 1:
varData = [[], []]
for ev in range(numberOfEvents):
uncertnty.append(_uncertaintyEstimat(ev, evID, Hypocenters,
(data,), rcv, Static_Corr,
(Slowness,), par, varData))
else:
varData = manager.list([[], []])
with Pool(processes=nThreads) as p:
uncertnty = p.starmap(_uncertaintyEstimat,
[(int(ev), evID, Hypocenters, (data,),
rcv, Static_Corr, (Slowness,), par,
varData) for ev in range(numberOfEvents)])
p.close() # pool won't take any new tasks
p.join()
sgmData = np.sqrt(np.sum(varData[0]) /
(np.sum(varData[1]) - 4 * numberOfEvents -
Static_Corr.size))
for ic in range(numberOfEvents):
uncertnty[ic] = tuple([sgmData * x for x in uncertnty[ic]])
output = OrderedDict()
output['Hypocenters'] = Hypocenters
output['Convergence'] = list(hypo_convergence)
output['Uncertainties'] = uncertnty
output['Velocity'] = 1. / Slowness
output['Sts_Corrections'] = Static_Corr
output['Residual_norm'] = ResidueNorm
return output
def jntHypoVelPS_T(obsData, calibdata, Vinit, cells, nodes, rcv, Hypo0,
par, threads=1, vPnts=(np.array([]), np.array([])),
basename='Vel'):
"""
Joint hypocenter-velocity inversion from P- and S-wave arrival time data
parametrized using the velocity models.
Parameters
----------
obsData : tuple of two np.ndarrays (shape(observed data number, 3))
Observed arrival time data of P- and S-waves.
calibdata : tuple of two np.ndarrays (shape (number of calibration shots, 5))
Calibration data of P- and S-waves.
Vinit : tuple of np.ndarrays (shape (nnodes, 1) or (1,1))
Initial velocity models of P- and S-waves.
cells : np.ndarray of int, shape (cell number, 4)
Indices of nodes forming the cells.
nodes : np.ndarray, shape (nnodes, 3)
Node coordinates.
rcv : np.ndarray, shape (receiver number,3)
Coordinates of receivers.
Hypo0 : np.ndarray, shape(event number, 5)
First guesses of the hypocenter coordinates (must be all diffirent).
par : instance of the class Parameters
The inversion parameters.
threads : int, optional
Thread number. The default is 1.
vPnts : tuple of two np.ndarrays, optional
Known velocity points of P- and S-waves.
The default is (np.array([]), np.array([])).
basename : string, optional
The filename used to save the output files. The default is 'Vel'.
Raises
------
ValueError
If the Vs/Vp ratio is inverted instead of Vs model and some
known velocity points are given for the S wave and not for the P wave.
Returns
-------
output : python dictionary
It contains the estimated hypocenter coordinates and their origin times,
static correction values, velocity models of P- and S-waves,
hypocenter convergence states, parameter uncertainty and
residual norm in each iteration.
"""
if par.verbose:
print(par)
print('inversion involves the velocity model\n')
sys.stdout.flush()
if par.use_sc:
nstation = rcv.shape[0]
else:
nstation = 0
scP = np.zeros([nstation, 1])
scS = np.zeros([nstation, 1])
nnodes = nodes.shape[0]
# observed traveltimes
dataP, dataS = obsData
data = np.vstack([dataP, dataS])
if data.size > 0:
evID = np.unique(data[:, 0])
tObserved = data[:, 1]
numberOfEvents = evID.size
else:
tObserved = np.array([])
numberOfEvents = 0
rcvData_P = np.zeros([dataP.shape[0], 3])
rcvData_S = np.zeros([dataS.shape[0], 3])
for ev in range(numberOfEvents):
indr = np.where(dataP[:, 0] == evID[ev])[0]
rcvData_P[indr] = rcv[dataP[indr, 2].astype(int) - 1, :]
indr = np.where(dataS[:, 0] == evID[ev])[0]
rcvData_S[indr] = rcv[dataS[indr, 2].astype(int) - 1, :]
# calibration data
caldataP, caldataS = calibdata
if caldataP.size * caldataS.size > 0:
caldata = np.vstack([caldataP, caldataS])
calID = np.unique(caldata[:, 0])
ncal = calID.size
nttcalp = caldataP.shape[0]
nttcals = caldataS.shape[0]
time_calibration = caldata[:, 1]
TxCalibP = np.zeros((caldataP.shape[0], 5))
TxCalibP[:, 0] = caldataP[:, 0]
TxCalibP[:, 2:] = caldataP[:, 3:]
TxCalibS = np.zeros((caldataS.shape[0], 5))
TxCalibS[:, 0] = caldataS[:, 0]
TxCalibS[:, 2:] = caldataS[:, 3:]
rcvCalibP = np.zeros([nttcalp, 3])
rcvCalibS = np.zeros([nttcals, 3])
if par.use_sc:
Mscp_cal = []
Mscs_cal = []
for nc in range(ncal):
indr = np.where(caldataP[:, 0] == calID[nc])[0]
rcvCalibP[indr] = rcv[caldataP[indr, 2].astype(int) - 1, :]
if par.use_sc:
Mscp_cal.append(sp.csr_matrix((np.ones([indr.size, ]),
(range(indr.size), caldataP[indr, 2]
- 1)), shape=(indr.size, nstation)))
indr = np.where(caldataS[:, 0] == calID[nc])[0]
rcvCalibS[indr] = rcv[caldataS[indr, 2].astype(int) - 1, :]
if par.use_sc:
Mscs_cal.append(sp.csr_matrix((np.ones([indr.size, ]),
(range(indr.size), caldataS[indr, 2]
- 1)), shape=(indr.size, nstation)))
else:
ncal = 0
time_calibration = np.array([])
# set number of threads
nThreadsSystem = cpu_count()
nThreads = np.min((threads, nThreadsSystem))
global Mesh3D, Dimensions
Mesh3D = tmesh.Mesh3d(nodes, tetra=cells, method='DSPM', cell_slowness=0,
n_threads=nThreads, n_secondary=2, n_tertiary=1,
process_vel=True, radius_factor_tertiary=2,
translate_grid=1)
# initial velocity models for P and S waves
Vpint, Vsint = Vinit
if Vpint.size == 1:
Velp = Vpint * np.ones([nnodes, 1])
SlowP = 1. / Velp
elif Vpint.size == nnodes:
Velp = Vpint
SlowP = 1. / Velp
else:
print("invalid P Velocity model\n")
sys.stdout.flush()
return 0
if Vsint.size == 1:
Vels = Vsint * np.ones([nnodes, 1])
SlowS = 1. / Vels
elif Vsint.size == nnodes:
Vels = Vsint
SlowS = 1. / Vels
else:
print("invalid S Velocity model\n")
sys.stdout.flush()
return 0
if par.invert_VpVs:
VsVp = Vels / Velp
Velocity = np.vstack((Velp, VsVp))
else:
Velocity = np.vstack((Velp, Vels))
# initial parameters Hyocenters0 and origin times
if numberOfEvents > 0 and Hypo0.shape[0] != numberOfEvents:
print("invalid Hypocenters0 format\n")
sys.stdout.flush()
return 0
else:
Hypocenters = Hypo0.copy()
Dimensions = np.empty(6)
Dimensions[0] = min(nodes[:, 0])
Dimensions[1] = max(nodes[:, 0])
Dimensions[2] = min(nodes[:, 1])
Dimensions[3] = max(nodes[:, 1])
Dimensions[4] = min(nodes[:, 2])
Dimensions[5] = max(nodes[:, 2])
if par.invert_vel:
if par.use_sc:
U = sp.hstack((sp.csr_matrix(np.vstack(
(np.zeros([2 * nnodes, 1]), np.ones([nstation, 1]),
np.zeros([nstation, 1])))), sp.csr_matrix(np.vstack(
(np.zeros([2 * nnodes + nstation, 1]),
np.ones([nstation, 1]))))))
nbre_param = 2 * (nnodes + nstation)
if par.max_sc > 0. and par.max_sc < 1.:
N = sp.bsr_matrix(np.hstack(
(np.zeros([2 * nstation, 2 * nnodes]), np.eye(2 * nstation))))
NtN = (1. / par.max_sc**2) * N.T.dot(N)
else:
U = sp.csr_matrix(np.zeros([2 * nnodes, 2]))
nbre_param = 2 * nnodes
# calculate statistical moments of VpVs ratio
if par.stig != 0.:
momnts = np.zeros([4, ])
if par.invert_VpVs:
Ratio = caldataP[:, 1] / caldataS[:, 1] # Ratio=Vs/Vp
else:
Ratio = caldataS[:, 1] / caldataP[:, 1] # Ratio=Vp/Vs
for m in np.arange(4):
if m == 0:
momnts[m] = Ratio.mean() * nnodes
else:
momnts[m] = scps.moment(Ratio, m + 1) * nnodes
# build matrix D
vPoints_p, vPoints_s = vPnts
if vPoints_p.shape[0] > 0 or vPoints_s.shape[0] > 0:
if par.invert_VpVs:
for i in np.arange(vPoints_s.shape[0]):
dist = np.sqrt(np.sum((vPoints_p[:, 2:] -
vPoints_s[i, 2:])**2, axis=1))
indp = np.where(dist < 1.e-5)[0]
if indp.size > 0:
vPoints_s[i, 1] /= vPoints_p[indp, 1] # Vs/Vp
else:
raise ValueError('Missing Vp data point for Vs data '
'at ({0:f}, {1:f}, {2:f})'.format(
vPoints_s[i, 2], vPoints_s[i, 3],
vPoints_s[i, 4]))
sys.stdout.flush()
vPoints = np.vstack((vPoints_p, vPoints_s))
if par.verbose:
print('Building velocity data point matrix D\n')
sys.stdout.flush()
Ds = Mesh3D.compute_D(vPoints_s[:, 2:])
D = sp.block_diag((Ds, Ds)).tocsr()
D = sp.hstack((D, sp.csr_matrix((D.shape[0], 2*nstation)))).tocsr()
DtD = D.T @ D
nD = spl.norm(DtD)
else:
vPoints = np.vstack((vPoints_p, vPoints_s))
Dp = Mesh3D.compute_D(vPoints_p[:, 2:])
Ds = Mesh3D.compute_D(vPoints_s[:, 2:])
D = sp.block_diag((Dp, Ds)).tocsr()
D = sp.hstack((D, sp.csr_matrix((D.shape[0], 2*nstation)))).tocsr()
DtD = D.T @ D
nD = spl.norm(DtD)
else:
vPoints = np.array([])
# Build regularization matrix
if par.verbose:
print('\n...Building regularization matrix K\n')
sys.stdout.flush()
kx, ky, kz = Mesh3D.compute_K(order=2, taylor_order=2,
weighting=1, squared=0,
s0inside=0, additional_points=3)
kx = sp.block_diag((kx, kx))
ky = sp.block_diag((ky, ky))
kz = sp.block_diag((kz, kz))
KX = sp.hstack((kx, sp.csr_matrix((2 * nnodes, 2 * nstation))))
KX_Square = KX.transpose() @ KX
KY = sp.hstack((ky, sp.csr_matrix((2 * nnodes, 2 * nstation))))
KY_Square = KY.transpose() @ KY
KZ = sp.hstack((kz, sp.csr_matrix((2 * nnodes, 2 * nstation))))
KZ_Square = KZ.transpose() @ KZ
KtK = KX_Square + KY_Square + par.wzK * KZ_Square
nK = spl.norm(KtK)
if par.invert_VpVs:
VsVpmax = 1. / par.VpVsmin
VsVpmin = 1. / par.VpVsmax
if nThreads == 1:
hypo_convergence = list(np.zeros(numberOfEvents, dtype=bool))
else:
manager = Manager()
hypo_convergence = manager.list(np.zeros(numberOfEvents, dtype=bool))
ResidueNorm = np.zeros([par.maxit])
for i in range(par.maxit):
if par.verbose:
print("Iteration N : {0:d}\n".format(i + 1))
sys.stdout.flush()
if par.invert_vel:
if par.verbose:
print('\nIteration {0:d} - Updating velocity model\n'.format(i + 1))
print("Updating penalty vector\n")
sys.stdout.flush()
# Build vector C
cx = kx.dot(Velocity)
cy = ky.dot(Velocity)
cz = kz.dot(Velocity)
# build matrix P and dP
indVpmin = np.where(Velocity[:nnodes] < par.Vpmin)[0]
indVpmax = np.where(Velocity[:nnodes] > par.Vpmax)[0]
if par.invert_VpVs:
indVsVpmin = np.where(Velocity[nnodes:] < VsVpmin)[0] + nnodes
indVsVpmax = np.where(Velocity[nnodes:] > VsVpmax)[0] + nnodes
pinality_V = np.vstack([par.PAp * (par.Vpmin - Velocity[indVpmin]),
par.PAp * (Velocity[indVpmax] - par.Vpmax),
par.Pvpvs * (VsVpmin -
Velocity[indVsVpmin]),
par.Pvpvs * (Velocity[indVsVpmax] -
VsVpmax)])
dPinality_V = np.hstack([-par.PAp * np.ones(indVpmin.size),
par.PAp * np.ones(indVpmax.size),
-par.Pvpvs * np.ones(indVsVpmin.size),
par.Pvpvs * np.ones(indVsVpmax.size)])
indPinality = np.hstack(
[indVpmin, indVpmax, indVsVpmin, indVsVpmax])
else:
indVsmin = np.where(Velocity[nnodes:] < par.Vsmin)[0] + nnodes
indVsmax = np.where(Velocity[nnodes:] > par.Vsmax)[0] + nnodes
pinality_V = np.vstack([par.PAp *
(par.Vpmin -
Velocity[indVpmin]), par.PAp *
(Velocity[indVpmax] -
par.Vpmax), par.PAs *
(par.Vsmin -
Velocity[indVsmin]), par.PAs *
(Velocity[indVsmax] -
par.Vsmax)])
dPinality_V = np.hstack([-par.PAp * np.ones(indVpmin.size),
par.PAp * np.ones(indVpmax.size),
-par.PAs * np.ones(indVsmin.size),
par.PAs * np.ones(indVsmax.size)])
indPinality = np.hstack(
[indVpmin, indVpmax, indVsmin, indVsmax])
if par.VpVsmin and par.VpVsmax:
indvpvs_min = np.where(Velp / Vels <= par.VpVsmin)[0]
indvpvs_max = np.where(Velp / Vels >= par.VpVsmax)[0]
if par.verbose and indvpvs_max.size > 0:
print('\n{0:d} nodes have Vp/Vs ratio higher than the '
'upper VpVs limit\n'.format(indvpvs_max.size))
sys.stdout.flush()
if par.verbose and indvpvs_min.size > 0:
print('\n{0:d} nodes have Vp/Vs ratio lower than the lower '
'VpVs limit\n'.format(indvpvs_min.size))
sys.stdout.flush()
indPnltvpvs = np.hstack([indvpvs_min, indvpvs_max])
no = 2 # order or pinality function
pinlt_vpvs = np.vstack([par.Pvpvs *
(par.VpVsmin - Velp[indvpvs_min] /
Vels[indvpvs_min])**no,
par.Pvpvs * (Velp[indvpvs_max] /
Vels[indvpvs_max] -
par.VpVsmax)**no])
PinltVpVs = sp.csr_matrix((pinlt_vpvs.reshape(
[-1, ]), (indPnltvpvs, np.zeros([indPnltvpvs.shape[0]]))),
shape=(nnodes, 1))
dPinltVpVsind = (np.hstack([indvpvs_min, indvpvs_max,
indvpvs_min, indvpvs_max]),
np.hstack([indvpvs_min, indvpvs_max,
indvpvs_min + nnodes,
indvpvs_max + nnodes]))
dPinltVpVs_V = np.vstack(
(-par.Pvpvs / Vels[indvpvs_min] * no *
(par.VpVsmin - Velp[indvpvs_min] /
Vels[indvpvs_min])**(no - 1), par.Pvpvs /
Vels[indvpvs_max] * no *
(Velp[indvpvs_max] / Vels[indvpvs_max] -
par.VpVsmax)**(no - 1),
par.Pvpvs * Velp[indvpvs_min] /
(Vels[indvpvs_min]**2) * no *
(par.VpVsmin - Velp[indvpvs_min] /
Vels[indvpvs_min])**(no - 1),
-par.Pvpvs * Velp[indvpvs_max] /
(Vels[indvpvs_max]**2) * no *
(Velp[indvpvs_max] / Vels[indvpvs_max] -
par.VpVsmax)**(no - 1)))
dPinltVpVs = sp.csr_matrix((dPinltVpVs_V.reshape(
[-1, ]), dPinltVpVsind), shape=(nnodes, nbre_param))
d_Pinality = sp.csr_matrix(
(dPinality_V, (indPinality, indPinality)),
shape=(2 * nnodes, nbre_param))
Pinality = sp.csr_matrix((pinality_V.reshape(
[-1, ]), (indPinality, np.zeros([indPinality.shape[0]]))),
shape=(2 * nnodes, 1))
if par.verbose:
print('P wave Penalties were applied at {0:d} nodes\n'.format(
indVpmin.shape[0] + indVpmax.shape[0]))
sys.stdout.flush()
if par.invert_VpVs:
print(
'Vs/Vp ratio Penalties were applied '
'at {0:d} nodes\n'.format(indVsVpmin.shape[0] +
indVsVpmax.shape[0]))
sys.stdout.flush()
else:
print('S wave Penalties were applied at {0:d} nodes\n'.format(
indVsmin.shape[0] + indVsmax.shape[0]))
sys.stdout.flush()
print('...Start Raytracing\n')
sys.stdout.flush()
if numberOfEvents > 0:
sourcesp = np.empty((dataP.shape[0], 5))
if par.use_sc:
scp_data = np.zeros((dataP.shape[0], 1))
for ev in np.arange(numberOfEvents):
indrp = np.where(dataP[:, 0] == evID[ev])[0]
indh = np.where(Hypocenters[:, 0] == evID[ev])[0]
sourcesp[indrp, :] = Hypocenters[indh, :]
if par.use_sc:
scp_data[indrp, :] = scP[dataP[indrp, 2].astype(int) - 1]
if par.use_sc:
sourcesp[:, 1] += scp_data[:, 0]
ttp, raysp, M0p = Mesh3D.raytrace(
source=sourcesp, rcv=rcvData_P,
slowness=SlowP, aggregate_src=False,
compute_L=True, return_rays=True)
else:
ttp, raysp, M0p = Mesh3D.raytrace(
source=sourcesp, rcv=rcvData_P,
slowness=SlowP, aggregate_src=False,
compute_L=True, return_rays=True)
if par.verbose:
inconverged = np.where(ttp == 0)[0]
for icr in inconverged:
print('\033[43m' +
'\nWarning: raypath failed to converge for even '
'N {0:d} :({1:5.4f},{2:5.4f},{3:5.4f}) and receiver '
'N {4:d} :({5:5.4f},{6:5.4f},{7:5.4f})\n'.format(
int(dataP[icr, 0]), sourcesp[icr, 2],
sourcesp[icr, 3], sourcesp[icr, 4],
int(dataP[icr, 2]), rcvData_P[icr, 0],
rcvData_P[icr, 1], rcvData_P[icr, 2]) +
'\033[0m')
print('\033[43m' + 'ray will be temporary removed' +
'\033[0m')
sys.stdout.flush()
v0p = 1. / Mesh3D.get_s0(sourcesp)
sourcesS = np.empty((dataS.shape[0], 5))
if par.use_sc:
scs_data = np.zeros((dataS.shape[0], 1))
for ev in np.arange(numberOfEvents):
indrs = | np.where(dataS[:, 0] == evID[ev]) | numpy.where |
# -*- coding: utf-8 -*-
import dash
import dash_core_components as dcc
import dash_html_components as html
import dash_daq as daq
from dash.dependencies import Output, Input, State
import dash_table
import pandas as pd
import sys
import os
import plotly.graph_objs as go
import numpy as np
import pandas as pd
from scipy.cluster.vq import vq, kmeans, whiten
from collections import OrderedDict
from collections import namedtuple
# bsplines
from bsplines_utilities import point_on_bspline_curve
from bsplines_utilities import point_on_bspline_surface
from bsplines_utilities import insert_knot_bspline_curve
from bsplines_utilities import elevate_degree_bspline_curve
from bsplines_utilities import insert_knot_bspline_surface
from bsplines_utilities import elevate_degree_bspline_surface
# nurbs
from bsplines_utilities import point_on_nurbs_curve
from bsplines_utilities import point_on_nurbs_surface
from bsplines_utilities import insert_knot_nurbs_curve
from bsplines_utilities import insert_knot_nurbs_surface
from bsplines_utilities import elevate_degree_nurbs_curve
from bsplines_utilities import elevate_degree_nurbs_surface
# bsplines
from bsplines_utilities import translate_bspline_curve
from bsplines_utilities import rotate_bspline_curve
from bsplines_utilities import homothetic_bspline_curve
# nurbs
from bsplines_utilities import translate_nurbs_curve
from bsplines_utilities import rotate_nurbs_curve
from bsplines_utilities import homothetic_nurbs_curve
from datatypes import SplineCurve
from datatypes import SplineSurface
from datatypes import SplineVolume
from datatypes import NurbsCurve
from datatypes import NurbsSurface
from datatypes import NurbsVolume
from gallery import make_line
from gallery import make_arc
from gallery import make_square
from gallery import make_circle
from gallery import make_half_annulus_cubic
from gallery import make_L_shape_C1
# ... global variables
namespace = OrderedDict()
model_id = 0
# ...
# ... global dict for time stamps
d_timestamp = OrderedDict()
d_timestamp['load'] = -10000
d_timestamp['refine'] = -10000
d_timestamp['transform'] = -10000
d_timestamp['edit'] = -10000
d_timestamp['line'] = -10000
d_timestamp['arc'] = -10000
d_timestamp['square'] = -10000
d_timestamp['circle'] = -10000
d_timestamp['half_annulus_cubic'] = -10000
d_timestamp['L_shape_C1'] = -10000
d_timestamp['cube'] = -10000
d_timestamp['cylinder'] = -10000
d_timestamp['insert'] = -10000
d_timestamp['elevate'] = -10000
d_timestamp['subdivide'] = -10000
d_timestamp['translate'] = -10000
d_timestamp['rotate'] = -10000
d_timestamp['homothetie'] = -10000
# ...
# ...
def plot_curve(crv, nx=101, control_polygon=False):
knots = crv.knots
degree = crv.degree
P = crv.points
n = len(knots) - degree - 1
# ... curve
xs = np.linspace(0., 1., nx)
Q = np.zeros((nx, 2))
if isinstance(crv, SplineCurve):
for i,x in enumerate(xs):
Q[i,:] = point_on_bspline_curve(knots, P, x)
elif isinstance(crv, NurbsCurve):
W = crv.weights
for i,x in enumerate(xs):
Q[i,:] = point_on_nurbs_curve(knots, P, W, x)
line_marker = dict(color='#0066FF', width=2)
x = Q[:,0] ; y = Q[:,1]
trace_crv = go.Scatter(
x=x,
y=y,
mode = 'lines',
name='Curve',
line=line_marker,
)
# ...
if not control_polygon:
return [trace_crv]
# ... control polygon
line_marker = dict(color='#ff7f0e', width=2)
x = P[:,0] ; y = P[:,1]
trace_ctrl = go.Scatter(
x=x,
y=y,
mode='lines+markers',
name='Control polygon',
line=line_marker,
)
# ...
return [trace_crv, trace_ctrl]
# ...
# ...
def plot_surface(srf, Nu=101, Nv=101, control_polygon=False):
Tu, Tv = srf.knots
pu, pv = srf.degree
P = srf.points
nu = len(Tu) - pu - 1
nv = len(Tv) - pv - 1
gridu = np.unique(Tu)
gridv = np.unique(Tv)
us = np.linspace(0., 1., Nu)
vs = np.linspace(0., 1., Nv)
lines = []
line_marker = dict(color='#0066FF', width=2)
# ...
Q = np.zeros((len(gridu), Nv, 2))
if isinstance(srf, SplineSurface):
for i,u in enumerate(gridu):
for j,v in enumerate(vs):
Q[i,j,:] = point_on_bspline_surface(Tu, Tv, P, u, v)
elif isinstance(srf, NurbsSurface):
W = srf.weights
for i,u in enumerate(gridu):
for j,v in enumerate(vs):
Q[i,j,:] = point_on_nurbs_surface(Tu, Tv, P, W, u, v)
for i in range(len(gridu)):
lines += [go.Scatter(mode = 'lines', line=line_marker,
x=Q[i,:,0],
y=Q[i,:,1])
]
# ...
# ...
Q = np.zeros((Nu, len(gridv), 2))
if isinstance(srf, SplineSurface):
for i,u in enumerate(us):
for j,v in enumerate(gridv):
Q[i,j,:] = point_on_bspline_surface(Tu, Tv, P, u, v)
elif isinstance(srf, NurbsSurface):
W = srf.weights
for i,u in enumerate(us):
for j,v in enumerate(gridv):
Q[i,j,:] = point_on_nurbs_surface(Tu, Tv, P, W, u, v)
for j in range(len(gridv)):
lines += [go.Scatter(mode = 'lines', line=line_marker,
x=Q[:,j,0],
y=Q[:,j,1])
]
# ...
if not control_polygon:
return lines
# ... control polygon
line_marker = dict(color='#ff7f0e', width=2)
for i in range(nu):
lines += [go.Scatter(mode = 'lines+markers',
line=line_marker,
x=P[i,:,0],
y=P[i,:,1])
]
for j in range(nv):
lines += [go.Scatter(mode = 'lines+markers',
line=line_marker,
x=P[:,j,0],
y=P[:,j,1])
]
# ...
return lines
# ...
# ...
def model_from_data(data):
# ...
weights = None
try:
knots, degree, points = data
points = np.asarray(points)
except:
try:
knots, degree, points, weights = data
points = np.asarray(points)
weights = np.asarray(weights)
except:
raise ValueError('Could not retrieve data')
# ...
if isinstance(knots, (tuple, list)):
knots = [np.asarray(T) for T in knots]
if isinstance(degree, int):
if weights is None:
current_model = SplineCurve(knots=knots,
degree=degree,
points=points)
else:
current_model = NurbsCurve(knots=knots,
degree=degree,
points=points,
weights=weights)
elif len(degree) == 2:
if weights is None:
current_model = SplineSurface(knots=knots,
degree=degree,
points=points)
else:
current_model = NurbsSurface(knots=knots,
degree=degree,
points=points,
weights=weights)
return current_model
# ...
# =================================================================
tab_line = dcc.Tab(label='line', children=[
html.Label('origin'),
dcc.Input(id='line_origin',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Label('end'),
dcc.Input(id='line_end',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Button('Submit', id='line_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_arc = dcc.Tab(label='arc', children=[
html.Label('center'),
dcc.Input(id='arc_center',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Label('radius'),
dcc.Input(id='arc_radius',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Label('angle'),
dcc.Dropdown(id="arc_angle",
options=[{'label': '90', 'value': '90'},
{'label': '120', 'value': '120'},
{'label': '180', 'value': '180'}],
value=[],
multi=False),
html.Button('Submit', id='arc_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_square = dcc.Tab(label='square', children=[
html.Label('origin'),
dcc.Input(id='square_origin',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Label('length'),
dcc.Input(id='square_length',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Button('Submit', id='square_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_circle = dcc.Tab(label='circle', children=[
html.Label('center'),
dcc.Input(id='circle_center',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Label('radius'),
dcc.Input(id='circle_radius',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Button('Submit', id='circle_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_half_annulus_cubic = dcc.Tab(label='half_annulus_cubic', children=[
html.Label('center'),
dcc.Input(id='half_annulus_cubic_center',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Label('rmax'),
dcc.Input(id='half_annulus_cubic_rmax',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Label('rmin'),
dcc.Input(id='half_annulus_cubic_rmin',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Button('Submit', id='half_annulus_cubic_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_L_shape_C1 = dcc.Tab(label='L_shape_C1', children=[
html.Label('center'),
dcc.Input(id='L_shape_C1_center',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Button('Submit', id='L_shape_C1_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_cube = dcc.Tab(label='cube', children=[
html.Label('origin'),
dcc.Input(id='cube_origin',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Button('Submit', id='cube_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_cylinder = dcc.Tab(label='cylinder', children=[
html.Label('origin'),
dcc.Input(id='cylinder_origin',
placeholder='Enter a value ...',
value='',
type='text'
),
html.Button('Submit', id='cylinder_submit',
n_clicks_timestamp=0),
])
# =================================================================
tab_geometry_1d = dcc.Tab(label='1D', children=[
dcc.Tabs(children=[
tab_line,
tab_arc,
]),
])
# =================================================================
tab_geometry_2d = dcc.Tab(label='2D', children=[
dcc.Tabs(children=[
tab_square,
tab_circle,
tab_half_annulus_cubic,
tab_L_shape_C1,
]),
])
# =================================================================
tab_geometry_3d = dcc.Tab(label='3D', children=[
dcc.Tabs(children=[
tab_cube,
tab_cylinder,
]),
])
# =================================================================
tab_loader = dcc.Tab(label='Load', children=[
html.Button('load', id='button_load',
n_clicks_timestamp=0),
dcc.Store(id='loaded_model'),
dcc.Tabs(children=[
tab_geometry_1d,
tab_geometry_2d,
tab_geometry_3d
]),
])
# =================================================================
tab_insert_knot = dcc.Tab(label='Insert knot', children=[
html.Div([
html.Label('Knot'),
dcc.Input(id='insert_knot_value',
placeholder='Enter a value ...',
value='',
# we use text rather than number to avoid
# having the incrementation/decrementation
type='text'
),
html.Label('times'),
daq.NumericInput(id='insert_knot_times',
min=1,
value=0
),
html.Button('Submit', id='insert_submit',
n_clicks_timestamp=0),
]),
])
# =================================================================
tab_elevate_degree = dcc.Tab(label='Elevate degree', children=[
html.Div([
html.Label('times'),
daq.NumericInput(id='elevate_degree_times',
min=0,
value=0
),
html.Button('Submit', id='elevate_submit',
n_clicks_timestamp=0),
]),
])
# =================================================================
tab_subdivision = dcc.Tab(label='Subdivision', children=[
html.Div([
html.Label('times'),
daq.NumericInput(id='subdivision_times',
min=0,
value=0
),
html.Button('Submit', id='subdivide_submit',
n_clicks_timestamp=0),
]),
])
# =================================================================
tab_refinement = dcc.Tab(label='Refinement', children=[
dcc.Store(id='refined_model'),
html.Div([
# ...
html.Label('Axis'),
dcc.Dropdown(id="axis",
options=[{'label': 'u', 'value': '0'},
{'label': 'v', 'value': '1'},
{'label': 'w', 'value': '2'}],
value=[],
multi=True),
html.Button('Apply', id='button_refine',
n_clicks_timestamp=0),
html.Hr(),
# ...
# ...
dcc.Tabs(children=[
tab_insert_knot,
tab_elevate_degree,
tab_subdivision
]),
# ...
])
])
# =================================================================
tab_translate = dcc.Tab(label='Translate', children=[
html.Div([
html.Label('displacement'),
dcc.Input(id='translate_disp',
placeholder='Enter a value ...',
value='',
type='text'),
html.Button('Submit', id='translate_submit',
n_clicks_timestamp=0),
]),
])
# =================================================================
tab_rotate = dcc.Tab(label='Rotate', children=[
html.Div([
html.Label('center'),
dcc.Input(id='rotate_center',
placeholder='Enter a value ...',
value='',
type='text'),
html.Label('angle'),
dcc.Input(id='rotate_angle',
placeholder='Enter a value ...',
value='',
type='text'),
html.Button('Submit', id='rotate_submit',
n_clicks_timestamp=0),
]),
])
# =================================================================
tab_homothetie = dcc.Tab(label='Homothetie', children=[
html.Div([
html.Label('center'),
dcc.Input(id='homothetie_center',
placeholder='Enter a value ...',
value='',
type='text'),
html.Label('scale'),
dcc.Input(id='homothetie_alpha',
placeholder='Enter a value ...',
value='',
type='text'),
html.Button('Submit', id='homothetie_submit',
n_clicks_timestamp=0),
]),
])
# =================================================================
tab_transformation = dcc.Tab(label='Transformation', children=[
dcc.Store(id='transformed_model'),
html.Div([
# ...
html.Button('Apply', id='button_transform',
n_clicks_timestamp=0),
dcc.Tabs(children=[
tab_translate,
tab_rotate,
tab_homothetie,
]),
# ...
])
])
# =================================================================
tab_editor = dcc.Tab(label='Editor', children=[
html.Button('Edit', id='button_edit',
n_clicks_timestamp=0),
dcc.Store(id='edited_model'),
html.Div([
html.Div(id='editor-Tu'),
html.Div(id='editor-Tv'),
html.Div(id='editor-Tw'),
html.Div(id='editor-degree'),
dash_table.DataTable(id='editor-table',
columns=[],
editable=True),
])
])
# =================================================================
tab_viewer = dcc.Tab(label='Viewer', children=[
html.Label('Geometry'),
dcc.Dropdown(id="model",
options=[{'label':name, 'value':name}
for name in namespace.keys()],
value=[],
multi=True),
html.Div([
daq.BooleanSwitch(label='Control polygon',
id='control_polygon',
on=False
),
# ...
html.Div([
dcc.Graph(id="graph")]),
# ...
])
])
# =================================================================
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
app.layout = html.Div([
# ...
html.H1(children='CAID'),
# ...
# ...
dcc.Tabs(id="tabs", children=[
tab_viewer,
tab_loader,
tab_refinement,
tab_transformation,
tab_editor,
]),
html.Div(id='tabs-content-example')
# ...
])
# =================================================================
@app.callback(
Output("loaded_model", "data"),
[Input('button_load', 'n_clicks_timestamp'),
Input('line_origin', 'value'),
Input('line_end', 'value'),
Input('line_submit', 'n_clicks_timestamp'),
Input('arc_center', 'value'),
Input('arc_radius', 'value'),
Input('arc_angle', 'value'),
Input('arc_submit', 'n_clicks_timestamp'),
Input('square_origin', 'value'),
Input('square_length', 'value'),
Input('square_submit', 'n_clicks_timestamp'),
Input('circle_center', 'value'),
Input('circle_radius', 'value'),
Input('circle_submit', 'n_clicks_timestamp'),
Input('half_annulus_cubic_center', 'value'),
Input('half_annulus_cubic_rmax', 'value'),
Input('half_annulus_cubic_rmin', 'value'),
Input('half_annulus_cubic_submit', 'n_clicks_timestamp'),
Input('L_shape_C1_center', 'value'),
Input('L_shape_C1_submit', 'n_clicks_timestamp')]
)
def load_model(time_clicks,
line_origin, line_end,
line_submit_time,
arc_center, arc_radius, arc_angle,
arc_submit_time,
square_origin, square_length,
square_submit_time,
circle_center, circle_radius,
circle_submit_time,
half_annulus_cubic_center,
half_annulus_cubic_rmax,
half_annulus_cubic_rmin,
half_annulus_cubic_submit_time,
L_shape_C1_center,
L_shape_C1_submit_time):
global d_timestamp
if time_clicks <= d_timestamp['load']:
return None
d_timestamp['load'] = time_clicks
if ( not( line_origin is '' ) and
not( line_end is '' ) and
not( line_submit_time <= d_timestamp['line'] )
):
# ...
try:
line_origin = [float(i) for i in line_origin.split(',')]
except:
raise ValueError('Cannot convert line_origin')
# ...
# ...
try:
line_end = [float(i) for i in line_end.split(',')]
except:
raise ValueError('Cannot convert line_end')
# ...
d_timestamp['line'] = line_submit_time
return make_line(origin=line_origin,
end=line_end)
elif ( not( arc_center is '' ) and
not( arc_radius is '' ) and
arc_angle and
not( arc_submit_time <= d_timestamp['arc'] )
):
# ...
try:
arc_center = [float(i) for i in arc_center.split(',')]
except:
raise ValueError('Cannot convert arc_center')
# ...
# ...
try:
arc_radius = float(arc_radius)
except:
raise ValueError('Cannot convert arc_radius')
# ...
# ...
try:
arc_angle = float(arc_angle)
except:
raise ValueError('Cannot convert arc_angle')
# ...
d_timestamp['arc'] = arc_submit_time
return make_arc(center=arc_center,
radius=arc_radius,
angle=arc_angle)
elif ( not( square_origin is '' ) and
not( square_length is '' ) and
not( square_submit_time <= d_timestamp['square'] )
):
# ...
try:
square_origin = [float(i) for i in square_origin.split(',')]
except:
raise ValueError('Cannot convert square_origin')
# ...
# ...
try:
square_length = float(square_length)
except:
raise ValueError('Cannot convert square_length')
# ...
d_timestamp['square'] = square_submit_time
return make_square(origin=square_origin,
length=square_length)
elif ( not( circle_center is '' ) and
not( circle_radius is '' ) and
not( circle_submit_time <= d_timestamp['circle'] )
):
# ...
try:
circle_center = [float(i) for i in circle_center.split(',')]
except:
raise ValueError('Cannot convert circle_center')
# ...
# ...
try:
circle_radius = float(circle_radius)
except:
raise ValueError('Cannot convert circle_radius')
# ...
d_timestamp['circle'] = circle_submit_time
return make_circle(center=circle_center,
radius=circle_radius)
elif ( not( half_annulus_cubic_center is '' ) and
not( half_annulus_cubic_rmax is '' ) and
not( half_annulus_cubic_rmin is '' ) and
not( half_annulus_cubic_submit_time <= d_timestamp['half_annulus_cubic'] )
):
# ...
try:
half_annulus_cubic_center = [float(i) for i in half_annulus_cubic_center.split(',')]
except:
raise ValueError('Cannot convert half_annulus_cubic_center')
# ...
# ...
try:
half_annulus_cubic_rmax = float(half_annulus_cubic_rmax)
except:
raise ValueError('Cannot convert half_annulus_cubic_rmax')
# ...
# ...
try:
half_annulus_cubic_rmin = float(half_annulus_cubic_rmin)
except:
raise ValueError('Cannot convert half_annulus_cubic_rmin')
# ...
d_timestamp['half_annulus_cubic'] = half_annulus_cubic_submit_time
return make_half_annulus_cubic(center=half_annulus_cubic_center,
rmax=half_annulus_cubic_rmax,
rmin=half_annulus_cubic_rmin)
elif ( not( L_shape_C1_center is '' ) and
not( L_shape_C1_submit_time <= d_timestamp['L_shape_C1'] )
):
# ...
try:
L_shape_C1_center = [float(i) for i in L_shape_C1_center.split(',')]
except:
raise ValueError('Cannot convert L_shape_C1_center')
# ...
d_timestamp['L_shape_C1'] = L_shape_C1_submit_time
return make_L_shape_C1(center=L_shape_C1_center)
else:
return None
# =================================================================
@app.callback(
Output("refined_model", "data"),
[Input("model", "value"),
Input('button_refine', 'n_clicks_timestamp'),
Input('insert_knot_value', 'value'),
Input('insert_knot_times', 'value'),
Input('insert_submit', 'n_clicks_timestamp'),
Input('elevate_degree_times', 'value'),
Input('elevate_submit', 'n_clicks_timestamp'),
Input('subdivision_times', 'value'),
Input('subdivide_submit', 'n_clicks_timestamp')]
)
def apply_refine(models,
time_clicks,
t, t_times,
insert_submit_time,
m,
elevate_submit_time,
levels,
subdivide_submit_time):
global d_timestamp
if time_clicks <= d_timestamp['refine']:
return None
d_timestamp['refine'] = time_clicks
if len(models) == 0:
return None
if len(models) > 1:
return None
name = models[0]
model = namespace[name]
# ... insert knot
if not( t is '' ) and not( insert_submit_time <= d_timestamp['insert'] ):
times = int(t_times)
t = float(t)
if isinstance(model, (SplineCurve, NurbsCurve)):
t_min = model.knots[ model.degree]
t_max = model.knots[-model.degree]
if t > t_min and t < t_max:
if isinstance(model, SplineCurve):
knots, degree, P = insert_knot_bspline_curve( model.knots,
model.degree,
model.points,
t, times=times )
model = SplineCurve(knots=knots,
degree=degree,
points=P)
elif isinstance(model, NurbsCurve):
knots, degree, P, W = insert_knot_nurbs_curve( model.knots,
model.degree,
model.points,
model.weights,
t, times=times )
model = NurbsCurve(knots=knots,
degree=degree,
points=P,
weights=W)
elif isinstance(model, (SplineSurface, NurbsSurface)):
u_min = model.knots[0][ model.degree[0]]
u_max = model.knots[0][-model.degree[0]]
v_min = model.knots[1][ model.degree[1]]
v_max = model.knots[1][-model.degree[1]]
condition = False
# TODO
if t > u_min and t < u_max:
if isinstance(model, SplineSurface):
Tu, Tv, pu, pv, P = insert_knot_bspline_surface( *model.knots,
*model.degree,
model.points,
t,
times=times,
axis=None)
model = SplineSurface(knots=(Tu, Tv), degree=(pu, pv), points=P)
elif isinstance(model, NurbsSurface):
Tu, Tv, pu, pv, P, W = insert_knot_nurbs_surface( *model.knots,
*model.degree,
model.points,
model.weights,
t,
times=times,
axis=None)
model = NurbsSurface(knots=(Tu, Tv),
degree=(pu, pv),
points=P,
weights=W)
d_timestamp['insert'] = insert_submit_time
# ...
# ... degree elevation
if m > 0 and not( elevate_submit_time <= d_timestamp['elevate'] ) :
m = int(m)
if isinstance(model, SplineCurve):
knots, degree, P = elevate_degree_bspline_curve( model.knots,
model.degree,
model.points,
m=m)
model = SplineCurve(knots=knots,
degree=degree,
points=P)
elif isinstance(model, NurbsCurve):
knots, degree, P, W = elevate_degree_nurbs_curve( model.knots,
model.degree,
model.points,
model.weights,
m=m)
model = NurbsCurve(knots=knots,
degree=degree,
points=P,
weights=W)
elif isinstance(model, SplineSurface):
Tu, Tv, pu, pv, P = elevate_degree_bspline_surface( *model.knots,
*model.degree,
model.points,
m=m)
model = SplineSurface(knots=(Tu, Tv),
degree=(pu, pv),
points=P)
elif isinstance(model, NurbsSurface):
Tu, Tv, pu, pv, P, W = elevate_degree_nurbs_surface( *model.knots,
*model.degree,
model.points,
model.weights,
m=m)
model = NurbsSurface(knots=(Tu, Tv),
degree=(pu, pv),
points=P,
weights=W)
d_timestamp['elevate'] = elevate_submit_time
# ...
# ...subdivision
if levels > 0 and not( subdivide_submit_time <= d_timestamp['subdivide'] ):
levels = int(levels)
for level in range(levels):
grid = np.unique(model.knots)
for a,b in zip(grid[:-1], grid[1:]):
t = (a+b)/2.
knots, degree, P = insert_knot_bspline_curve( model.knots,
model.degree,
model.points,
t, times=1 )
model = SplineCurve(knots=knots, degree=degree, points=P)
d_timestamp['subdivide'] = subdivide_submit_time
# ...
print('refinement done')
return model
# =================================================================
@app.callback(
Output("transformed_model", "data"),
[Input("model", "value"),
Input('button_transform', 'n_clicks_timestamp'),
Input('translate_disp', 'value'),
Input('translate_submit', 'n_clicks_timestamp'),
Input('rotate_center', 'value'),
Input('rotate_angle', 'value'),
Input('rotate_submit', 'n_clicks_timestamp'),
Input('homothetie_alpha', 'value'),
Input('homothetie_center', 'value'),
Input('homothetie_submit', 'n_clicks_timestamp')]
)
def apply_transform(models,
time_clicks,
translate_disp,
translate_submit_time,
rotate_center,
rotate_angle,
rotate_submit_time,
homothetie_alpha,
homothetie_center,
homothetie_submit_time):
global d_timestamp
if time_clicks <= d_timestamp['transform']:
return None
d_timestamp['transform'] = time_clicks
if len(models) == 0:
return None
if len(models) > 1:
return None
name = models[0]
model = namespace[name]
if not( translate_disp is '' ) and not( translate_submit_time <= d_timestamp['translate'] ):
# ...
try:
displ = [float(i) for i in translate_disp.split(',')]
except:
raise ValueError('Cannot convert translate_disp')
# ...
displ = np.asarray(displ)
if isinstance(model, SplineCurve):
knots, P = translate_bspline_curve(model.knots,
model.points,
displ)
model = SplineCurve(knots=knots,
degree=model.degree,
points=P)
elif isinstance(model, NurbsCurve):
knots, P, W = translate_nurbs_curve(model.knots,
model.points,
model.weights,
displ)
model = NurbsCurve(knots=knots,
degree=model.degree,
points=P,
weights=W)
elif not( rotate_center is '' ) and not( rotate_angle is '' ) and not( rotate_submit_time <= d_timestamp['rotate'] ):
# ...
try:
center = [float(i) for i in rotate_center.split(',')]
center = | np.asarray(center) | numpy.asarray |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import numpy as np
from collections import defaultdict
import copy
np.random.seed=2021
# In[2]:
def temp_scaled_softmax(data,temp=1.0):
prob=np.exp(data/temp)/np.sum( | np.exp(data/temp) | numpy.exp |
# Import Packages
import numpy as np
import pandas as pd
from bitarray import bitarray
from sklearn.base import clone
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score, roc_auc_score, average_precision_score
from sklearn.utils import shuffle
from sklearn.model_selection import LeaveOneOut, StratifiedKFold
from sklearn.metrics import SCORERS
from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt
#Define some useful functions
# Load disproportionality data (from Harpaz et al)
# calculated on FAERS data through Q3 2011
# I skip LR and ELR here
# The LR and ELR they present are calculated differently
# by running the regressor on more empirical data, and not just
# by running it on calculated ratios (as done here).
def loadharpazdata(inputfile, labelfile, harpazfile):
tmpvecs = []
tmpqueries = []
with open(inputfile, 'r') as infile:
infile.readline()#skip header row
for line in infile:
tmp = line.strip().split('|')
tmpvecs += [np.asarray(bitarray(tmp[1]).tolist(), dtype=int)]
tmpqueries += [tmp[0]]
tmpdf = pd.DataFrame(np.asarray(tmpvecs))
tmpdf.columns = [str(x) for x in range(1, np.asarray(tmpvecs).shape[1]+1)]
tmpdf.insert(0, 'Query', tmpqueries)
labsdict = dict()
with open(labelfile,'r') as infile:
for line in infile:
tmp = line.strip().split('\t')
labsdict[tmp[1]] = int(tmp[0])
tmpdf.insert(1, 'Label', [labsdict[x] for x in tmpqueries])
prrdict = dict()
with open(harpazfile, 'r') as infile:
infile.readline() #skip header
for line in infile:
tmp = line.strip().split('\t')
if tmp[0] == 'darunavir' or tmp[0] == 'sitagliptin':
continue
if tmp[0] == 'tenofovir':
prrdict[f'S({tmp[0]})*S({tmp[1]})'] = ['NA']*8
continue
prrdict[f'S({tmp[0]})*S({tmp[1]})'] = [tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[21], tmp[22]]
#['EBGM', 'EB05', 'PRR', 'PRR05', 'ROR', 'ROR05', 'EBGM (none-stratified)', 'EB05 (none-stratified)']
tmpdf.insert(2, 'EB05NoStrat', [prrdict[x][-1] for x in tmpqueries])
tmpdf.insert(2, 'EBGMNoStrat', [prrdict[x][-2] for x in tmpqueries])
tmpdf.insert(2, 'ROR05', [prrdict[x][-3] for x in tmpqueries])
tmpdf.insert(2, 'ROR', [prrdict[x][-4] for x in tmpqueries])
tmpdf.insert(2, 'PRR05', [prrdict[x][-5] for x in tmpqueries])
tmpdf.insert(2, 'PRR', [prrdict[x][-6] for x in tmpqueries])
tmpdf.insert(2, 'EB05', [prrdict[x][-7] for x in tmpqueries])
tmpdf.insert(2, 'EBGM', [prrdict[x][-8] for x in tmpqueries])
return tmpdf
#Load disproportionality data calculated by Banda et al
#from FAERS data through Q2 2015
def loadbandadata(inputfile, labelfile, bandafile):
tmpvecs = []
tmpqueries = []
with open(inputfile, 'r') as infile:
infile.readline()#skip header row
for line in infile:
tmp = line.strip().split('|')
tmpvecs += [np.asarray(bitarray(tmp[1]).tolist(), dtype=int)]
tmpqueries += [tmp[0]]
tmpdf = pd.DataFrame(np.asarray(tmpvecs))
tmpdf.columns = [str(x) for x in range(1, np.asarray(tmpvecs).shape[1]+1)]
tmpdf.insert(0, 'Query', tmpqueries)
labsdict = dict()
with open(labelfile,'r') as infile:
for line in infile:
tmp = line.strip().split('\t')
labsdict[tmp[1]] = int(tmp[0])
tmpdf.insert(1, 'Label', [labsdict[x] for x in tmpqueries])
prrdict = dict()
with open(bandafile, 'r') as infile:
for line in infile:
tmp = line.strip().split('\t')
prrdict['S(fluvoxamine)*S(diseases_of_mitral_valve)'] = ['NA'] * 10
prrdict['S(captopril)*S(acute_kidney_insufficiency)'] = ['NA'] * 10
prrdict['S(carteolol)*S(liver_failure,_acute)'] = ['NA'] * 10
prrdict[f'S({tmp[0]})*S({tmp[1]})'] = [tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8]]
#Drug ADE #Reports PRR PRRUB PRRLB ROR RORUB RORLB
tmpdf.insert(2, 'RORLB', [prrdict[x][-1] for x in tmpqueries])
tmpdf.insert(2, 'RORUB', [prrdict[x][-2] for x in tmpqueries])
tmpdf.insert(2, 'ROR', [prrdict[x][-3] for x in tmpqueries])
tmpdf.insert(2, 'PRRLB', [prrdict[x][-4] for x in tmpqueries])
tmpdf.insert(2, 'PRRUB', [prrdict[x][-5] for x in tmpqueries])
tmpdf.insert(2, 'PRR', [prrdict[x][-6] for x in tmpqueries])
tmpdf.insert(2, 'CaseReports', [prrdict[x][-7] for x in tmpqueries])
return tmpdf
# Leave one out crossvalidation quick test
def lootest(df):
preds = []
predprob = []
reals = []
vecs = np.asarray(df.iloc[:,2:])
labels = np.asarray(df.Label)
for train,test in LeaveOneOut().split(vecs):
model = LogisticRegression(penalty='l1', solver='liblinear')
model.fit(vecs[train], labels[train])
preds += [model.predict(vecs[test])]
predprob += [model.predict_proba(vecs[test])[:,1]]
reals += [labels[test]]
return(f1_score(reals, preds), roc_auc_score(reals, predprob))
# Stratified 5 Fold crossvalidation quick test
# Returns overall F1 and ROC AUC for comparison to other research
# That is, we don't compute fold to fold, but over the whole set
def skftest(df):
reals = np.asarray([])
preds = np.asarray([])
predprob = np.asarray([])
vecs = np.asarray(df.iloc[:,2:])
labels = np.asarray(df.Label)
for train,test in StratifiedKFold(n_splits=5, shuffle=True).split(vecs, labels):
model = LogisticRegression(penalty='l1', solver='liblinear')
model.fit(vecs[train], labels[train])
predprob = np.append(predprob, model.predict_proba(vecs[test])[:,1])
reals = np.append(reals, labels[test])
preds = np.append(preds, model.predict(vecs[test]))
return(f1_score(reals, preds), roc_auc_score(reals, predprob))
# Get the average performance across 100 runs for a given LR training model
def get_average_performance(df, trainfunc):
aucscores = []
fscores = []
for i in range(100):
tmpf1, tmpauc = trainfunc(df)
fscores += [tmpf1]
aucscores += [tmpauc]
return(np.average(fscores), 1.96*(np.std(fscores)/np.sqrt(100)), np.average(aucscores), 1.96*(np.std(aucscores)/np.sqrt(100)))
# Create an ensemble method which weights the literature at a float between 0 and 1 relative contribution
def ensembleskftest(basevecs, dvecs, labels, litweight=0.1):
reals = np.asarray([])
preds = np.asarray([])
basepredprob = np.asarray([])
dpredprob = np.asarray([])
predprob = np.asarray([])
for train,test in StratifiedKFold(n_splits=5, shuffle=True).split(basevecs, labels):
basemodel = LogisticRegression(penalty='l1', solver='liblinear', max_iter=200)
basemodel.fit(basevecs[train], labels[train])
baseprob = basemodel.predict_proba(basevecs[test])[:,1]
basepredprob = np.append(basepredprob, baseprob)
dmodel = LogisticRegression(penalty='l1', solver='liblinear', max_iter=200)
dmodel.fit(dvecs[train], labels[train])
dprob = dmodel.predict_proba(dvecs[test])[:,1]
dpredprob = np.append(dpredprob, dprob)
ensembleprob = baseprob*litweight+dprob*(1-litweight)
predprob = np.append(predprob, ensembleprob)
reals = np.append(reals, labels[test])
preds = np.append(preds, np.round(ensembleprob))
return(average_precision_score(reals, preds), roc_auc_score(reals, predprob))
def get_average_performance_ensemble(trainfunc, litvecs, dvecs, labels, weight):
aucscores = []
fscores = []
runs = 100
for i in range(runs):
tmpf1, tmpauc = trainfunc(litvecs, dvecs, labels, weight)
fscores += [tmpf1]
aucscores += [tmpauc]
return(np.average(fscores), np.std(fscores)/np.sqrt(runs), np.average(aucscores), np.std(aucscores)/np.sqrt(runs)) #1.96 is multiplied later in graphing
#Define graphing functions
def plot_ensemble(df, disproidx, title='Ensemble Model Performance'):
plt.figure(figsize=(15,10), dpi=300)
plt.title(title)
plt.xlabel("Percent Literature Contribution to Prediction")
plt.ylabel("Mean ROC AUC")
litvecs = np.asarray(df.iloc[:,disproidx:])
dvecs = np.asarray(df.iloc[:,2:disproidx])
labels = np.asarray(df.Label)
litweights = np.linspace(0,1,20)
#test_scores = []
baselinedscore = []
test_scores_mean = []
test_scores_std = []
for lw in litweights:
'''
_tmpscores = []
for train,test in StratifiedKFold(n_splits=5, shuffle=True).split(litvecs, labels):
#Define models and fit
litmodel = LogisticRegression(penalty='l1', solver='liblinear')
litmodel.fit(litvecs[train], labels[train])
dmodel = LogisticRegression(penalty='l1', solver='liblinear')
dmodel.fit(dvecs[train], labels[train])
#Get respective performance
litprob = litmodel.predict_proba(litvecs[test])[:,1]
dprob = dmodel.predict_proba(dvecs[test])[:,1]
ensembleprob = litprob*lw+dprob*(1-lw)
preds = np.round(ensembleprob)
_tmpscores += [f1_score(labels[test], preds)]
test_scores += [_tmpscores]
#print(test_scores)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
'''
_tmpresults = get_average_performance_ensemble(ensembleskftest, litvecs, dvecs, labels, lw)
test_scores_mean += [_tmpresults[2]]
test_scores_std += [_tmpresults[3]]
plt.grid()
plt.fill_between(litweights, np.asarray(test_scores_mean) - np.asarray(test_scores_std)*1.96,
np.asarray(test_scores_mean) + np.asarray(test_scores_std)*1.96, alpha=0.1, color="g")
plt.plot(litweights, np.asarray(test_scores_mean), '^-', color="g",
label="Ensemble Model")
plt.fill_between(litweights, [test_scores_mean[0] - test_scores_std[0]*1.96]*len(litweights),
[test_scores_mean[0]+test_scores_std[0]*1.96]*len(litweights), alpha=0.1, color='b')
plt.plot(litweights, [test_scores_mean[0]]*len(litweights), 's-', color='b', label='DPM Only')
plt.legend(loc="best")
plt.ylim(0.5, 1.0)
return plt
def plot_shuffle_triple_comparison_learning_curve(estimator, title, X1, y1, X2, y2, X3, y3, ylim=None, cv=None,
n_jobs=-1, train_sizes=np.linspace(.1, 1.0, 20), score=None, label1=' ', label2=' ', label3=' '):
"""
Code adapted from: https://scikit-learn.org/stable/auto_examples/model_selection/plot_learning_curve.html#sphx-glr-auto-examples-model-selection-plot-learning-curve-py
Generate a simple plot of the test and traning learning curve.
Parameters
----------
estimator : object type that implements the "fit" and "predict" methods
An object of that type which is cloned for each validation.
title : string
Title for the chart.
X : array-like, shape (n_samples, n_features)
Training vector, where n_samples is the number of samples and
n_features is the number of features.
y : array-like, shape (n_samples) or (n_samples, n_features), optional
Target relative to X for classification or regression;
None for unsupervised learning.
ylim : tuple, shape (ymin, ymax), optional
Defines minimum and maximum yvalues plotted.
cv : integer, cross-validation generator, optional
If an integer is passed, it is the number of folds (defaults to 3).
Specific cross-validation objects can be passed, see
sklearn.cross_validation module for the list of possible objects
n_jobs : integer, optional
Number of jobs to run in parallel (default 1).
"""
fig = plt.figure(figsize=(15,10), dpi=300)
plt.title(title)
if ylim is not None:
plt.ylim(*ylim)
if score is None:
score = 'average_precision'
ylabscore = ' '.join([x.capitalize() for x in score.split('_')])
if ylabscore == 'Roc Auc':
ylabscore = 'ROC AUC'
plt.xlabel("Training Examples")
plt.ylabel(f"Mean {ylabscore}")
train_sizes2 = np.asarray(train_sizes)
train_sizes3 = np.asarray(train_sizes)
test_scores_means = []
test_scores_means2 = []
test_scores_means3 = []
for i in range(100): # probably need to refresh each of the models passed with a clone operation, in all likelihood
#Shuffle rows of data
'''
This must be done if we don't want the learning curve to essentially pick the same data points for
every single run. This is because the learning curve pulls only the first n samples, and StratifiedKFold
returns the properly stratified splits, but in index order (i.e. they aren't designed to be subsampled).
So, in order to generally keep the same stratification and subsample appropriately (for Standard Error of
the Mean, the reporting metric for variances of means), we shuffle the data set on every repetition prior
to passing to SKF-CV (note that SKF has a shuffle function, but this only shuffles membership not order).
'''
idxs = np.random.permutation(X1.shape[0])
#First Metrics
train_sizes, train_scores, test_scores = learning_curve(
clone(estimator), X1[idxs], y1[idxs], cv=cv, n_jobs=n_jobs, train_sizes=train_sizes, scoring=score, shuffle=False)
#Comparison Metrics
train_sizes2, train_scores2, test_scores2 = learning_curve(
clone(estimator), X2[idxs], y2[idxs], cv=cv, n_jobs=n_jobs, train_sizes=train_sizes2, scoring=score, shuffle=False)
train_sizes3, train_scores3, test_scores3 = learning_curve(
clone(estimator), X3[idxs], y3[idxs], cv=cv, n_jobs=n_jobs, train_sizes=train_sizes3, scoring=score, shuffle=False)
#train_scores_mean = np.mean(train_scores, axis=1)
#train_scores_std = np.std(train_scores, axis=1)
test_scores_means += [np.mean(test_scores, axis=1)]
#test_scores_std = np.std(test_scores, axis=1)
#train_scores_mean2 = np.mean(train_scores2, axis=1)
#train_scores_std2 = np.std(train_scores2, axis=1)
test_scores_means2 += [np.mean(test_scores2, axis=1)]
#test_scores_std2 = np.std(test_scores2, axis=1)
test_scores_means3 += [np.mean(test_scores3, axis=1)]
test_scores_mean = np.mean(test_scores_means, axis=0)
test_scores_std = np.std(test_scores_means, axis=0)/ | np.sqrt(100) | numpy.sqrt |
from __future__ import print_function
import itertools
import math
import os
import random
import shutil
import tempfile
import unittest
import uuid
import numpy as np
import tensorflow as tf
import coremltools
import coremltools.models.datatypes as datatypes
from coremltools.models import _MLMODEL_FULL_PRECISION, _MLMODEL_HALF_PRECISION
from coremltools.models import neural_network as neural_network
from coremltools.models.utils import macos_version
from coremltools.models.neural_network import flexible_shape_utils
np.random.seed(10)
MIN_MACOS_VERSION_REQUIRED = (10, 13)
LAYERS_10_15_MACOS_VERSION = (10, 15)
def _get_unary_model_spec(x, mode, alpha=1.0):
input_dim = x.shape
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', datatypes.Array(*input_dim))]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_unary(name='unary', input_name='data',
output_name='output', mode=mode, alpha=alpha)
return builder.spec
class CorrectnessTest(unittest.TestCase):
def runTest(self):
pass
def _compare_shapes(self, np_preds, coreml_preds):
return np.squeeze(np_preds).shape == np.squeeze(coreml_preds).shape
def _compare_nd_shapes(self, np_preds, coreml_preds, shape=()):
if shape:
return coreml_preds.shape == shape
else:
return coreml_preds.shape == np_preds.shape
def _compare_predictions(self, np_preds, coreml_preds, delta=.01):
np_preds = np_preds.flatten()
coreml_preds = coreml_preds.flatten()
for i in range(len(np_preds)):
max_den = max(1.0, np_preds[i], coreml_preds[i])
if np.abs(
np_preds[i] / max_den - coreml_preds[i] / max_den) > delta:
return False
return True
@staticmethod
def _compare_moments(model, inputs, expected, use_cpu_only=True, num_moments=10):
"""
This utility function is used for validate random distributions layers.
It validates the first 10 moments of prediction and expected values.
"""
def get_moment(data, k):
return np.mean(np.power(data - np.mean(data), k))
if isinstance(model, str):
model = coremltools.models.MLModel(model)
model = coremltools.models.MLModel(model, useCPUOnly=use_cpu_only)
prediction = model.predict(inputs, useCPUOnly=use_cpu_only)
for output_name in expected:
np_preds = expected[output_name]
coreml_preds = prediction[output_name]
np_moments = [get_moment(np_preds.flatten(), k) for k in range(num_moments)]
coreml_moments = [get_moment(coreml_preds.flatten(), k) for k in range(num_moments)]
np.testing.assert_almost_equal(np_moments, coreml_moments, decimal=2)
# override expected values to allow element-wise compares
for output_name in expected:
expected[output_name] = prediction[output_name]
def _test_model(self,
model,
input,
expected,
model_precision=_MLMODEL_FULL_PRECISION,
useCPUOnly=False,
output_name_shape_dict={},
validate_shapes_only=False):
model_dir = None
# if we're given a path to a model
if isinstance(model, str):
model = coremltools.models.MLModel(model)
# If we're passed in a specification, save out the model
# and then load it back up
elif isinstance(model, coremltools.proto.Model_pb2.Model):
model_dir = tempfile.mkdtemp()
model_name = str(uuid.uuid4()) + '.mlmodel'
model_path = os.path.join(model_dir, model_name)
coremltools.utils.save_spec(model, model_path)
model = coremltools.models.MLModel(model, useCPUOnly=useCPUOnly)
# If we want to test the half precision case
if model_precision == _MLMODEL_HALF_PRECISION:
model = coremltools.utils.convert_neural_network_weights_to_fp16(
model)
prediction = model.predict(input, useCPUOnly=useCPUOnly)
for output_name in expected:
if self.__class__.__name__ == "SimpleTest":
assert (self._compare_shapes(expected[output_name],
prediction[output_name]))
else:
if output_name in output_name_shape_dict:
output_shape = output_name_shape_dict[output_name]
else:
output_shape = []
if len(output_shape) == 0 and len(expected[output_name].shape) == 0:
output_shape = (1,)
assert (self._compare_nd_shapes(expected[output_name],
prediction[output_name],
output_shape))
if not validate_shapes_only:
assert (self._compare_predictions(expected[output_name],
prediction[output_name]))
# Remove the temporary directory if we created one
if model_dir and os.path.exists(model_dir):
shutil.rmtree(model_dir)
@unittest.skipIf(macos_version() < MIN_MACOS_VERSION_REQUIRED,
'macOS 10.13+ is required. Skipping tests.')
class SimpleTest(CorrectnessTest):
def test_tiny_upsample_linear_mode(self):
input_dim = (1, 1, 3) # (C,H,W)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_upsample(name='upsample',
scaling_factor_h=2, scaling_factor_w=3,
input_name='data', output_name='output',
mode='BILINEAR')
input = {
'data': np.reshape(np.array([1.0, 2.0, 3.0]), (1, 1, 3))
}
expected = {
'output': np.array(
[[1, 1.333, 1.666, 2, 2.333, 2.666, 3, 3, 3],
[1, 1.333, 1.6666, 2, 2.33333, 2.6666, 3, 3, 3]
])
}
self._test_model(builder.spec, input, expected)
def test_LRN(self):
input_dim = (1, 3, 3)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', datatypes.Array(*input_dim))]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_lrn(name='lrn', input_name='data', output_name='output',
alpha=2, beta=3, local_size=1, k=8)
input = {
'data': np.ones((1, 3, 3))
}
expected = {
'output': 1e-3 * np.ones((1, 3, 3))
}
self._test_model(builder.spec, input, expected)
def test_MVN(self):
input_dim = (2, 2, 2)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', datatypes.Array(*input_dim))]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_mvn(name='mvn', input_name='data', output_name='output',
across_channels=False, normalize_variance=False)
input = {
'data': np.reshape(np.arange(8, dtype=np.float32), (2, 2, 2))
}
expected = {
'output': np.reshape(np.arange(8) - np.array(
[1.5, 1.5, 1.5, 1.5, 5.5, 5.5, 5.5, 5.5]), (2, 2, 2))
}
self._test_model(builder.spec, input, expected)
def test_L2_normalize(self):
input_dim = (1, 2, 2)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', datatypes.Array(*input_dim))]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_l2_normalize(name='mvn', input_name='data',
output_name='output')
input = {
'data': np.reshape(np.arange(4, dtype=np.float32), (1, 2, 2))
}
expected = {
'output': np.reshape(np.arange(4, dtype=np.float32),
(1, 2, 2)) / np.sqrt(14)
}
self._test_model(builder.spec, input, expected)
def test_unary_sqrt(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': np.sqrt(x)}
spec = _get_unary_model_spec(x, 'sqrt')
self._test_model(spec, input, expected)
def test_unary_rsqrt(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': 1 / np.sqrt(x)}
spec = _get_unary_model_spec(x, 'rsqrt')
self._test_model(spec, input, expected)
def test_unary_inverse(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': 1 / x}
spec = _get_unary_model_spec(x, 'inverse')
self._test_model(spec, input, expected)
def test_unary_power(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': x ** 3}
spec = _get_unary_model_spec(x, 'power', 3)
self._test_model(spec, input, expected)
def test_unary_exp(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': np.exp(x)}
spec = _get_unary_model_spec(x, 'exp')
self._test_model(spec, input, expected)
def test_unary_log(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': np.log(x)}
spec = _get_unary_model_spec(x, 'log')
self._test_model(spec, input, expected)
def test_unary_abs(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': np.abs(x)}
spec = _get_unary_model_spec(x, 'abs')
self._test_model(spec, input, expected)
def test_unary_threshold(self):
x = np.reshape(np.arange(1, 5, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': np.maximum(x, 2)}
spec = _get_unary_model_spec(x, 'threshold', 2)
self._test_model(spec, input, expected)
def test_split(self):
input_dim = (9, 2, 2)
x = np.random.rand(*input_dim)
input_features = [('data', datatypes.Array(*input_dim))]
output_names = []
output_features = []
for i in range(3):
out = 'out_' + str(i)
output_names.append(out)
output_features.append((out, None))
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_split(name='split', input_name='data',
output_names=output_names)
input = {'data': x}
expected = {
'out_0': x[0: 3, :, :],
'out_1': x[3: 6, :, :],
'out_2': x[6: 9, :, :]
}
self._test_model(builder.spec, input, expected)
def test_scale_constant(self):
input_dim = (1, 2, 2)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_scale(name='scale', W=5, b=45, has_bias=True,
input_name='data', output_name='output')
x = np.reshape(np.arange(4, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': 5 * x + 45}
self._test_model(builder.spec, input, expected)
def test_scale_matrix(self):
input_dim = (1, 2, 2)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
W = np.reshape(np.arange(5, 9), (1, 2, 2))
builder.add_scale(name='scale', W=W, b=None, has_bias=False,
input_name='data', output_name='output',
shape_scale=[1, 2, 2])
x = np.reshape(np.arange(4, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': W * x}
self._test_model(builder.spec, input, expected)
def test_bias_constant(self):
input_dim = (1, 2, 2)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_bias(name='bias', b=45, input_name='data',
output_name='output')
x = np.reshape(np.arange(4, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': x + 45}
self._test_model(builder.spec, input, expected)
def test_bias_matrix(self):
input_dim = (1, 2, 2)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
b = np.reshape(np.arange(5, 9), (1, 2, 2))
builder.add_bias(name='bias', b=b, input_name='data',
output_name='output',
shape_bias=[1, 2, 2])
x = np.reshape(np.arange(4, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': x + b}
self._test_model(builder.spec, input, expected)
def test_load_constant(self, model_precision=_MLMODEL_FULL_PRECISION):
input_dim = (1, 2, 2)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
b = np.reshape(np.arange(5, 9), (1, 2, 2))
builder.add_load_constant(name='load_constant', output_name='bias',
constant_value=b, shape=[1, 2, 2])
builder.add_elementwise(name='add', input_names=['data', 'bias'],
output_name='output', mode='ADD')
x = np.reshape(np.arange(4, dtype=np.float32), (1, 2, 2))
input = {'data': x}
expected = {'output': x + b}
self._test_model(builder.spec, input, expected, model_precision)
def test_load_constant_half_precision(self):
self.test_load_constant(model_precision=_MLMODEL_HALF_PRECISION)
def test_min(self):
input_dim = (1, 2, 2)
input_features = [('data_0', datatypes.Array(*input_dim)),
('data_1', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
builder.add_elementwise(name='min', input_names=['data_0', 'data_1'],
output_name='output', mode='MIN')
x1 = np.reshape(np.arange(4, dtype=np.float32), (1, 2, 2))
x2 = np.reshape(np.arange(2, 6, dtype=np.float32), (1, 2, 2))
input = {'data_0': x1, 'data_1': x2}
expected = {'output': np.minimum(x1, x2)}
self._test_model(builder.spec, input, expected)
def test_conv_same_padding(self):
input_dim = (10, 15, 15)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
W = np.random.rand(3, 3, 10, 20)
builder.add_convolution(name='conv', kernel_channels=10,
output_channels=20,
height=3, width=3, stride_height=2,
stride_width=2,
border_mode='same', groups=1,
W=W, b=None, has_bias=False,
input_name='data', output_name='output',
same_padding_asymmetry_mode='TOP_LEFT_HEAVY')
x = np.random.rand(*input_dim)
input = {'data': x}
expected = {'output': np.random.rand(20, 8, 8)}
self._test_model(
builder.spec, input, expected, validate_shapes_only=True)
def test_deconv_valid_padding(self):
input_dim = (10, 15, 15)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(input_features,
output_features)
W = np.random.rand(3, 3, 10, 20)
builder.add_convolution(name='deconv', kernel_channels=10,
output_channels=20,
height=3, width=3, stride_height=2,
stride_width=2,
border_mode='valid', groups=1,
W=W, b=None, has_bias=False,
is_deconv=True,
input_name='data', output_name='output',
padding_top=2, padding_bottom=3,
padding_left=2, padding_right=3)
x = np.random.rand(*input_dim)
input = {'data': x}
expected = {'output': np.random.rand(20, 26, 26)}
self._test_model(
builder.spec, input, expected, validate_shapes_only=True)
def test_deconv_non_unit_groups(self):
input_dim = (16, 15, 15)
input_features = [('data', datatypes.Array(*input_dim))]
output_features = [('output', None)]
builder = neural_network.NeuralNetworkBuilder(
input_features, output_features)
W = np.random.rand(3, 3, 16, 5)
builder.add_convolution(name='deconv', kernel_channels=16,
output_channels=20,
height=3, width=3, stride_height=2,
stride_width=2,
border_mode='valid', groups=4,
W=W, b=None, has_bias=False,
is_deconv=True,
input_name='data', output_name='output',
padding_top=2, padding_bottom=3,
padding_left=2, padding_right=3)
x = | np.random.rand(*input_dim) | numpy.random.rand |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
comparing
Auxiliar methods to compare approximate values.
"""
import numpy as np
def approx_equal(a, b, tolerance=0.00001):
"""Check if a and b can be considered approximately equal.
Args:
a: A float or int number.
b: A float or int number.
tolerance: Percentage of discrepancy allowed to be considered equal.
Returns:
True (a == b) or False (a != b)
"""
RV = False
if a == b:
RV = True
elif isinstance(a, str) and isinstance(b, str):
RV = a == b
elif (not a) and (not b):
RV = True
elif | np.isnan(a) | numpy.isnan |
import pickle
from hashlib import md5
from shutil import which
from textwrap import dedent
import geopandas
import numpy as np
import pandas as pd
import pytest
from shapely import wkt
from shapely.geometry import Point
import swn
import swn.modflow
from swn.file import gdf_to_shapefile
from swn.spatial import force_2d, interp_2d_to_3d, wkt_to_geoseries
if __name__ != "__main__":
from .conftest import datadir, matplotlib, plt
else:
from conftest import datadir, matplotlib, plt
try:
import flopy
except ImportError:
pytest.skip("skipping tests that require flopy", allow_module_level=True)
mfnwt_exe = which("mfnwt")
mf2005_exe = which("mf2005")
requires_mfnwt = pytest.mark.skipif(not mfnwt_exe, reason="requires mfnwt")
requires_mf2005 = pytest.mark.skipif(not mf2005_exe, reason="requires mf2005")
if mfnwt_exe is None:
mfnwt_exe = "mfnwt"
if mf2005_exe is None:
mf2005_exe = "mf2005"
# same valid network used in test_basic
n3d_lines = wkt_to_geoseries([
"LINESTRING Z (60 100 14, 60 80 12)",
"LINESTRING Z (40 130 15, 60 100 14)",
"LINESTRING Z (70 130 15, 60 100 14)",
])
def get_basic_swn(has_z: bool = True, has_diversions: bool = False):
if has_z:
n = swn.SurfaceWaterNetwork.from_lines(n3d_lines)
else:
n = swn.SurfaceWaterNetwork.from_lines(force_2d(n3d_lines))
if has_diversions:
diversions = geopandas.GeoDataFrame(geometry=[
Point(58, 97), Point(62, 97), Point(61, 89), Point(59, 89)])
n.set_diversions(diversions=diversions)
return n
def get_basic_modflow(
outdir=".", with_top: bool = False, nper: int = 1,
hk=1e-2, rech=1e-4):
"""Returns a basic Flopy MODFLOW model"""
if with_top:
top = np.array([
[16.0, 15.0],
[15.0, 15.0],
[14.0, 14.0],
])
else:
top = 15.0
m = flopy.modflow.Modflow(
version="mf2005", exe_name=mf2005_exe, model_ws=outdir)
flopy.modflow.ModflowDis(
m, nlay=1, nrow=3, ncol=2, nper=nper,
delr=20.0, delc=20.0, top=top, botm=10.0,
xul=30.0, yul=130.0)
_ = flopy.modflow.ModflowBas(m, strt=top, stoper=5.0)
_ = flopy.modflow.ModflowSip(m)
_ = flopy.modflow.ModflowLpf(m, ipakcb=52, laytyp=0, hk=hk)
_ = flopy.modflow.ModflowRch(m, ipakcb=52, rech=rech)
_ = flopy.modflow.ModflowOc(
m, stress_period_data={
(0, 0): ["print head", "save head", "save budget"]})
return m
def read_head(hed_fname, reaches=None):
"""Reads MODFLOW Head file
If reaches is not None, it is modified inplace to add a "head" column
Returns numpy array
"""
with flopy.utils.HeadFile(hed_fname) as b:
data = b.get_data()
if reaches is not None:
reaches["head"] = data[reaches["k"], reaches["i"], reaches["j"]]
return data
def read_budget(bud_fname, text, reaches=None, colname=None):
"""Reads MODFLOW cell-by-cell file
If reaches is not None, it is modified inplace to add data in "colname"
Returns numpy array
"""
with flopy.utils.CellBudgetFile(bud_fname) as b:
res = b.get_data(text=text)
if len(res) != 1:
from warnings import warn
warn(f"get_data(text={text!r}) returned more than one array")
data = res[0]
if reaches is not None:
if isinstance(data, np.recarray) and "q" in data.dtype.names:
reaches[colname] = data["q"]
else:
reaches[colname] = data[reaches["k"], reaches["i"], reaches["j"]]
return data
def read_sfl(sfl_fname, reaches=None):
"""Reads MODFLOW stream flow listing ASCII file
If reaches is not None, it is modified inplace to add new columns
Returns DataFrame of stream flow listing file
"""
sfl = flopy.utils.SfrFile(sfl_fname).get_dataframe()
# this index modification is only valid for steady models
if sfl.index.name is None:
sfl.index += 1
sfl.index.name = "reachID"
if "col16" in sfl.columns:
sfl.rename(columns={"col16": "gradient"}, inplace=True)
dont_copy = ["layer", "row", "column", "segment", "reach", "k", "i", "j"]
if reaches is not None:
if not (reaches.index == sfl.index).all():
raise IndexError("reaches.index is different")
for cn in sfl.columns:
if cn == "kstpkper": # split tuple into two columns
reaches["kstp"] = sfl[cn].apply(lambda x: x[0])
reaches["kper"] = sfl[cn].apply(lambda x: x[1])
elif cn not in dont_copy:
reaches[cn] = sfl[cn]
return sfl
def test_init_errors():
with pytest.raises(ValueError, match="expected 'logger' to be Logger"):
swn.SwnModflow(object())
def test_from_swn_flopy_errors():
n = get_basic_swn()
m = flopy.modflow.Modflow(version="mf2005", exe_name=mf2005_exe)
_ = flopy.modflow.ModflowDis(
m, nlay=1, nrow=3, ncol=2, nper=4, delr=20.0, delc=20.0)
with pytest.raises(
ValueError,
match="swn must be a SurfaceWaterNetwork object"):
swn.SwnModflow.from_swn_flopy(object(), m)
_ = flopy.modflow.ModflowBas(m)
m.modelgrid.set_coord_info(epsg=2193)
# n.segments.crs = {"init": "epsg:27200"}
# with pytest.raises(
# ValueError,
# match="CRS for segments and modelgrid are different"):
# nm = swn.SwnModflow.from_swn_flopy(n, m)
n.segments.crs = None
with pytest.raises(
ValueError,
match="modelgrid extent does not cover segments extent"):
swn.SwnModflow.from_swn_flopy(n, m)
m.modelgrid.set_coord_info(xoff=30.0, yoff=70.0)
with pytest.raises(ValueError, match="ibound_action must be one of"):
swn.SwnModflow.from_swn_flopy(n, m, ibound_action="foo")
@pytest.mark.parametrize("has_diversions", [False, True], ids=["nodiv", "div"])
def test_new_segment_data(has_diversions):
n = get_basic_swn(has_diversions=has_diversions)
m = get_basic_modflow()
nm = swn.SwnModflow.from_swn_flopy(n, m)
assert nm.segment_data is None
assert nm.segment_data_ts is None
nm.new_segment_data()
assert nm.segment_data_ts == {}
assert (nm.segment_data.icalc == 0).all()
if has_diversions:
pd.testing.assert_index_equal(
nm.segment_data.index,
pd.Int64Index([1, 2, 3, 4, 5, 6, 7], name="nseg"))
assert list(nm.segment_data.segnum) == [1, 2, 0, -1, -1, -1, -1]
assert list(nm.segment_data.divid) == [0, 0, 0, 0, 1, 2, 3]
assert list(nm.segment_data.outseg) == [3, 3, 0, 0, 0, 0, 0]
assert list(nm.segment_data.iupseg) == [0, 0, 0, 1, 2, 3, 3]
else:
pd.testing.assert_index_equal(
nm.segment_data.index,
pd.Int64Index([1, 2, 3], name="nseg"))
assert list(nm.segment_data.segnum) == [1, 2, 0]
assert "divid" not in nm.segment_data.columns
assert list(nm.segment_data.outseg) == [3, 3, 0]
assert list(nm.segment_data.iupseg) == [0, 0, 0]
@requires_mf2005
def test_n3d_defaults(tmp_path):
n = get_basic_swn()
m = get_basic_modflow(tmp_path)
nm = swn.SwnModflow.from_swn_flopy(n, m)
nm.default_segment_data()
nm.set_sfr_obj(ipakcb=52, istcb2=-53)
assert m.sfr.ipakcb == 52
assert m.sfr.istcb2 == -53
# Data set 1c
assert abs(m.sfr.nstrm) == 7
assert m.sfr.nss == 3
assert m.sfr.const == 86400.0
# Data set 2
# Base-0
assert list(m.sfr.reach_data.node) == [0, 1, 3, 1, 3, 3, 5]
assert list(m.sfr.reach_data.k) == [0, 0, 0, 0, 0, 0, 0]
assert list(m.sfr.reach_data.i) == [0, 0, 1, 0, 1, 1, 2]
assert list(m.sfr.reach_data.j) == [0, 1, 1, 1, 1, 1, 1]
# Base-1
assert list(m.sfr.reach_data.reachID) == [1, 2, 3, 4, 5, 6, 7]
assert list(m.sfr.reach_data.iseg) == [1, 1, 1, 2, 2, 3, 3]
assert list(m.sfr.reach_data.ireach) == [1, 2, 3, 1, 2, 1, 2]
np.testing.assert_array_almost_equal(
m.sfr.reach_data.rchlen,
[18.027756, 6.009252, 12.018504, 21.081851, 10.540926, 10.0, 10.0])
np.testing.assert_array_almost_equal(
m.sfr.reach_data.strtop,
[14.75, 14.416667, 14.16666667, 14.66666667, 14.16666667, 13.5, 12.5])
np.testing.assert_array_almost_equal(
m.sfr.reach_data.slope,
[0.027735, 0.027735, 0.027735, 0.031622775, 0.031622775, 0.1, 0.1])
np.testing.assert_array_equal(m.sfr.reach_data.strthick, [1.0] * 7)
np.testing.assert_array_equal(m.sfr.reach_data.strhc1, [1.0] * 7)
# Data set 6
assert len(m.sfr.segment_data) == 1
sd = m.sfr.segment_data[0]
| np.testing.assert_array_equal(sd.nseg, [1, 2, 3]) | numpy.testing.assert_array_equal |
#!/usr/bin/env python
"""
History:
2002-07-09 ROwen Converted to Python from the TCC's cnv_ZPMFK42J 4-1.
2004-05-18 ROwen Stopped importing math; it wasn't used.
2007-04-24 ROwen Converted from Numeric to numpy.
"""
__all__ = ["icrsFromFixedFK4"]
import numpy
import opscore.RO.PhysConst
import opscore.RO.MathUtil
from opscore.RO.Astro import llv, Tm
# Constants
_MatPP = numpy.array((
(+0.999925678186902E+00, -0.111820596422470E-01, -0.485794655896000E-02),
(+0.111820595717660E-01, +0.999937478448132E+00, -0.271764411850000E-04),
(+0.485794672118600E-02, -0.271474264980000E-04, +0.999988199738770E+00),
))
_MatVP = numpy.array((
(-0.262600477903207E-10, -0.115370204968080E-07, +0.211489087156010E-07),
(+0.115345713338304E-07, -0.128997445928004E-09, -0.413922822287973E-09),
(-0.211432713109975E-07, +0.594337564639027E-09, +0.102737391643701E-09),
))
def icrsFromFixedFK4(fk4P, fk4Date):
"""
Converts mean catalog fk4 coordinates to ICRS for a fixed star.
Uses the approximation that ICRS = FK5 J2000.
Inputs:
- fk4Date TDB date of fk4 coordinates (Besselian epoch)
note: TDT will always do and UTC is usually adequate
- fk4P(3) mean catalog fk4 cartesian position (au)
Returns:
- icrsP(3) ICRS cartesian position (au), a numpy.array
Error Conditions:
none
Warnings:
The FK4 date is in Besselian years.
The star is assumed fixed on the celestial sphere. That is a bit
different than assuming it has zero proper motion because
FK4 system has slight ficticious proper motion.
The FK4 system refers to a specific set of precession constants;
not all Besselian-epoch data was precessed using these constants
(especially data for epochs before B1950).
References:
P.T. Wallace's routine FK45Z
"""
# compute new precession constants
# note: ETrms and PreBn both want Besselian date
eTerms = llv.etrms (fk4Date)
precMat = llv.prebn (fk4Date, 1950.0)
# subtract e-terms from position. As a minor approximation,
# we don't bother to subtract variation in e-terms from proper motion.
magP = opscore.RO.MathUtil.vecMag(fk4P)
meanFK4P = fk4P - (eTerms * magP)
# precess position to B1950, assuming zero fk4 pm
# (we'll correct for the fictious fk4 pm later)
b1950P = numpy.dot(precMat, meanFK4P)
# convert position to ICRS (actually FK5 J2000)
# but still containing fk4 fictitious pm;
# compute fictitious pm.
tempP = | numpy.dot(_MatPP, b1950P) | numpy.dot |
import sys
import unittest
import copy
import numpy as np
from scipy.linalg import block_diag
import pyinduct as pi
import pyinduct.hyperbolic.feedforward as hff
import pyinduct.parabolic as parabolic
import pyinduct.simulation as sim
from pyinduct.tests import show_plots
import pyqtgraph as pg
class SimpleInput(sim.SimulationInput):
"""
the simplest input we can imagine
"""
def __init__(self):
super().__init__("SimpleInput")
def _calc_output(self, **kwargs):
return 0
class MonotonousInput(sim.SimulationInput):
"""
an input that ramps up
"""
def __init__(self):
super().__init__("MonotonousInput")
def _calc_output(self, **kwargs):
t = kwargs["time"]
extra_data = np.sin(t)
if np.isclose(t % 2, 0):
extra_data = np.nan
return dict(output=kwargs["time"], extra_data=extra_data)
class CorrectInput(sim.SimulationInput):
"""
a diligent input
"""
def __init__(self, output, limits=(0, 1), der_order=0):
super().__init__(self)
self.out = np.ones(der_order + 1) * output
self.t_min, self.t_max = limits
def _calc_output(self, **kwargs):
if "time" not in kwargs:
raise ValueError("mandatory key not found!")
if "weights" not in kwargs:
raise ValueError("mandatory key not found!")
if "weight_lbl" not in kwargs:
raise ValueError("mandatory key not found!")
return dict(output=self.out)
class AlternatingInput(sim.SimulationInput):
"""
a simple alternating input, composed of smooth transitions
"""
def _calc_output(self, **kwargs):
t = kwargs["time"] % 2
if t < 1:
res = self.tr_up(t)
else:
res = self.tr_down(t)
return dict(output=res - .5)
def __init__(self):
super().__init__(self)
self.tr_up = pi.SmoothTransition(states=(0, 1),
interval=(0, 1),
method="poly")
self.tr_down = pi.SmoothTransition(states=(1, 0),
interval=(1, 2),
method="poly")
class SimulationInputTest(unittest.TestCase):
def setUp(self):
pass
def test_abstract_funcs(self):
# raise type error since abstract method is not implemented
self.assertRaises(TypeError, sim.SimulationInput)
# method implemented, should work
u = SimpleInput()
def test_call_arguments(self):
a = np.eye(2, 2)
b = np.array([[0], [1]])
u = CorrectInput(output=1, limits=(0, 1))
ic = | np.zeros((2, 1)) | numpy.zeros |
# -*- coding: utf-8 -*-
"""Slope and trend utilities."""
__all__ = [
"_slope",
"_fit_trend",
]
__author__ = ["<NAME>"]
import numpy as np
from sklearn.utils import check_array
def _fit_trend(x, order=0):
"""Fit linear regression with polynomial terms of given order.
x : array_like, shape=[n_samples, n_obs]
Time series data, each sample is fitted separately
order : int
The polynomial order of the trend, zero is constant (mean), one is
linear trend, two is quadratic trend, and so on.
Returns
-------
coefs : ndarray, shape=[n_samples, order + 1]
Fitted coefficients of polynomial order for each sample, one column
means order zero, two columns mean order 1
(linear), three columns mean order 2 (quadratic), etc
See Also
--------
add_trend
remove_trend
"""
x = check_array(x)
if order == 0:
coefs = | np.mean(x, axis=1) | numpy.mean |
"""
This module implements classes representing gmsh primitives
"""
import numpy as np
class Point:
"""
Point
"""
def __init__( self, coordinates, grid_size = None ):
self.id = self._next_id
Point._next_id += 1
self.coordinates = coordinates
self.grid_size = grid_size
def __str__( self ):
grid_size = ''
if self.grid_size is not None:
grid_size = ', {}'.format( self.grid_size )
return 'Point( {id} ) = {{ {x}, {y}, {z} {grid_size} }};'.format( id = self.id,
x = self.coordinates[ 0 ],
y = self.coordinates[ 1 ],
z = self.coordinates[ 2 ],
grid_size = grid_size )
_next_id = 1
class Curve:
"""
Base class for all curves
"""
def __init__( self ):
self.id = self._next_id
Curve._next_id += 1
_next_id = 1
class Line(Curve):
"""
Lines
"""
def __init__(self, begin, end, transfinite = None, progression = 1):
super( Line, self ).__init__()
self.begin = begin
self.end = end
self.transfinite = transfinite
self.progression = progression
def __str__(self):
transfinite_statement = ''
if self.transfinite is not None:
transfinite_statement = 'Transfinite Line {{ {id} }} = {n} Using Progression {p};'.format(id = self.id,
n = self.transfinite,
p = self.progression)
return 'Line( {id} ) = {{ {begin}, {end} }}; {transfinite}'.format( id = self.id,
begin = self.begin.id,
end = self.end.id,
transfinite = transfinite_statement )
def progression_from_width(self, initial_width):
"""
Sets progression based on a specified initial width
:param initial_width: width of first (smallest) element
:return: None
"""
if self.transfinite is None:
raise ValueError('Cannot set progression on non-transfinite line')
if self.transfinite == 2: # if transfinite is 2, there is no progression and so set a dummy value
self.progression = 1
l = np.linalg.norm(np.array(self.begin.coordinates) - np.array(self.end.coordinates)) # line length
p = [0] * (self.transfinite + 1)
p[0] = 1
p[-2] = -l / initial_width
p[-1] = -l / initial_width - 1.0
r = | np.roots(p) | numpy.roots |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
search.py
This module holds functions used to find and record the diagonals in the
thresholded matrix, T. These functions prepare the diagonals found to for
transformation and assembling later.
The module contains the following functions:
* find_complete_list
Finds all smaller diagonals (and the associated pairs of repeats)
that are contained in pair_list, which is composed of larger diagonals
found in find_initial_repeats.
* __find_add_rows
Finds pairs of repeated structures, represented as diagonals of a
certain length, k, that neither start nor end at the same time steps
as previously found pairs of repeated structures of the same length.
* find_all_repeats
Finds all the diagonals present in thresh_mat. This function is nearly
identical to find_initial_repeats except for two crucial differences.
First, we do not remove diagonals after we find them. Second, there is
no smallest bandwidth size as we are looking for all diagonals.
* find_complete_list_anno_only
Finds annotations for all pairs of repeats found in find_all_repeats.
This list contains all the pairs of repeated structures with their
starting/ending indices and lengths.
"""
import numpy as np
from scipy import signal
from .utilities import add_annotations
def find_complete_list(pair_list, song_length):
"""
Finds all smaller diagonals (and the associated pairs of repeats) that are
contained in pair_list, which is composed of larger diagonals found in
find_initial_repeats.
Args
----
pair_list : np.ndarray
List of pairs of repeats found in earlier steps
(bandwidths MUST be in ascending order). If you have
run find_initial_repeats before this script,
then pair_list will be ordered correctly.
song_length : int
Song length, which is the number of audio shingles.
Returns
-------
lst_out : np.ndarray
List of pairs of repeats with smaller repeats added.
"""
# Find the list of unique repeat lengths
bw_found = np.unique(pair_list[:, 4])
bw_num = np.size(bw_found, axis=0)
# If the longest bandwidth is the length of the song, then remove that row
if song_length == bw_found[-1]:
pair_list = np.delete(pair_list, -1, 0)
bw_found = np.delete(bw_found, -1, 0)
bw_num = (bw_num - 1)
# Initialize variables
p = np.size(pair_list, axis=0)
add_mat = np.zeros((1, 5)).astype(int)
# Step 1: For each found bandwidth, search upwards (i.e. search the larger
# bandwidths) and add all found diagonals to the variable add_mat
for j in range(0, bw_num - 1):
band_width = bw_found[j]
# Isolate pairs of repeats that are length bandwidth
# Return the minimum of the array
bsnds = np.amin((pair_list[:, 4] == band_width).nonzero())
bends = (pair_list[:, 4] > band_width).nonzero()
# Convert bends into an array
bend = np.array(bends)
if bend.size > 0:
bend = np.amin(bend)
else:
bend = p
# Part A1: Isolate all starting time steps of the repeats of length
# bandwidth
start_I = pair_list[bsnds:bend, 0]
start_J = pair_list[bsnds:bend, 2]
all_vec_snds = np.concatenate((start_I, start_J), axis=None)
int_snds = np.unique(all_vec_snds)
# Part A2: Isolate all ending time steps of the repeats of length
# bandwidth
end_I = pair_list[bsnds:bend, 1] # Similar to definition for start_I
end_J = pair_list[bsnds:bend, 3] # Similar to definition for start_J
all_vec_ends = np.concatenate((end_I, end_J), axis=None)
int_ends = np.unique(all_vec_ends)
# Part B: Use the current diagonal information to search for diagonals
# of length BW contained in larger diagonals and thus were not
# detected because they were contained in larger diagonals that
# were removed by our method of eliminating diagonals in
# descending order by size
add_mrows = __find_add_rows(pair_list, int_snds, band_width)
# Check if any of the arrays are empty
# Add the new pairs of repeats to the temporary list add_mat
if add_mrows.size != 0:
add_mat = np.vstack((add_mat, add_mrows))
# Remove the empty row
if add_mat.size != 0:
add_mat = np.delete(add_mat, 0, 0)
# Step 2: Combine pair_list and new_mat. Make sure that you don't have any
# double rows in add_mat. Then find the new list of found
# bandwidths in combine_mat.
combine_mat = np.vstack((pair_list, add_mat))
combine_mat = np.unique(combine_mat, axis=0)
# Return the indices that would sort combine_mat's fourth column
combine_inds = np.argsort(combine_mat[:, 4])
combine_mat = combine_mat[combine_inds, :]
c = np.size(combine_mat, axis=0)
# Again, find the list of unique repeat lengths
new_bw_found = np.unique(combine_mat[:, 4])
new_bw_num = np.size(new_bw_found, axis=0)
full_lst = []
# Step 3: Loop over the new list of found bandwidths to add the annotation
# markers to each found pair of repeats
for j in range(1, new_bw_num + 1):
new_bw = new_bw_found[j - 1]
# Isolate pairs of repeats in combine_mat that are length bandwidth
# Return the minimum of the array
new_bsnds = np.amin((combine_mat[:, 4] == new_bw).nonzero())
new_bends = (combine_mat[:, 4] > new_bw).nonzero()
# Convert new_bends into an array
new_bend = np.array(new_bends)
if new_bend.size > 0:
new_bend = np.amin(new_bend)
else:
new_bend = c
band_width_mat = np.array((combine_mat[new_bsnds:new_bend, ]))
length_band_width_mat = np.size(band_width_mat, axis=0)
temp_anno_lst = np.concatenate((band_width_mat,
(np.zeros((length_band_width_mat, 1))))
,axis=1).astype(int)
# Part C: Get annotation markers for this bandwidth
temp_anno_lst = add_annotations(temp_anno_lst, song_length)
full_lst.append(temp_anno_lst)
final_lst = np.vstack(full_lst)
tem_final_lst = np.lexsort([final_lst[:, 2], final_lst[:, 0],
final_lst[:, 5], final_lst[:, 4]])
final_lst = final_lst[tem_final_lst, :]
lst_out = final_lst
return lst_out
def __find_add_rows(lst_no_anno, check_inds, k):
"""
Finds pairs of repeated structures, represented as diagonals of a certain
length, k, that that start at the same time step, or end at the same time
step, or neither start nor end at the same time step as previously found
pairs of repeated structures of the same length.
Args
----
lst_no_anno : np.ndarray
List of pairs of repeats.
check_inds : np.ndarray
List of ending indices for repeats of length k that we use to
check lst_no_anno for more repeats of length k.
k : int
Length of repeats that we are looking for.
Returns
-------
add_rows : np.ndarray
List of newly found pairs of repeats of length K that are
contained in larger repeats in lst_no_anno.
"""
# Initialize list of pairs
L = lst_no_anno
add_rows = np.empty(0)
# Logically, which pair of repeats has a length greater than k
search_inds = (L[:, 4] > k)
# If there are no pairs of repeats that have a length greater than k
if sum(search_inds) == 0:
add_rows = np.full(1, False)
return add_rows
# Multiply the starting index of all repeats "I" by search_inds
SI = np.multiply(L[:, 0], search_inds)
# Multiply the starting index of all repeats "J" by search_inds
SJ = np.multiply(L[:, 2], search_inds)
# Multiply the ending index of all repeats "I" by search_inds
EI = np.multiply(L[:, 1], search_inds)
# Multiply the ending index of all repeats "J" by search_inds
EJ = np.multiply(L[:, 3], search_inds)
# Loop over check_inds
for i in range(check_inds.size):
ci = check_inds[i]
# Left Check: Check for CI on the left side of the pairs
lnds = ((SI <= ci) & (EI >= (ci + k - 1)))
# Check that SI <= CI and that EI >= (CI + K - 1) indicating that there
# is a repeat of length k with starting index CI contained in a larger
# repeat which is the left repeat of a pair
if lnds.sum(axis=0) > 0:
# Find the 2nd entry of the row (lnds) whose starting index of the
# repeat "I" equals CI
SJ_li = L[lnds, 2]
EJ_li = L[lnds, 3]
l_num = SJ_li.shape[0]
# Left side of left pair
l_left_k = (ci * np.ones((1, l_num))) - L[lnds, 0]
l_add_left = np.vstack((L[lnds, 0] * np.ones((1, l_num)),
(ci - 1 * np.ones((1, l_num))),
SJ_li * np.ones((1, l_num)),
(SJ_li + l_left_k - np.ones((1, l_num))),
l_left_k))
l_add_left = np.transpose(l_add_left)
# Middle of left pair
l_add_mid = np.vstack(((ci * np.ones((1, l_num))),
(ci+k-1) * np.ones((1, l_num)),
SJ_li + l_left_k, SJ_li +
l_left_k + (k-1) * np.ones((1, l_num)),
k * np.ones((1, l_num))))
l_add_mid = np.transpose(l_add_mid)
# Right side of left pair
l_right_k = np.concatenate((L[lnds, 1] - ((ci + k) - 1) *
np.ones((1, l_num))), axis=None)
l_add_right = np.vstack((((ci + k) * np.ones((1, l_num))),
L[lnds, 1], (EJ_li - l_right_k +
np.ones((1, l_num))), EJ_li,
l_right_k))
l_add_right = np.transpose(l_add_right)
# Add the rows found
if add_rows.size == 0:
add_rows = np.vstack((l_add_left, l_add_mid,
l_add_right)).astype(int)
else:
add_rows = np.vstack((add_rows, l_add_left,
l_add_mid, l_add_right)).astype(int)
# Right Check: Check for CI on the right side of the pairs
rnds = ((SJ <= ci) & (EJ >= (ci + k - 1)))
# Check that SI <= CI and that EI >= (CI + K - 1) indicating that there
# is a repeat of length K with starting index CI contained in a larger
# repeat which is the right repeat of a pair
if rnds.sum(axis=0) > 0:
SI_ri = L[rnds, 0]
EI_ri = L[rnds, 1]
r_num = SI_ri.shape[0]
# Left side of right pair
r_left_k = ci*np.ones((1, r_num)) - L[rnds, 2]
r_add_left = np.vstack((SI_ri, (SI_ri + r_left_k -
np.ones((1, r_num))), L[rnds, 2],
(ci - 1) * np.ones((1, r_num)),
r_left_k))
r_add_left = np.transpose(r_add_left)
# Middle of right pair
r_add_mid = np.vstack(((SI_ri + r_left_k), (SI_ri + r_left_k
+ (k - 1) * np.ones((1, r_num))),
ci * np.ones((1, r_num)),
(ci + k - 1) * np.ones((1, r_num)),
k * np.ones((1, r_num))))
r_add_mid = np.transpose(r_add_mid)
# Right side of right pair
r_right_k = L[rnds, 3] - ((ci + k) - 1) * | np.ones((1, r_num)) | numpy.ones |
from __future__ import division, print_function, absolute_import
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.linalg import eigsh, inv
from numpy.linalg import norm, eig
from scipy.linalg import eigh
from itertools import product
from typing import Union
class framework(object):
"""Base class for a framework
A framework at a minimum needs an array of coordinates for vertices/sites and
a list of edges/bonds where each element represents an bond. Additional
information such as boundary conditions, additional constriants
such pinning specific vertices, spring constants, etc. are optional.
For the complete list of the variables, see the following.
Args:
coordinates (Union[np.array, list]): Vertex/site coordinates. For
``N`` sites in ``d`` dimensions, the shape is ``(N,d)``.
bonds (Union[np.array, list]): Edge list. For ``M`` bonds, its
shape is ``(M,2)``.
basis (Union[np.array, list], optional): List of basis/repeat/lattice
vectors, Default: ``None``.If ``None`` or array of zero vectors,
the system is assumed to be finite. Defaults to None.
pins (Union[np.array, list], optional): array/list of int,
List of sites to be immobilized. Defaults to None.
k (Union[np.array, float], optional): Spring constant/stiffness.
If an array is supplied, the shape should be ``(M,2)``.
Defaults to 1.0.
restLengths (Union[np.array, list, float], optional): Equilibrium
or rest length of bonds, used for systems with pre-stress.
Defaults to None.
varcell (Union[np.array, list], optional): (d*d,) array of booleans/int
A list of basis vector components allowed to change (1/True) or
fixed (0/False). Example: ``[0,1,0,0]`` or ``[False, True, False, False]``
both mean that in two dimensions, only second element of first
basis vector is allowed to change.. Defaults to None.
power (int, optional): Power of potential energy.
power=2 is Hookean, power=5/2 is Hertzian. For
non-Hookean potentials, make sure to supply restLengths non-equal to the
current length of the bonds, otherwise the calculations will be wrong.
Defaults to 2.
Raises:
ValueError: The bond list should have two columns corresponding to
two ends of bonds.
Examples:
```python
>>> import numpy as np
>>> import rigidpy as rp
>>> coordinates = np.array([[-1,0], [1,0], [0,1]])
>>> bonds = np.array([[0,1],[1,2],[0,2]])
>>> basis = [[0,0],[0,0]]
>>> pins = [0]
>>> F = rp.Framework(coordinates, bonds, basis=basis, pins=pins)
>>> print ("rigidity matrix:\n",F.RigidityMatrix())
>>> eigvals, eigvecs = F.eigenspace(eigvals=(0,3))
>>> print("vibrational eigenvalues:\n",eigvals)
"""
def __init__(
self,
coordinates: Union[np.array, list],
bonds: Union[np.array, list],
basis: Union[np.array, list] = None,
pins: Union[np.array, list] = None,
k: Union[np.array, float] = 1.0,
restLengths: Union[np.array, list, float] = None,
# mass=1,
varcell: Union[np.array, list] = None,
power: int = 2,
):
# Number of sites and spatial dimensions
self.coordinates = np.array(coordinates)
self.N, self.dim = self.coordinates.shape
# Number of bonds and bond list
self.bonds = np.array(bonds)
self.NB, self.C = self.bonds.shape
# Basis vectors and their norms
if basis is None:
basis = np.zeros(shape=(self.dim, self.dim))
self.boundary = "free"
else:
self.basis = basis
self.boundary = "periodic"
self.nbasis = nbasis = len(basis) # number of basis vectors
self.basisNorm = np.array([norm(base) for base in basis])
self.cutoff = 0.5 * np.amin(self.basisNorm)
if pins is None:
self.pins = []
else:
self.pins = pins
# update the boundary conditions
if self.boundary == "periodic":
self.boundary = "periodic+pinned"
else:
self.boundary = "anchored"
# index of pinned and non-pinned sites in rigidity matrix
dim_idx = np.arange(0, self.dim)
if len(self.pins) != 0:
self.pins_idx = [pin * self.dim + dim_idx for pin in self.pins]
self.keepIdx = np.setdiff1d(np.arange(0, self.dim * self.N), self.pins_idx)
# whether cell can deform
self.varcell = varcell
# volume of the box/cell
if nbasis == 1:
# in case system is 1D
self.volume = self.basisNorm
else:
volume = np.abs(np.product(eig(basis)[0]))
if volume:
self.volume = volume
else:
self.volume = 1
# froce constant matrix
if isinstance(k, (int, float)):
self.K = np.diagflat(k * np.ones(self.NB))
else:
self.K = np.diagflat(k)
self.KS = csr_matrix(self.K) # sparse spring constants
# Cartesian product for periodic box
regionIndex = np.array(list(product([-1, 0, 1], repeat=nbasis)))
transVectors = np.einsum("ij,jk->ik", regionIndex, basis)
# Identify long bonds
if self.C not in [2, 3]:
raise ValueError("Second dimension should be 2 or 3.")
elif self.C == 2:
# vector from node i to node j if bond is (i,j)
dr = -np.diff(coordinates[bonds[:, 0:2]], axis=1).reshape(-1, self.dim)
# length of dr
lengths = norm(dr, axis=1)
# which bonds are long == cross the boundary
self.indexLong = indexLong = np.nonzero(lengths > self.cutoff)[0]
# two ends of long bonds
longBonds = bonds[indexLong]
# index of neiboring boxes for long bonds only
index = [
np.argmin(norm(item[0] - item[1] - transVectors, axis=1))
for item in coordinates[longBonds]
]
dr[indexLong] -= transVectors[index]
# negihbor is in which neighboring box
self.mn = regionIndex[index]
# correct vector from particle 1 to particle 2
self.dr = dr
else:
pass
# which bonds are long == cross the boundary
# indexLong = np.nonzero(lengths > self.cutoff)
# feature for future release
# Equilibrium or rest length of springs
if restLengths is None:
self.L0 = | norm(self.dr, axis=1) | numpy.linalg.norm |
import numpy as np
from utils.colors import generate_colors
from utils.format_image import format_image
def semantic2binary(mask):
return format_image((mask > 0).max(axis=2))
def single2multi(mask):
return np.stack((mask,) * 3, axis=-1)
def semantic2binary_list(mask):
"""Input RGB image"""
unsqueezed_mask = mask.reshape(-1, mask.shape[2])
masks_colors = np.unique(unsqueezed_mask, axis=0)
background_index = np.argwhere( | np.sum(masks_colors, axis=1) | numpy.sum |
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# Deep Recurrent Reinforcement Learning: 1 capa LSTM y 4 capas Dense, Funcion de activacion tanh, 12 episodes, 50 iteraciones
drnnLSTMtanhMakespan0=[799, 798, 799, 799, 805, 806, 799, 805, 805, 800, 798, 798]
drnnLSTMtanhMakespan1=[800, 798, 796, 800, 796, 794, 795, 798, 800, 798, 805, 798]
drnnLSTMtanhMakespan2=[796, 800, 798, 804, 800, 798, 798, 798, 800, 800, 802, 797]
drnnLSTMtanhMakespan3=[805, 800, 800, 803, 794, 802, 800, 798, 799, 804, 799, 806]
drnnLSTMtanhMakespan4=[796, 798, 795, 798, 796, 799, 800, 796, 796, 798, 806, 800]
drnnLSTMtanhMakespan5=[798, 798, 799, 800, 800, 808, 798, 798, 801, 796, 799, 798]
drnnLSTMtanhMakespan6=[800, 796, 805, 798, 798, 796, 799, 800, 803, 800, 798, 800]
drnnLSTMtanhMakespan7=[799, 805, 802, 805, 800, 799, 800, 799, 805, 800, 794, 796]
drnnLSTMtanhMakespan8=[799, 798, 800, 798, 798, 800, 800, 800, 804, 799, 800, 804]
drnnLSTMtanhMakespan9=[795, 800, 795, 796, 798, 796, 797, 800, 797, 798, 796, 795]
drnnLSTMtanhMakespan10=[804, 799, 805, 798, 798, 798, 805, 800, 796, 804, 796, 799]
drnnLSTMtanhMakespan11=[795, 803, 805, 798, 795, 801, 798, 798, 804, 803, 799, 804]
drnnLSTMtanhMakespan12=[798, 798, 799, 800, 798, 798, 799, 799, 801, 796, 799, 798]
drnnLSTMtanhMakespan13=[798, 798, 799, 797, 796, 796, 800, 797, 805, 800, 800, 794]
drnnLSTMtanhMakespan14=[800, 798, 798, 796, 800, 800, 798, 798, 802, 798, 802, 798]
drnnLSTMtanhMakespan15=[796, 796, 800, 801, 800, 800, 796, 794, 796, 800, 796, 798]
drnnLSTMtanhMakespan16=[798, 798, 795, 797, 795, 799, 800, 796, 795, 796, 800, 800]
drnnLSTMtanhMakespan17=[794, 795, 800, 798, 795, 796, 798, 796, 795, 794, 798, 796]
drnnLSTMtanhMakespan18=[797, 795, 794, 794, 800, 796, 796, 795, 798, 795, 798, 794]
drnnLSTMtanhMakespan19=[797, 795, 795, 796, 798, 799, 795, 799, 795, 794, 795, 795]
drnnLSTMtanhMakespan20=[796, 794, 798, 797, 798, 799, 795, 795, 797, 795, 795, 792]
drnnLSTMtanhMakespan21=[797, 795, 797, 793, 794, 794, 800, 794, 798, 795, 797, 795]
drnnLSTMtanhMakespan22=[794, 800, 798, 795, 795, 796, 796, 799, 795, 794, 795, 795]
drnnLSTMtanhMakespan23=[795, 795, 794, 795, 794, 794, 797, 799, 796, 794, 794, 795]
drnnLSTMtanhMakespan24=[798, 795, 795, 795, 792, 794, 795, 794, 794, 795, 795, 795]
drnnLSTMtanhMakespan25=[794, 792, 794, 795, 795, 794, 794, 794, 794, 795, 794, 793]
drnnLSTMtanhMakespan26=[794, 794, 795, 796, 798, 795, 794, 794, 794, 794, 795, 794]
drnnLSTMtanhMakespan27=[795, 794, 795, 795, 795, 794, 794, 794, 794, 794, 795, 795]
drnnLSTMtanhMakespan28=[795, 794, 794, 795, 794, 795, 795, 795, 795, 794, 795, 794]
drnnLSTMtanhMakespan29=[792, 794, 795, 794, 794, 795, 794, 793, 795, 794, 795, 792]
drnnLSTMtanhMakespan30=[795, 794, 795, 795, 794, 794, 794, 795, 794, 794, 794, 794]
drnnLSTMtanhMakespan31=[794, 794, 795, 794, 795, 793, 795, 795, 795, 792, 794, 794]
drnnLSTMtanhMakespan32=[795, 795, 794, 793, 795, 795, 795, 795, 794, 794, 795, 794]
drnnLSTMtanhMakespan33=[793, 794, 795, 793, 792, 795, 794, 794, 794, 794, 794, 795]
drnnLSTMtanhMakespan34=[794, 795, 795, 794, 794, 794, 794, 793, 794, 794, 794, 794]
drnnLSTMtanhMakespan35=[794, 794, 797, 793, 792, 794, 793, 794, 795, 794, 795, 792]
drnnLSTMtanhMakespan36=[794, 794, 793, 794, 795, 797, 795, 795, 794, 795, 793, 794]
drnnLSTMtanhMakespan37=[795, 793, 795, 794, 795, 798, 795, 794, 795, 793, 795, 794]
drnnLSTMtanhMakespan38=[794, 795, 793, 795, 794, 794, 794, 794, 794, 794, 797, 795]
drnnLSTMtanhMakespan39=[794, 794, 795, 794, 795, 795, 794, 795, 794, 795, 798, 797]
drnnLSTMtanhMakespan40=[795, 795, 794, 795, 794, 795, 795, 794, 794, 794, 795, 795]
drnnLSTMtanhMakespan41=[794, 795, 792, 794, 794, 798, 795, 794, 794, 794, 793, 795]
drnnLSTMtanhMakespan42=[793, 795, 794, 793, 794, 794, 792, 794, 795, 794, 794, 793]
drnnLSTMtanhMakespan43=[793, 792, 793, 794, 794, 795, 792, 794, 795, 794, 795, 794]
drnnLSTMtanhMakespan44=[793, 794, 795, 795, 794, 794, 795, 798, 794, 792, 795, 794]
drnnLSTMtanhMakespan45=[795, 794, 794, 794, 794, 792, 794, 795, 794, 796, 795, 794]
drnnLSTMtanhMakespan46=[794, 793, 793, 795, 795, 794, 794, 794, 794, 796, 794, 794]
drnnLSTMtanhMakespan47=[794, 794, 795, 794, 794, 795, 792, 795, 794, 795, 795, 794]
drnnLSTMtanhMakespan48=[794, 795, 794, 794, 794, 792, 794, 795, 796, 794, 794, 795]
drnnLSTMtanhMakespan49=[794, 794, 794, 794, 794, 794, 792, 794, 793, 794, 795, 794]
drnnLSTMtanhRewards0=[-0.1759911894273128, -0.17580964970257765, -0.1759911894273128, -0.1759911894273128, -0.177078750549934, -0.17725973169122497, -0.1759911894273128, -0.177078750549934, -0.177078750549934, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765]
drnnLSTMtanhRewards1=[-0.17617264919621228, -0.17580964970257765, -0.17544633017412387, -0.17617264919621228, -0.17544633017412387, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.17580964970257765, -0.17580964970257765]
drnnLSTMtanhRewards2=[-0.17544633017412387, -0.17617264919621228, -0.17580964970257765, -0.1768976897689769, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17653532907770195, -0.17562802996914942]
drnnLSTMtanhRewards3=[-0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.17671654929577466, -0.17508269018743108, -0.17653532907770195, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.1768976897689769, -0.1759911894273128, -0.17725973169122497]
drnnLSTMtanhRewards4=[-0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765, -0.17544633017412387, -0.1759911894273128, -0.17617264919621228, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17725973169122497, -0.17617264919621228]
drnnLSTMtanhRewards5=[-0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17617264919621228, -0.17617264919621228, -0.1776214552648934, -0.17580964970257765, -0.17580964970257765, -0.1763540290620872, -0.17544633017412387, -0.1759911894273128, -0.17580964970257765]
drnnLSTMtanhRewards6=[-0.17617264919621228, -0.17544633017412387, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.1759911894273128, -0.17617264919621228, -0.17671654929577466, -0.17617264919621228, -0.17580964970257765, -0.17617264919621228]
drnnLSTMtanhRewards7=[-0.1759911894273128, -0.177078750549934, -0.17653532907770195, -0.177078750549934, -0.17617264919621228, -0.1759911894273128, -0.17617264919621228, -0.1759911894273128, -0.177078750549934, -0.17617264919621228, -0.17508269018743108, -0.17544633017412387]
drnnLSTMtanhRewards8=[-0.1759911894273128, -0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.1768976897689769, -0.1759911894273128, -0.17617264919621228, -0.1768976897689769]
drnnLSTMtanhRewards9=[-0.17526455026455026, -0.17617264919621228, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17544633017412387, -0.17562802996914942, -0.17617264919621228, -0.17562802996914942, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026]
drnnLSTMtanhRewards10=[-0.1768976897689769, -0.1759911894273128, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17617264919621228, -0.17544633017412387, -0.1768976897689769, -0.17544633017412387, -0.1759911894273128]
drnnLSTMtanhRewards11=[-0.17526455026455026, -0.17671654929577466, -0.177078750549934, -0.17580964970257765, -0.17526455026455026, -0.1763540290620872, -0.17580964970257765, -0.17580964970257765, -0.1768976897689769, -0.17671654929577466, -0.1759911894273128, -0.1768976897689769]
drnnLSTMtanhRewards12=[-0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.1759911894273128, -0.1763540290620872, -0.17544633017412387, -0.1759911894273128, -0.17580964970257765]
drnnLSTMtanhRewards13=[-0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17562802996914942, -0.17544633017412387, -0.17544633017412387, -0.17617264919621228, -0.17562802996914942, -0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.17508269018743108]
drnnLSTMtanhRewards14=[-0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17653532907770195, -0.17580964970257765, -0.17653532907770195, -0.17580964970257765]
drnnLSTMtanhRewards15=[-0.17544633017412387, -0.17544633017412387, -0.17617264919621228, -0.1763540290620872, -0.17617264919621228, -0.17617264919621228, -0.17544633017412387, -0.17508269018743108, -0.17544633017412387, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765]
drnnLSTMtanhRewards16=[-0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.1759911894273128, -0.17617264919621228, -0.17544633017412387, -0.17544633017412387, -0.17526455026455026, -0.17617264919621228, -0.17617264919621228]
drnnLSTMtanhRewards17=[-0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17544633017412387]
drnnLSTMtanhRewards18=[-0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17617264919621228, -0.17544633017412387, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108]
drnnLSTMtanhRewards19=[-0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.1759911894273128, -0.17526455026455026, -0.1759911894273128, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drnnLSTMtanhRewards20=[-0.17544633017412387, -0.17508269018743108, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.1759911894273128, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17471872931833224]
drnnLSTMtanhRewards21=[-0.17562802996914942, -0.17526455026455026, -0.17562802996914942, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17617264919621228, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026]
drnnLSTMtanhRewards22=[-0.17508269018743108, -0.17617264919621228, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17544633017412387, -0.1759911894273128, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drnnLSTMtanhRewards23=[-0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942, -0.1759911894273128, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026]
drnnLSTMtanhRewards24=[-0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026]
drnnLSTMtanhRewards25=[-0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221]
drnnLSTMtanhRewards26=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards27=[-0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drnnLSTMtanhRewards28=[-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards29=[-0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224]
drnnLSTMtanhRewards30=[-0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drnnLSTMtanhRewards31=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108]
drnnLSTMtanhRewards32=[-0.17526455026455026, -0.17526455026455026, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards33=[-0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026]
drnnLSTMtanhRewards34=[-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drnnLSTMtanhRewards35=[-0.17508269018743108, -0.17508269018743108, -0.17562802996914942, -0.17471872931833224, -0.1749007498897221, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224]
drnnLSTMtanhRewards36=[-0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17508269018743108]
drnnLSTMtanhRewards37=[-0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards38=[-0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026]
drnnLSTMtanhRewards39=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17562802996914942]
drnnLSTMtanhRewards40=[-0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drnnLSTMtanhRewards41=[-0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026]
drnnLSTMtanhRewards42=[-0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221]
drnnLSTMtanhRewards43=[-0.1749007498897221, -0.17471872931833224, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards44=[-0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards45=[-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards46=[-0.17508269018743108, -0.1749007498897221, -0.1749007498897221, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108]
drnnLSTMtanhRewards47=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108]
drnnLSTMtanhRewards48=[-0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026]
drnnLSTMtanhRewards49=[-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
# Deep Recurrent Reinforcement Learning: 1 capa LSTM y 4 capas Dense, Funcion de activacion relu, 12 episodes, 50 iteraciones
drnnLSTMreluMakespan0=[805, 800, 800, 800, 794, 800, 798, 809, 795, 800, 798, 798]
drnnLSTMreluMakespan1=[798, 798, 796, 799, 800, 796, 796, 798, 798, 794, 798, 800]
drnnLSTMreluMakespan2=[805, 805, 798, 799, 806, 799, 806, 799, 800, 798, 805, 795]
drnnLSTMreluMakespan3=[800, 800, 800, 796, 800, 800, 799, 806, 808, 798, 797, 798]
drnnLSTMreluMakespan4=[805, 805, 795, 796, 799, 804, 798, 794, 798, 794, 796, 810]
drnnLSTMreluMakespan5=[798, 798, 798, 795, 800, 798, 796, 802, 800, 800, 805, 801]
drnnLSTMreluMakespan6=[800, 798, 798, 795, 800, 796, 800, 798, 799, 796, 805, 800]
drnnLSTMreluMakespan7=[800, 800, 800, 799, 798, 798, 800, 805, 800, 799, 800, 801]
drnnLSTMreluMakespan8=[799, 800, 800, 799, 795, 795, 805, 795, 798, 800, 798, 800]
drnnLSTMreluMakespan9=[800, 796, 805, 798, 798, 795, 805, 800, 799, 795, 800, 805]
drnnLSTMreluMakespan10=[805, 798, 805, 800, 801, 805, 799, 805, 798, 800, 800, 798]
drnnLSTMreluMakespan11=[798, 803, 800, 797, 795, 796, 794, 799, 800, 800, 800, 796]
drnnLSTMreluMakespan12=[799, 798, 799, 795, 798, 795, 798, 798, 798, 795, 798, 798]
drnnLSTMreluMakespan13=[798, 798, 799, 796, 798, 796, 800, 799, 796, 794, 796, 795]
drnnLSTMreluMakespan14=[796, 798, 806, 799, 804, 798, 805, 798, 800, 805, 794, 800]
drnnLSTMreluMakespan15=[806, 795, 800, 796, 798, 796, 810, 798, 799, 798, 800, 800]
drnnLSTMreluMakespan16=[799, 796, 798, 798, 798, 800, 798, 810, 796, 805, 800, 795]
drnnLSTMreluMakespan17=[798, 798, 798, 794, 798, 805, 801, 798, 800, 799, 798, 798]
drnnLSTMreluMakespan18=[795, 800, 794, 798, 797, 798, 794, 800, 797, 796, 794, 794]
drnnLSTMreluMakespan19=[798, 802, 794, 798, 799, 795, 797, 795, 800, 796, 797, 796]
drnnLSTMreluMakespan20=[794, 797, 795, 794, 799, 795, 795, 795, 800, 797, 794, 798]
drnnLSTMreluMakespan21=[799, 798, 796, 795, 794, 798, 795, 795, 798, 798, 795, 794]
drnnLSTMreluMakespan22=[794, 794, 795, 797, 795, 795, 795, 792, 794, 795, 794, 794]
drnnLSTMreluMakespan23=[794, 794, 794, 794, 795, 796, 793, 794, 795, 794, 797, 795]
drnnLSTMreluMakespan24=[794, 792, 792, 794, 796, 792, 794, 795, 794, 792, 796, 795]
drnnLSTMreluMakespan25=[794, 795, 795, 794, 794, 792, 795, 792, 795, 794, 794, 794]
drnnLSTMreluMakespan26=[795, 794, 794, 795, 794, 794, 793, 794, 797, 795, 794, 795]
drnnLSTMreluMakespan27=[794, 794, 795, 796, 795, 797, 794, 794, 795, 801, 794, 795]
drnnLSTMreluMakespan28=[795, 795, 795, 795, 794, 792, 794, 797, 794, 795, 795, 795]
drnnLSTMreluMakespan29=[794, 792, 798, 794, 797, 795, 793, 795, 795, 794, 795, 795]
drnnLSTMreluMakespan30=[795, 794, 798, 794, 794, 795, 792, 796, 794, 796, 794, 794]
drnnLSTMreluMakespan31=[794, 795, 795, 794, 795, 794, 795, 795, 794, 794, 795, 795]
drnnLSTMreluMakespan32=[798, 794, 794, 794, 798, 792, 795, 795, 795, 796, 794, 795]
drnnLSTMreluMakespan33=[794, 796, 794, 794, 794, 795, 794, 794, 797, 793, 793, 795]
drnnLSTMreluMakespan34=[794, 794, 795, 794, 794, 793, 794, 795, 793, 795, 795, 794]
drnnLSTMreluMakespan35=[798, 796, 795, 794, 795, 795, 795, 795, 794, 795, 797, 795]
drnnLSTMreluMakespan36=[794, 796, 794, 794, 794, 794, 795, 795, 797, 796, 795, 795]
drnnLSTMreluMakespan37=[795, 794, 796, 795, 795, 795, 795, 794, 792, 797, 794, 793]
drnnLSTMreluMakespan38=[794, 798, 794, 792, 794, 792, 795, 797, 793, 794, 794, 797]
drnnLSTMreluMakespan39=[792, 794, 794, 794, 792, 795, 795, 795, 794, 794, 795, 794]
drnnLSTMreluMakespan40=[792, 795, 795, 792, 795, 795, 794, 795, 794, 795, 794, 795]
drnnLSTMreluMakespan41=[794, 797, 795, 794, 795, 795, 798, 794, 795, 796, 796, 794]
drnnLSTMreluMakespan42=[794, 795, 795, 795, 794, 795, 795, 794, 794, 795, 793, 795]
drnnLSTMreluMakespan43=[795, 794, 795, 794, 795, 795, 792, 794, 794, 795, 794, 795]
drnnLSTMreluMakespan44=[795, 794, 792, 795, 794, 794, 795, 794, 796, 795, 796, 794]
drnnLSTMreluMakespan45=[795, 794, 793, 794, 793, 795, 794, 794, 795, 794, 795, 794]
drnnLSTMreluMakespan46=[794, 796, 793, 794, 794, 795, 799, 795, 794, 794, 794, 794]
drnnLSTMreluMakespan47=[794, 794, 794, 794, 795, 793, 795, 795, 794, 795, 795, 795]
drnnLSTMreluMakespan48=[794, 794, 795, 794, 795, 795, 795, 794, 794, 795, 795, 794]
drnnLSTMreluMakespan49=[795, 795, 795, 794, 795, 795, 794, 795, 793, 793, 792, 792]
drnnLSTMreluRewards0=[-0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.17508269018743108, -0.17617264919621228, -0.17580964970257765, -0.1778021978021978, -0.17526455026455026, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765]
drnnLSTMreluRewards1=[-0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.1759911894273128, -0.17617264919621228, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17508269018743108, -0.17580964970257765, -0.17617264919621228]
drnnLSTMreluRewards2=[-0.177078750549934, -0.177078750549934, -0.17580964970257765, -0.1759911894273128, -0.17725973169122497, -0.1759911894273128, -0.17725973169122497, -0.1759911894273128, -0.17617264919621228, -0.17580964970257765, -0.177078750549934, -0.17526455026455026]
drnnLSTMreluRewards3=[-0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.17544633017412387, -0.17617264919621228, -0.17617264919621228, -0.1759911894273128, -0.17725973169122497, -0.1776214552648934, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765]
drnnLSTMreluRewards4=[-0.177078750549934, -0.177078750549934, -0.17526455026455026, -0.17544633017412387, -0.1759911894273128, -0.1768976897689769, -0.17580964970257765, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17544633017412387, -0.17798286090969018]
drnnLSTMreluRewards5=[-0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17617264919621228, -0.17580964970257765, -0.17544633017412387, -0.17653532907770195, -0.17617264919621228, -0.17617264919621228, -0.177078750549934, -0.1763540290620872]
drnnLSTMreluRewards6=[-0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.17544633017412387, -0.177078750549934, -0.17617264919621228]
drnnLSTMreluRewards7=[-0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.17617264919621228, -0.1759911894273128, -0.17617264919621228, -0.1763540290620872]
drnnLSTMreluRewards8=[-0.1759911894273128, -0.17617264919621228, -0.17617264919621228, -0.1759911894273128, -0.17526455026455026, -0.17526455026455026, -0.177078750549934, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.17617264919621228]
drnnLSTMreluRewards9=[-0.17617264919621228, -0.17544633017412387, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17526455026455026, -0.17617264919621228, -0.1759911894273128, -0.17526455026455026, -0.17617264919621228, -0.177078750549934]
drnnLSTMreluRewards10=[-0.177078750549934, -0.17580964970257765, -0.177078750549934, -0.17617264919621228, -0.1763540290620872, -0.1759911894273128, -0.177078750549934, -0.177078750549934, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765]
drnnLSTMreluRewards11=[-0.17580964970257765, -0.17671654929577466, -0.17617264919621228, -0.17562802996914942, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.1759911894273128, -0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.17544633017412387]
drnnLSTMreluRewards12=[-0.1759911894273128, -0.17580964970257765, -0.1759911894273128, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17580964970257765]
drnnLSTMreluRewards13=[-0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17544633017412387, -0.17580964970257765, -0.17544633017412387, -0.17617264919621228, -0.1759911894273128, -0.17544633017412387, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026]
drnnLSTMreluRewards14=[-0.17544633017412387, -0.17580964970257765, -0.17725973169122497, -0.1759911894273128, -0.1768976897689769, -0.17580964970257765, -0.177078750549934, -0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.17508269018743108, -0.17617264919621228]
drnnLSTMreluRewards15=[-0.17725973169122497, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765, -0.17544633017412387, -0.17798286090969018, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228]
drnnLSTMreluRewards16=[-0.1759911894273128, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.17798286090969018, -0.17544633017412387, -0.177078750549934, -0.17617264919621228, -0.17526455026455026]
drnnLSTMreluRewards17=[-0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17508269018743108, -0.17580964970257765, -0.177078750549934, -0.1763540290620872, -0.17580964970257765, -0.17617264919621228, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765]
drnnLSTMreluRewards18=[-0.17526455026455026, -0.17617264919621228, -0.17508269018743108, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.17508269018743108, -0.17617264919621228, -0.17562802996914942, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108]
drnnLSTMreluRewards19=[-0.17580964970257765, -0.17653532907770195, -0.17508269018743108, -0.17580964970257765, -0.1759911894273128, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.17562802996914942, -0.17544633017412387]
drnnLSTMreluRewards20=[-0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.1759911894273128, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17617264919621228, -0.17562802996914942, -0.17508269018743108, -0.17580964970257765]
drnnLSTMreluRewards21=[-0.1759911894273128, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108]
drnnLSTMreluRewards22=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108]
drnnLSTMreluRewards23=[-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026]
drnnLSTMreluRewards24=[-0.17508269018743108, -0.17471872931833224, -0.17471872931833224, -0.17508269018743108, -0.17544633017412387, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17544633017412387, -0.17526455026455026]
drnnLSTMreluRewards25=[-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drnnLSTMreluRewards26=[-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026]
drnnLSTMreluRewards27=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.1763540290620872, -0.17508269018743108, -0.17526455026455026]
drnnLSTMreluRewards28=[-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17562802996914942, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026]
drnnLSTMreluRewards29=[-0.17508269018743108, -0.17471872931833224, -0.17580964970257765, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drnnLSTMreluRewards30=[-0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17544633017412387, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108]
drnnLSTMreluRewards31=[-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drnnLSTMreluRewards32=[-0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17471872931833224, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.17526455026455026]
drnnLSTMreluRewards33=[-0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942, -0.1749007498897221, -0.1749007498897221, -0.17526455026455026]
drnnLSTMreluRewards34=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108]
drnnLSTMreluRewards35=[-0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026]
drnnLSTMreluRewards36=[-0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026]
drnnLSTMreluRewards37=[-0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17562802996914942, -0.17508269018743108, -0.1749007498897221]
drnnLSTMreluRewards38=[-0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.17562802996914942, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942]
drnnLSTMreluRewards39=[-0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drnnLSTMreluRewards40=[-0.17471872931833224, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026]
drnnLSTMreluRewards41=[-0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17544633017412387, -0.17508269018743108]
drnnLSTMreluRewards42=[-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026]
drnnLSTMreluRewards43=[-0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026]
drnnLSTMreluRewards44=[-0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108]
drnnLSTMreluRewards45=[-0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drnnLSTMreluRewards46=[-0.17508269018743108, -0.17544633017412387, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.1759911894273128, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drnnLSTMreluRewards47=[-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026]
drnnLSTMreluRewards48=[-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108]
drnnLSTMreluRewards49=[-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.1749007498897221, -0.17471872931833224, -0.17471872931833224]
# Deep Recurrent Reinforcement Learning: 1 capa GRU y 4 capas Dense, Funcion de activacion tanh, 12 episodes, 50 iteraciones
drnnGRUtanhMakespan0 = [798, 799, 798, 804, 805, 799, 801, 801, 801, 799, 798, 796]
drnnGRUtanhMakespan1 = [800, 798, 798, 798, 798, 798, 801, 798, 795, 796, 800, 796]
drnnGRUtanhMakespan2 = [795, 804, 805, 800, 800, 796, 804, 800, 795, 798, 798, 801]
drnnGRUtanhMakespan3 = [806, 796, 794, 797, 798, 800, 800, 808, 805, 798, 800, 809]
drnnGRUtanhMakespan4 = [805, 801, 795, 798, 798, 800, 796, 796, 805, 798, 799, 798]
drnnGRUtanhMakespan5 = [804, 799, 798, 804, 796, 799, 798, 805, 796, 805, 798, 800]
drnnGRUtanhMakespan6 = [800, 799, 794, 801, 799, 796, 800, 804, 797, 796, 800, 798]
drnnGRUtanhMakespan7 = [798, 800, 810, 810, 805, 800, 795, 798, 800, 805, 799, 800]
drnnGRUtanhMakespan8 = [798, 797, 800, 800, 804, 805, 798, 798, 801, 795, 798, 809]
drnnGRUtanhMakespan9 = [803, 800, 800, 805, 805, 798, 804, 803, 805, 801, 810, 801]
drnnGRUtanhMakespan10 = [798, 799, 798, 798, 805, 804, 805, 798, 799, 798, 800, 800]
drnnGRUtanhMakespan11 = [796, 795, 805, 800, 800, 798, 795, 804, 805, 798, 800, 800]
drnnGRUtanhMakespan12 = [799, 799, 809, 800, 799, 799, 797, 805, 799, 800, 798, 795]
drnnGRUtanhMakespan13 = [805, 800, 800, 805, 800, 799, 798, 801, 798, 797, 805, 800]
drnnGRUtanhMakespan14 = [800, 798, 800, 800, 800, 804, 804, 799, 799, 800, 798, 798]
drnnGRUtanhMakespan15 = [805, 800, 795, 800, 804, 795, 800, 798, 799, 798, 800, 796]
drnnGRUtanhMakespan16 = [806, 795, 801, 799, 799, 796, 796, 794, 802, 796, 800, 802]
drnnGRUtanhMakespan17 = [796, 800, 798, 800, 794, 800, 804, 805, 798, 810, 800, 798]
drnnGRUtanhMakespan18 = [798, 800, 794, 794, 797, 798, 800, 805, 798, 798, 804, 798]
drnnGRUtanhMakespan19 = [796, 800, 806, 799, 796, 800, 798, 805, 798, 799, 797, 805]
drnnGRUtanhMakespan20 = [805, 800, 799, 796, 805, 805, 805, 794, 809, 796, 800, 797]
drnnGRUtanhMakespan21 = [798, 800, 800, 800, 798, 801, 796, 801, 801, 801, 795, 799]
drnnGRUtanhMakespan22 = [798, 801, 797, 800, 799, 795, 799, 799, 800, 801, 800, 799]
drnnGRUtanhMakespan23 = [800, 798, 799, 805, 794, 800, 798, 796, 796, 804, 800, 794]
drnnGRUtanhMakespan24 = [800, 800, 798, 805, 804, 799, 798, 801, 800, 798, 798, 798]
drnnGRUtanhMakespan25 = [798, 798, 798, 795, 800, 803, 798, 798, 800, 799, 796, 798]
drnnGRUtanhMakespan26 = [796, 798, 798, 798, 805, 796, 798, 798, 805, 795, 801, 796]
drnnGRUtanhMakespan27 = [794, 796, 796, 800, 800, 798, 800, 798, 802, 798, 797, 798]
drnnGRUtanhMakespan28 = [799, 799, 800, 800, 798, 802, 799, 798, 795, 795, 794, 798]
drnnGRUtanhMakespan29 = [798, 796, 796, 797, 796, 798, 800, 800, 796, 798, 800, 795]
drnnGRUtanhMakespan30 = [799, 798, 795, 795, 800, 795, 798, 798, 799, 798, 805, 799]
drnnGRUtanhMakespan31 = [795, 799, 794, 794, 796, 795, 795, 794, 798, 797, 798, 795]
drnnGRUtanhMakespan32 = [797, 798, 795, 796, 798, 795, 797, 798, 795, 794, 795, 796]
drnnGRUtanhMakespan33 = [799, 795, 794, 794, 798, 795, 798, 797, 800, 796, 795, 794]
drnnGRUtanhMakespan34 = [798, 795, 798, 796, 798, 794, 796, 798, 798, 798, 796, 797]
drnnGRUtanhMakespan35 = [795, 798, 796, 798, 794, 801, 795, 800, 795, 800, 794, 800]
drnnGRUtanhMakespan36 = [798, 799, 796, 797, 795, 794, 800, 795, 795, 794, 795, 795]
drnnGRUtanhMakespan37 = [799, 798, 795, 795, 794, 795, 795, 796, 805, 795, 798, 796]
drnnGRUtanhMakespan38 = [798, 794, 795, 795, 795, 796, 795, 796, 800, 798, 797, 796]
drnnGRUtanhMakespan39 = [794, 795, 795, 797, 795, 795, 794, 794, 798, 795, 794, 798]
drnnGRUtanhMakespan40 = [795, 795, 795, 795, 795, 795, 794, 794, 793, 797, 794, 795]
drnnGRUtanhMakespan41 = [794, 794, 795, 793, 795, 795, 792, 794, 795, 794, 794, 794]
drnnGRUtanhMakespan42 = [795, 795, 795, 796, 794, 797, 795, 795, 792, 795, 796, 793]
drnnGRUtanhMakespan43 = [794, 795, 795, 794, 795, 794, 798, 794, 797, 795, 794, 794]
drnnGRUtanhMakespan44 = [795, 795, 793, 794, 795, 794, 795, 795, 794, 794, 795, 794]
drnnGRUtanhMakespan45 = [794, 794, 794, 794, 794, 794, 795, 794, 794, 794, 796, 795]
drnnGRUtanhMakespan46 = [795, 794, 795, 794, 794, 794, 793, 794, 795, 795, 794, 797]
drnnGRUtanhMakespan47 = [794, 794, 794, 794, 795, 794, 795, 792, 794, 795, 794, 794]
drnnGRUtanhMakespan48 = [795, 794, 794, 794, 795, 798, 794, 794, 794, 795, 794, 794]
drnnGRUtanhMakespan49 = [795, 795, 794, 795, 793, 795, 796, 794, 795, 794, 794, 797]
drnnGRUtanhRewards0 = [-0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.1768976897689769, -0.177078750549934, -0.1759911894273128, -0.1763540290620872, -0.1763540290620872, -0.1763540290620872, -0.1759911894273128, -0.17580964970257765, -0.17544633017412387]
drnnGRUtanhRewards1 = [-0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.1763540290620872, -0.17580964970257765, -0.17526455026455026, -0.17544633017412387, -0.17617264919621228, -0.17544633017412387]
drnnGRUtanhRewards2 = [-0.17526455026455026, -0.1768976897689769, -0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.17544633017412387, -0.1768976897689769, -0.17617264919621228, -0.17526455026455026, -0.17580964970257765, -0.17580964970257765, -0.1763540290620872]
drnnGRUtanhRewards3 = [-0.17725973169122497, -0.17544633017412387, -0.17508269018743108, -0.17562802996914942, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.1776214552648934, -0.177078750549934, -0.17580964970257765, -0.17617264919621228, -0.1778021978021978]
drnnGRUtanhRewards4 = [-0.177078750549934, -0.1763540290620872, -0.17526455026455026, -0.17580964970257765, -0.17580964970257765, -0.17617264919621228, -0.17544633017412387, -0.17544633017412387, -0.177078750549934, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765]
drnnGRUtanhRewards5 = [-0.1768976897689769, -0.1759911894273128, -0.17580964970257765, -0.1768976897689769, -0.17544633017412387, -0.1759911894273128, -0.17580964970257765, -0.177078750549934, -0.17544633017412387, -0.177078750549934, -0.17580964970257765, -0.17617264919621228]
drnnGRUtanhRewards6 = [-0.17617264919621228, -0.1759911894273128, -0.17508269018743108, -0.1763540290620872, -0.1759911894273128, -0.17544633017412387, -0.17617264919621228, -0.1768976897689769, -0.17562802996914942, -0.17544633017412387, -0.17617264919621228, -0.17580964970257765]
drnnGRUtanhRewards7 = [-0.17580964970257765, -0.17617264919621228, -0.17798286090969018, -0.177078750549934, -0.17798286090969018, -0.17617264919621228, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.1759911894273128, -0.17617264919621228]
drnnGRUtanhRewards8 = [-0.17580964970257765, -0.17562802996914942, -0.17617264919621228, -0.17617264919621228, -0.1768976897689769, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.1763540290620872, -0.17580964970257765, -0.1778021978021978]
drnnGRUtanhRewards9 = [-0.17671654929577466, -0.17617264919621228, -0.17617264919621228, -0.177078750549934, -0.177078750549934, -0.17580964970257765, -0.1768976897689769, -0.17671654929577466, -0.177078750549934, -0.1763540290620872, -0.17798286090969018, -0.1763540290620872]
drnnGRUtanhRewards10 = [-0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.1768976897689769, -0.177078750549934, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228]
drnnGRUtanhRewards11 = [-0.17544633017412387, -0.17526455026455026, -0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17526455026455026, -0.1768976897689769, -0.177078750549934, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228]
drnnGRUtanhRewards12 = [-0.1759911894273128, -0.1759911894273128, -0.1778021978021978, -0.17617264919621228, -0.1759911894273128, -0.1759911894273128, -0.17562802996914942, -0.177078750549934, -0.1759911894273128, -0.17617264919621228, -0.17580964970257765, -0.17526455026455026]
drnnGRUtanhRewards13 = [-0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.177078750549934, -0.17617264919621228, -0.1759911894273128, -0.17580964970257765, -0.1763540290620872, -0.17580964970257765, -0.17562802996914942, -0.177078750549934, -0.17617264919621228]
drnnGRUtanhRewards14 = [-0.17617264919621228, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.1768976897689769, -0.1768976897689769, -0.1759911894273128, -0.1759911894273128, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765]
drnnGRUtanhRewards15 = [-0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.17526455026455026, -0.1768976897689769, -0.17526455026455026, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17617264919621228, -0.17544633017412387]
drnnGRUtanhRewards16 = [-0.17725973169122497, -0.17526455026455026, -0.1763540290620872, -0.1759911894273128, -0.1759911894273128, -0.17544633017412387, -0.17544633017412387, -0.17508269018743108, -0.17653532907770195, -0.17544633017412387, -0.17617264919621228, -0.17653532907770195]
drnnGRUtanhRewards17 = [-0.17544633017412387, -0.17617264919621228, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17508269018743108, -0.1768976897689769, -0.177078750549934, -0.17580964970257765, -0.17798286090969018, -0.17617264919621228, -0.17580964970257765]
drnnGRUtanhRewards18 = [-0.17580964970257765, -0.17617264919621228, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942, -0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.1768976897689769, -0.17580964970257765]
drnnGRUtanhRewards19 = [-0.17544633017412387, -0.17617264919621228, -0.17725973169122497, -0.1759911894273128, -0.17544633017412387, -0.17617264919621228, -0.17580964970257765, -0.177078750549934, -0.17580964970257765, -0.17562802996914942, -0.1759911894273128, -0.177078750549934]
drnnGRUtanhRewards20 = [-0.17617264919621228, -0.177078750549934, -0.1759911894273128, -0.17544633017412387, -0.177078750549934, -0.177078750549934, -0.177078750549934, -0.17508269018743108, -0.1778021978021978, -0.17544633017412387, -0.17617264919621228, -0.17562802996914942]
drnnGRUtanhRewards21 = [-0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.1763540290620872, -0.17544633017412387, -0.1763540290620872, -0.1763540290620872, -0.1763540290620872, -0.17526455026455026, -0.1759911894273128]
drnnGRUtanhRewards22 = [-0.17580964970257765, -0.1763540290620872, -0.17562802996914942, -0.17617264919621228, -0.1759911894273128, -0.17526455026455026, -0.1759911894273128, -0.1759911894273128, -0.17617264919621228, -0.1763540290620872, -0.17617264919621228, -0.1759911894273128]
drnnGRUtanhRewards23 = [-0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.177078750549934, -0.17508269018743108, -0.17617264919621228, -0.17580964970257765, -0.17544633017412387, -0.17544633017412387, -0.1768976897689769, -0.17617264919621228, -0.17508269018743108]
drnnGRUtanhRewards24 = [-0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.177078750549934, -0.1768976897689769, -0.17580964970257765, -0.1763540290620872, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765]
drnnGRUtanhRewards25 = [-0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17617264919621228, -0.17580964970257765, -0.17671654929577466, -0.17580964970257765, -0.17617264919621228, -0.1759911894273128, -0.17544633017412387, -0.17580964970257765]
drnnGRUtanhRewards26 = [-0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17526455026455026, -0.1763540290620872, -0.17544633017412387]
drnnGRUtanhRewards27 = [-0.17508269018743108, -0.17544633017412387, -0.17544633017412387, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.17653532907770195, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765]
drnnGRUtanhRewards28 = [-0.1759911894273128, -0.1759911894273128, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17653532907770195, -0.17580964970257765, -0.1759911894273128, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765]
drnnGRUtanhRewards29 = [-0.17580964970257765, -0.17544633017412387, -0.17544633017412387, -0.17562802996914942, -0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.17526455026455026]
drnnGRUtanhRewards30 = [-0.1759911894273128, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17617264919621228, -0.17526455026455026, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.1759911894273128]
drnnGRUtanhRewards31 = [-0.17526455026455026, -0.1759911894273128, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.17526455026455026]
drnnGRUtanhRewards32 = [-0.17562802996914942, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026]
drnnGRUtanhRewards33 = [-0.1759911894273128, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17580964970257765, -0.17562802996914942, -0.17617264919621228, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108]
drnnGRUtanhRewards34 = [-0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17544633017412387, -0.17508269018743108, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17562802996914942]
drnnGRUtanhRewards35 = [-0.17526455026455026, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17508269018743108, -0.1763540290620872, -0.17526455026455026, -0.17617264919621228, -0.17526455026455026, -0.17617264919621228, -0.17508269018743108, -0.17617264919621228]
drnnGRUtanhRewards36 = [-0.17580964970257765, -0.1759911894273128, -0.17544633017412387, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17617264919621228, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drnnGRUtanhRewards37 = [-0.1759911894273128, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.177078750549934, -0.17526455026455026, -0.17580964970257765, -0.17544633017412387]
drnnGRUtanhRewards38 = [-0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17617264919621228, -0.17580964970257765, -0.17562802996914942, -0.17544633017412387]
drnnGRUtanhRewards39 = [-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765]
drnnGRUtanhRewards40 = [-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17562802996914942, -0.17508269018743108, -0.17526455026455026]
drnnGRUtanhRewards41 = [-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drnnGRUtanhRewards42 = [-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17544633017412387, -0.1749007498897221]
drnnGRUtanhRewards43 = [-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108]
drnnGRUtanhRewards44 = [-0.17526455026455026, -0.17526455026455026, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drnnGRUtanhRewards45 = [-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026]
drnnGRUtanhRewards46 = [-0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17562802996914942]
drnnGRUtanhRewards47 = [-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108]
drnnGRUtanhRewards48 = [-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108]
drnnGRUtanhRewards49 = [-0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942]
# Deep Recurrent Reinforcement Learning: 1 capa GRU y 4 capas Dense, Funcion de activacion relu, 12 episodes, 50 iteraciones
drnnGRUreluMakespan0 = [800, 799, 798, 797, 798, 800, 800, 796, 800, 794, 800, 800]
drnnGRUreluMakespan1 = [798, 800, 805, 795, 799, 808, 795, 800, 796, 798, 799, 798]
drnnGRUreluMakespan2 = [799, 800, 806, 800, 800, 805, 805, 798, 799, 807, 800, 800]
drnnGRUreluMakespan3 = [798, 795, 799, 800, 800, 796, 798, 800, 800, 804, 805, 800]
drnnGRUreluMakespan4 = [811, 800, 799, 800, 805, 798, 798, 799, 796, 804, 805, 804]
drnnGRUreluMakespan5 = [799, 795, 797, 800, 798, 800, 800, 798, 800, 797, 800, 798]
drnnGRUreluMakespan6 = [798, 800, 798, 799, 797, 798, 800, 796, 801, 799, 795, 798]
drnnGRUreluMakespan7 = [800, 804, 795, 801, 796, 806, 805, 798, 800, 799, 799, 804]
drnnGRUreluMakespan8 = [800, 799, 799, 800, 805, 796, 800, 800, 810, 796, 800, 798]
drnnGRUreluMakespan9 = [794, 800, 799, 805, 800, 800, 798, 798, 796, 795, 798, 796]
drnnGRUreluMakespan10 = [798, 800, 798, 801, 795, 802, 796, 809, 800, 800, 798, 795]
drnnGRUreluMakespan11 = [804, 800, 799, 799, 798, 803, 798, 798, 805, 803, 800, 796]
drnnGRUreluMakespan12 = [800, 799, 805, 797, 798, 796, 799, 794, 799, 805, 799, 800]
drnnGRUreluMakespan13 = [796, 800, 798, 800, 795, 799, 800, 804, 800, 794, 805, 805]
drnnGRUreluMakespan14 = [800, 795, 796, 798, 798, 801, 805, 794, 800, 801, 801, 796]
drnnGRUreluMakespan15 = [798, 800, 796, 796, 798, 794, 797, 800, 796, 801, 795, 799]
drnnGRUreluMakespan16 = [800, 805, 794, 800, 799, 800, 805, 801, 798, 800, 801, 799]
drnnGRUreluMakespan17 = [797, 803, 801, 808, 794, 799, 799, 800, 805, 796, 801, 796]
drnnGRUreluMakespan18 = [805, 800, 800, 804, 799, 798, 800, 799, 804, 796, 800, 804]
drnnGRUreluMakespan19 = [804, 798, 800, 799, 799, 799, 805, 795, 801, 799, 799, 805]
drnnGRUreluMakespan20 = [799, 804, 796, 798, 796, 798, 800, 805, 799, 810, 800, 800]
drnnGRUreluMakespan21 = [798, 799, 799, 805, 798, 798, 805, 798, 794, 799, 798, 798]
drnnGRUreluMakespan22 = [799, 798, 798, 796, 798, 805, 799, 798, 798, 799, 796, 798]
drnnGRUreluMakespan23 = [798, 805, 808, 798, 798, 805, 810, 796, 804, 799, 800, 799]
drnnGRUreluMakespan24 = [798, 796, 798, 795, 800, 798, 799, 798, 797, 805, 798, 800]
drnnGRUreluMakespan25 = [799, 796, 799, 798, 805, 798, 798, 800, 796, 794, 810, 798]
drnnGRUreluMakespan26 = [799, 798, 805, 800, 802, 798, 799, 799, 799, 794, 802, 797]
drnnGRUreluMakespan27 = [798, 800, 805, 796, 798, 795, 802, 796, 798, 800, 798, 794]
drnnGRUreluMakespan28 = [796, 805, 798, 800, 800, 798, 810, 798, 798, 798, 796, 796]
drnnGRUreluMakespan29 = [800, 798, 798, 802, 794, 798, 796, 808, 800, 800, 798, 799]
drnnGRUreluMakespan30 = [798, 796, 798, 798, 794, 798, 794, 800, 796, 794, 800, 800]
drnnGRUreluMakespan31 = [794, 802, 797, 799, 798, 800, 799, 799, 796, 796, 798, 798]
drnnGRUreluMakespan32 = [799, 798, 794, 795, 798, 805, 804, 797, 795, 800, 796, 798]
drnnGRUreluMakespan33 = [803, 799, 805, 796, 794, 798, 797, 798, 798, 794, 794, 798]
drnnGRUreluMakespan34 = [810, 796, 795, 798, 799, 798, 796, 795, 795, 797, 798, 798]
drnnGRUreluMakespan35 = [799, 799, 799, 799, 795, 798, 795, 800, 796, 795, 795, 796]
drnnGRUreluMakespan36 = [795, 797, 798, 799, 799, 799, 800, 794, 796, 795, 798, 800]
drnnGRUreluMakespan37 = [800, 798, 799, 794, 800, 796, 798, 798, 797, 800, 794, 798]
drnnGRUreluMakespan38 = [800, 799, 794, 796, 795, 800, 796, 804, 800, 795, 800, 798]
drnnGRUreluMakespan39 = [794, 798, 795, 804, 805, 799, 798, 800, 796, 798, 795, 794]
drnnGRUreluMakespan40 = [799, 798, 796, 798, 798, 799, 800, 796, 798, 798, 799, 798]
drnnGRUreluMakespan41 = [796, 798, 800, 797, 799, 796, 797, 796, 799, 804, 805, 798]
drnnGRUreluMakespan42 = [798, 794, 795, 799, 799, 798, 797, 798, 798, 798, 798, 795]
drnnGRUreluMakespan43 = [799, 798, 794, 794, 795, 794, 795, 799, 799, 800, 799, 794]
drnnGRUreluMakespan44 = [795, 796, 795, 799, 794, 795, 794, 796, 795, 794, 795, 796]
drnnGRUreluMakespan45 = [794, 797, 794, 795, 796, 795, 794, 799, 795, 794, 798, 798]
drnnGRUreluMakespan46 = [795, 795, 794, 795, 794, 794, 792, 794, 795, 797, 794, 794]
drnnGRUreluMakespan47 = [798, 796, 797, 798, 794, 798, 794, 797, 794, 803, 798, 798]
drnnGRUreluMakespan48 = [795, 794, 796, 798, 795, 794, 796, 795, 796, 794, 796, 796]
drnnGRUreluMakespan49 = [798, 798, 796, 798, 798, 796, 796, 798, 798, 798, 796, 798]
drnnGRUreluRewards0 = [-0.17617264919621228, -0.1759911894273128, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17544633017412387, -0.17617264919621228, -0.17508269018743108, -0.17617264919621228, -0.17617264919621228]
drnnGRUreluRewards1 = [-0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.17526455026455026, -0.1759911894273128, -0.1776214552648934, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765]
drnnGRUreluRewards2 = [-0.1759911894273128, -0.17617264919621228, -0.17725973169122497, -0.17617264919621228, -0.17617264919621228, -0.177078750549934, -0.177078750549934, -0.17580964970257765, -0.1759911894273128, -0.1774406332453826, -0.17617264919621228, -0.17617264919621228]
drnnGRUreluRewards3 = [-0.17580964970257765, -0.17526455026455026, -0.1759911894273128, -0.17617264919621228, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.1768976897689769, -0.177078750549934, -0.17617264919621228]
drnnGRUreluRewards4 = [-0.1781634446397188, -0.17617264919621228, -0.1759911894273128, -0.17617264919621228, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17544633017412387, -0.1768976897689769, -0.177078750549934, -0.1768976897689769]
drnnGRUreluRewards5 = [-0.1759911894273128, -0.17526455026455026, -0.17562802996914942, -0.17617264919621228, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17617264919621228, -0.17562802996914942, -0.17617264919621228, -0.17580964970257765]
drnnGRUreluRewards6 = [-0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.17562802996914942, -0.17580964970257765, -0.17544633017412387, -0.17617264919621228, -0.1763540290620872, -0.1759911894273128, -0.17526455026455026, -0.17580964970257765]
drnnGRUreluRewards7 = [-0.17617264919621228, -0.1768976897689769, -0.17526455026455026, -0.1763540290620872, -0.17544633017412387, -0.17725973169122497, -0.177078750549934, -0.17580964970257765, -0.17617264919621228, -0.1759911894273128, -0.1759911894273128, -0.1768976897689769]
drnnGRUreluRewards8 = [-0.17617264919621228, -0.1759911894273128, -0.1759911894273128, -0.17617264919621228, -0.177078750549934, -0.17544633017412387, -0.17617264919621228, -0.17617264919621228, -0.17798286090969018, -0.17544633017412387, -0.17617264919621228, -0.17580964970257765]
drnnGRUreluRewards9 = [-0.17508269018743108, -0.17617264919621228, -0.1759911894273128, -0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765, -0.17544633017412387]
drnnGRUreluRewards10 = [-0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.1763540290620872, -0.17526455026455026, -0.17653532907770195, -0.17544633017412387, -0.1778021978021978, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17526455026455026]
drnnGRUreluRewards11 = [-0.1768976897689769, -0.17617264919621228, -0.1759911894273128, -0.1759911894273128, -0.17580964970257765, -0.17671654929577466, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17671654929577466, -0.17617264919621228, -0.17544633017412387]
drnnGRUreluRewards12 = [-0.17617264919621228, -0.1759911894273128, -0.177078750549934, -0.17562802996914942, -0.17580964970257765, -0.17544633017412387, -0.1759911894273128, -0.17508269018743108, -0.1759911894273128, -0.177078750549934, -0.1759911894273128, -0.17617264919621228]
drnnGRUreluRewards13 = [-0.17544633017412387, -0.17617264919621228, -0.17580964970257765, -0.17617264919621228, -0.17526455026455026, -0.1759911894273128, -0.17617264919621228, -0.1768976897689769, -0.17617264919621228, -0.17508269018743108, -0.177078750549934, -0.177078750549934]
drnnGRUreluRewards14 = [-0.17617264919621228, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.1763540290620872, -0.177078750549934, -0.17508269018743108, -0.17617264919621228, -0.1763540290620872, -0.1763540290620872, -0.17544633017412387]
drnnGRUreluRewards15 = [-0.17580964970257765, -0.17617264919621228, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17508269018743108, -0.17562802996914942, -0.17617264919621228, -0.17544633017412387, -0.1763540290620872, -0.17526455026455026, -0.1759911894273128]
drnnGRUreluRewards16 = [-0.17617264919621228, -0.177078750549934, -0.17508269018743108, -0.17617264919621228, -0.1759911894273128, -0.17617264919621228, -0.177078750549934, -0.1763540290620872, -0.17580964970257765, -0.17617264919621228, -0.1763540290620872, -0.1759911894273128]
drnnGRUreluRewards17 = [-0.17562802996914942, -0.17671654929577466, -0.1763540290620872, -0.1776214552648934, -0.17508269018743108, -0.1759911894273128, -0.17617264919621228, -0.1759911894273128, -0.177078750549934, -0.17544633017412387, -0.1763540290620872, -0.17544633017412387]
drnnGRUreluRewards18 = [-0.177078750549934, -0.17617264919621228, -0.17617264919621228, -0.1768976897689769, -0.1759911894273128, -0.17580964970257765, -0.17617264919621228, -0.1759911894273128, -0.1768976897689769, -0.17544633017412387, -0.17617264919621228, -0.1768976897689769]
drnnGRUreluRewards19 = [-0.1768976897689769, -0.17580964970257765, -0.17617264919621228, -0.1759911894273128, -0.1759911894273128, -0.1759911894273128, -0.177078750549934, -0.17526455026455026, -0.1763540290620872, -0.1759911894273128, -0.1759911894273128, -0.177078750549934]
drnnGRUreluRewards20 = [-0.1759911894273128, -0.1768976897689769, -0.17544633017412387, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.1759911894273128, -0.17798286090969018, -0.17617264919621228, -0.17617264919621228]
drnnGRUreluRewards21 = [-0.17580964970257765, -0.1759911894273128, -0.1759911894273128, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17580964970257765, -0.17508269018743108, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765]
drnnGRUreluRewards22 = [-0.1759911894273128, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.177078750549934, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17544633017412387, -0.17580964970257765]
drnnGRUreluRewards23 = [-0.17580964970257765, -0.177078750549934, -0.1776214552648934, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17798286090969018, -0.17544633017412387, -0.1768976897689769, -0.1759911894273128, -0.17617264919621228, -0.1759911894273128]
drnnGRUreluRewards24 = [-0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17562802996914942, -0.177078750549934, -0.17580964970257765, -0.17617264919621228]
drnnGRUreluRewards25 = [-0.1759911894273128, -0.17544633017412387, -0.1759911894273128, -0.17580964970257765, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.17617264919621228, -0.17544633017412387, -0.17508269018743108, -0.17798286090969018, -0.17580964970257765]
drnnGRUreluRewards26 = [-0.1759911894273128, -0.17580964970257765, -0.177078750549934, -0.17617264919621228, -0.17653532907770195, -0.17580964970257765, -0.1759911894273128, -0.1759911894273128, -0.1759911894273128, -0.17508269018743108, -0.17653532907770195, -0.17562802996914942]
drnnGRUreluRewards27 = [-0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17653532907770195, -0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.17508269018743108]
drnnGRUreluRewards28 = [-0.17544633017412387, -0.177078750549934, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.17798286090969018, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17544633017412387]
drnnGRUreluRewards29 = [-0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.17653532907770195, -0.17508269018743108, -0.17580964970257765, -0.17544633017412387, -0.1776214552648934, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128]
drnnGRUreluRewards30 = [-0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17617264919621228, -0.17544633017412387, -0.17508269018743108, -0.17617264919621228, -0.17617264919621228]
drnnGRUreluRewards31 = [-0.17508269018743108, -0.17653532907770195, -0.17562802996914942, -0.1759911894273128, -0.17580964970257765, -0.17617264919621228, -0.1759911894273128, -0.1759911894273128, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765]
drnnGRUreluRewards32 = [-0.1759911894273128, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.1768976897689769, -0.177078750549934, -0.17562802996914942, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765]
drnnGRUreluRewards33 = [-0.17671654929577466, -0.1759911894273128, -0.177078750549934, -0.17544633017412387, -0.17508269018743108, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765]
drnnGRUreluRewards34 = [-0.17798286090969018, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17580964970257765, -0.17580964970257765]
drnnGRUreluRewards35 = [-0.1759911894273128, -0.1759911894273128, -0.1759911894273128, -0.1759911894273128, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387]
drnnGRUreluRewards36 = [-0.17526455026455026, -0.17562802996914942, -0.17580964970257765, -0.1759911894273128, -0.1759911894273128, -0.1759911894273128, -0.17617264919621228, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228]
drnnGRUreluRewards37 = [-0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.17508269018743108, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17562802996914942, -0.17617264919621228, -0.17508269018743108, -0.17580964970257765]
drnnGRUreluRewards38 = [-0.17617264919621228, -0.1759911894273128, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.1768976897689769, -0.17617264919621228, -0.17526455026455026, -0.17617264919621228, -0.17580964970257765]
drnnGRUreluRewards39 = [-0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.1768976897689769, -0.177078750549934, -0.1759911894273128, -0.17580964970257765, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108]
drnnGRUreluRewards40 = [-0.1759911894273128, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765]
drnnGRUreluRewards41 = [-0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.17562802996914942, -0.1759911894273128, -0.17544633017412387, -0.17562802996914942, -0.17544633017412387, -0.1759911894273128, -0.1768976897689769, -0.177078750549934, -0.17580964970257765]
drnnGRUreluRewards42 = [-0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.1759911894273128, -0.1759911894273128, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026]
drnnGRUreluRewards43 = [-0.1759911894273128, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.1759911894273128, -0.1759911894273128, -0.17617264919621228, -0.1759911894273128, -0.17508269018743108]
drnnGRUreluRewards44 = [-0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.1759911894273128, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387]
drnnGRUreluRewards45 = [-0.17508269018743108, -0.17562802996914942, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.1759911894273128, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17580964970257765]
drnnGRUreluRewards46 = [-0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108]
drnnGRUreluRewards47 = [-0.17580964970257765, -0.17544633017412387, -0.17562802996914942, -0.17580964970257765, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17562802996914942, -0.17508269018743108, -0.17671654929577466, -0.17580964970257765, -0.17580964970257765]
drnnGRUreluRewards48 = [-0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.17544633017412387, -0.17544633017412387]
drnnGRUreluRewards49 = [-0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765]
# Deep Reinforcement Learning: 5 capas Dense, Funcion de activacion tanh, 12 episodios, 50 iteraciones
drlTanhMakespan0 = [794, 794, 805, 799, 810, 800, 794, 810, 804, 806, 812, 808]
drlTanhMakespan1 = [796, 795, 795, 798, 799, 800, 800, 795, 797, 796, 797, 799]
drlTanhMakespan2 = [800, 797, 798, 801, 799, 800, 796, 795, 797, 796, 794, 798]
drlTanhMakespan3 = [800, 795, 799, 796, 799, 798, 795, 799, 795, 799, 798, 796]
drlTanhMakespan4 = [809, 795, 795, 800, 797, 795, 798, 798, 799, 799, 798, 798]
drlTanhMakespan5 = [795, 795, 795, 799, 795, 798, 795, 800, 795, 796, 795, 805]
drlTanhMakespan6 = [794, 800, 795, 793, 798, 795, 794, 798, 795, 799, 795, 796]
drlTanhMakespan7 = [795, 795, 795, 795, 798, 795, 797, 797, 795, 795, 798, 797]
drlTanhMakespan8 = [795, 795, 795, 794, 800, 800, 794, 795, 794, 794, 797, 795]
drlTanhMakespan9 = [793, 794, 796, 795, 796, 800, 794, 797, 793, 795, 798, 795]
drlTanhMakespan10 = [795, 795, 797, 794, 795, 798, 797, 795, 798, 794, 794, 794]
drlTanhMakespan11 = [795, 795, 795, 795, 797, 795, 795, 794, 795, 795, 795, 794]
drlTanhMakespan12 = [794, 798, 795, 794, 795, 795, 795, 797, 799, 795, 795, 795]
drlTanhMakespan13 = [795, 797, 795, 800, 796, 795, 796, 795, 795, 795, 798, 794]
drlTanhMakespan14 = [795, 795, 796, 794, 794, 794, 797, 795, 798, 795, 795, 793]
drlTanhMakespan15 = [799, 794, 795, 795, 795, 796, 801, 797, 795, 794, 795, 799]
drlTanhMakespan16 = [795, 795, 796, 798, 795, 795, 795, 795, 795, 798, 798, 796]
drlTanhMakespan17 = [800, 798, 795, 795, 798, 794, 795, 795, 797, 795, 796, 794]
drlTanhMakespan18 = [797, 800, 798, 797, 796, 794, 799, 797, 795, 796, 799, 798]
drlTanhMakespan19 = [797, 800, 795, 794, 794, 796, 795, 798, 796, 798, 797, 795]
drlTanhMakespan20 = [794, 795, 795, 799, 798, 797, 795, 795, 798, 795, 798, 795]
drlTanhMakespan21 = [796, 795, 795, 795, 795, 797, 798, 794, 797, 795, 796, 794]
drlTanhMakespan22 = [799, 796, 795, 795, 795, 795, 796, 795, 796, 798, 796, 795]
drlTanhMakespan23 = [799, 799, 795, 796, 796, 799, 796, 797, 794, 794, 798, 796]
drlTanhMakespan24 = [795, 795, 797, 800, 797, 795, 795, 796, 795, 795, 798, 799]
drlTanhMakespan25 = [795, 797, 795, 795, 795, 795, 800, 796, 795, 797, 795, 795]
drlTanhMakespan26 = [795, 795, 799, 794, 797, 794, 794, 798, 794, 796, 795, 798]
drlTanhMakespan27 = [796, 796, 795, 796, 798, 797, 794, 795, 794, 794, 794, 798]
drlTanhMakespan28 = [795, 795, 794, 798, 796, 796, 800, 797, 797, 796, 795, 794]
drlTanhMakespan29 = [795, 795, 798, 800, 797, 794, 796, 794, 792, 794, 794, 795]
drlTanhMakespan30 = [798, 797, 795, 799, 797, 800, 798, 799, 797, 800, 794, 796]
drlTanhMakespan31 = [794, 795, 800, 798, 800, 794, 800, 798, 799, 798, 798, 798]
drlTanhMakespan32 = [795, 795, 795, 794, 794, 794, 793, 795, 794, 793, 794, 795]
drlTanhMakespan33 = [794, 797, 792, 794, 795, 795, 797, 795, 795, 794, 792, 795]
drlTanhMakespan34 = [795, 794, 795, 798, 795, 796, 794, 795, 794, 794, 795, 794]
drlTanhMakespan35 = [796, 794, 797, 793, 794, 798, 795, 794, 793, 793, 795, 794]
drlTanhMakespan36 = [795, 795, 794, 795, 795, 795, 794, 795, 795, 793, 795, 794]
drlTanhMakespan37 = [794, 794, 798, 794, 794, 796, 795, 794, 793, 795, 795, 792]
drlTanhMakespan38 = [794, 796, 795, 794, 798, 798, 795, 795, 794, 794, 795, 794]
drlTanhMakespan39 = [794, 795, 795, 796, 792, 794, 795, 794, 795, 794, 794, 795]
drlTanhMakespan40 = [798, 795, 794, 795, 794, 794, 793, 795, 794, 794, 797, 794]
drlTanhMakespan41 = [795, 792, 795, 794, 794, 795, 794, 795, 792, 797, 795, 795]
drlTanhMakespan42 = [792, 794, 794, 795, 794, 794, 795, 794, 792, 794, 794, 794]
drlTanhMakespan43 = [794, 796, 794, 793, 795, 795, 793, 798, 794, 794, 798, 794]
drlTanhMakespan44 = [794, 794, 794, 794, 795, 794, 793, 794, 794, 795, 795, 794]
drlTanhMakespan45 = [790, 794, 793, 794, 793, 794, 795, 794, 791, 795, 795, 794]
drlTanhMakespan46 = [792, 794, 794, 794, 794, 794, 794, 793, 794, 794, 794, 794]
drlTanhMakespan47 = [794, 794, 794, 794, 794, 794, 794, 794, 792, 795, 793, 795]
drlTanhMakespan48 = [794, 794, 792, 792, 797, 794, 792, 794, 794, 795, 794, 795]
drlTanhMakespan49 = [795, 794, 794, 796, 794, 797, 794, 794, 794, 794, 794, 794]
drlTanhMakespan50 = [794, 792, 795, 794, 794, 794, 794, 794, 795, 794, 795, 794]
drlTanhMakespan51 = [794, 792, 796, 795, 794, 794, 795, 794, 795, 795, 795, 794]
drlTanhMakespan52 = [794, 794, 795, 792, 795, 795, 795, 792, 794, 793, 795, 794]
drlTanhMakespan53 = [794, 792, 794, 792, 794, 794, 794, 795, 795, 794, 794, 792]
drlTanhMakespan54 = [795, 793, 794, 794, 794, 792, 795, 794, 794, 792, 794, 796]
drlTanhMakespan55 = [795, 794, 794, 795, 795, 793, 794, 795, 794, 797, 795, 792]
drlTanhMakespan56 = [795, 795, 792, 795, 794, 795, 794, 794, 794, 795, 795, 795]
drlTanhMakespan57 = [795, 792, 795, 794, 795, 795, 792, 795, 794, 797, 792, 792]
drlTanhMakespan58 = [795, 795, 794, 795, 792, 794, 794, 794, 792, 792, 792, 793]
drlTanhMakespan59 = [795, 794, 792, 794, 794, 794, 792, 794, 794, 794, 793, 795]
drlTanhMakespan60 = [794, 795, 795, 795, 798, 794, 794, 794, 794, 794, 794, 792]
drlTanhMakespan61 = [792, 795, 794, 794, 795, 794, 792, 795, 795, 794, 794, 795]
drlTanhMakespan62 = [795, 794, 794, 794, 799, 794, 792, 794, 795, 795, 794, 793]
drlTanhMakespan63 = [791, 795, 792, 796, 794, 794, 792, 795, 793, 794, 792, 794]
drlTanhRewards0 = [-0.17508269018743108, -0.17508269018743108, -0.177078750549934, -0.1759911894273128, -0.17798286090969018, -0.17617264919621228, -0.17508269018743108, -0.17798286090969018, -0.1768976897689769, -0.17725973169122497, -0.17834394904458598, -0.1776214552648934]
drlTanhRewards1 = [-0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228, -0.1759911894273128, -0.17617264919621228, -0.17526455026455026, -0.17562802996914942, -0.17544633017412387, -0.17562802996914942, -0.1759911894273128]
drlTanhRewards2 = [-0.17617264919621228, -0.17562802996914942, -0.17580964970257765, -0.1763540290620872, -0.1759911894273128, -0.17617264919621228, -0.17544633017412387, -0.17526455026455026, -0.17562802996914942, -0.17508269018743108, -0.17544633017412387, -0.17580964970257765]
drlTanhRewards3 = [-0.17617264919621228, -0.1759911894273128, -0.17526455026455026, -0.17544633017412387, -0.1759911894273128, -0.17580964970257765, -0.17526455026455026, -0.1759911894273128, -0.17526455026455026, -0.1759911894273128, -0.17580964970257765, -0.17544633017412387]
drlTanhRewards4 = [-0.1778021978021978, -0.17526455026455026, -0.17526455026455026, -0.17617264919621228, -0.17562802996914942, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765]
drlTanhRewards5 = [-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.1759911894273128, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17617264919621228, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.177078750549934]
drlTanhRewards6 = [-0.17508269018743108, -0.17617264919621228, -0.17526455026455026, -0.1749007498897221, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.1759911894273128, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17544633017412387]
drlTanhRewards7 = [-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17562802996914942, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17562802996914942]
drlTanhRewards8 = [-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17617264919621228, -0.17508269018743108, -0.17617264919621228, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026]
drlTanhRewards9 = [-0.1749007498897221, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17617264919621228, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.1749007498897221, -0.17580964970257765, -0.17526455026455026]
drlTanhRewards10 = [-0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17562802996914942, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drlTanhRewards11 = [-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026]
drlTanhRewards12 = [-0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.1759911894273128, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026]
drlTanhRewards13 = [-0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17617264919621228, -0.17544633017412387, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108]
drlTanhRewards14 = [-0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.1749007498897221]
drlTanhRewards15 = [-0.1759911894273128, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17562802996914942, -0.1763540290620872, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.1759911894273128]
drlTanhRewards16 = [-0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17544633017412387]
drlTanhRewards17 = [-0.17617264919621228, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108]
drlTanhRewards18 = [-0.17562802996914942, -0.17617264919621228, -0.17580964970257765, -0.17562802996914942, -0.17544633017412387, -0.1759911894273128, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17544633017412387, -0.1759911894273128, -0.17580964970257765]
drlTanhRewards19 = [-0.17562802996914942, -0.17617264919621228, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17580964970257765, -0.17562802996914942, -0.17526455026455026]
drlTanhRewards20 = [-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.1759911894273128, -0.17580964970257765, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026]
drlTanhRewards21 = [-0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17562802996914942, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108]
drlTanhRewards22 = [-0.1759911894273128, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026]
drlTanhRewards23 = [-0.1759911894273128, -0.1759911894273128, -0.17544633017412387, -0.17544633017412387, -0.17526455026455026, -0.1759911894273128, -0.17544633017412387, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17544633017412387]
drlTanhRewards24 = [-0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17617264919621228, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765, -0.1759911894273128]
drlTanhRewards25 = [-0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17617264919621228, -0.17544633017412387, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026]
drlTanhRewards26 = [-0.17526455026455026, -0.17526455026455026, -0.1759911894273128, -0.17508269018743108, -0.17562802996914942, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765]
drlTanhRewards27 = [-0.17544633017412387, -0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17562802996914942, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108]
drlTanhRewards28 = [-0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17544633017412387, -0.17562802996914942, -0.17544633017412387, -0.17617264919621228, -0.17562802996914942, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards29 = [-0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228, -0.17562802996914942, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026]
drlTanhRewards30 = [-0.17580964970257765, -0.17562802996914942, -0.17526455026455026, -0.1759911894273128, -0.17562802996914942, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.17562802996914942, -0.17617264919621228, -0.17508269018743108, -0.17544633017412387]
drlTanhRewards31 = [-0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17508269018743108, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765]
drlTanhRewards32 = [-0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026]
drlTanhRewards33 = [-0.17508269018743108, -0.17562802996914942, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026]
drlTanhRewards34 = [-0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards35 = [-0.17544633017412387, -0.17508269018743108, -0.17562802996914942, -0.1749007498897221, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards36 = [-0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards37 = [-0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224]
drlTanhRewards38 = [-0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards39 = [-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026]
drlTanhRewards40 = [-0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942, -0.17508269018743108]
drlTanhRewards41 = [-0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17562802996914942, -0.17526455026455026, -0.17526455026455026]
drlTanhRewards42 = [-0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drlTanhRewards43 = [-0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108]
drlTanhRewards44 = [-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards45 = [-0.1749007498897221, -0.17435444714191128, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17453662842012357, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards46 = [-0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drlTanhRewards47 = [-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.1749007498897221, -0.17526455026455026]
drlTanhRewards48 = [-0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17471872931833224, -0.17508269018743108, -0.17562802996914942, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026]
drlTanhRewards49 = [-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drlTanhRewards50 = [-0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108]
drlTanhRewards51 = [-0.17508269018743108, -0.17471872931833224, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards52 = [-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026, -0.17508269018743108]
drlTanhRewards53 = [-0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224]
drlTanhRewards54 = [-0.17526455026455026, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17544633017412387]
drlTanhRewards55 = [-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17471872931833224]
drlTanhRewards56 = [-0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026]
drlTanhRewards57 = [-0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17562802996914942, -0.17471872931833224, -0.17471872931833224]
drlTanhRewards58 = [-0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17471872931833224, -0.17471872931833224, -0.1749007498897221]
drlTanhRewards59 = [-0.17526455026455026, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17526455026455026]
drlTanhRewards60 = [-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224]
drlTanhRewards61 = [-0.17471872931833224, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17471872931833224, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026]
drlTanhRewards62 = [-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1759911894273128, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221]
drlTanhRewards63 = [-0.17453662842012357, -0.17471872931833224, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17526455026455026, -0.1749007498897221, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108]
# Deep Reinforcement Learning: 5 capas Dense, Funcion de activacion relu, 12 episodios, 50 iteraciones
drlReluMakespan0 = [796, 798, 809, 798, 796, 800, 798, 799, 800, 794, 800, 798]
drlReluMakespan1 = [800, 800, 801, 806, 804, 806, 808, 798, 796, 796, 798, 800]
drlReluMakespan2 = [805, 805, 798, 800, 800, 798, 801, 799, 800, 806, 800, 800]
drlReluMakespan3 = [798, 799, 798, 795, 798, 808, 803, 800, 798, 795, 799, 800]
drlReluMakespan4 = [805, 805, 799, 796, 798, 803, 799, 800, 800, 800, 795, 794]
drlReluMakespan5 = [799, 796, 795, 800, 801, 796, 800, 795, 803, 800, 800, 805]
drlReluMakespan6 = [799, 795, 798, 794, 805, 796, 795, 799, 798, 795, 804, 796]
drlReluMakespan7 = [795, 798, 799, 798, 798, 799, 795, 794, 796, 794, 795, 805]
drlReluMakespan8 = [805, 794, 794, 795, 798, 795, 798, 795, 799, 800, 796, 798]
drlReluMakespan9 = [797, 797, 797, 794, 795, 794, 794, 797, 796, 795, 801, 799]
drlReluMakespan10 = [799, 794, 797, 795, 794, 794, 795, 795, 795, 796, 797, 799]
drlReluMakespan11 = [796, 798, 800, 795, 805, 794, 798, 796, 795, 794, 798, 795]
drlReluMakespan12 = [800, 795, 794, 798, 800, 805, 800, 798, 804, 799, 794, 803]
drlReluMakespan13 = [796, 799, 798, 794, 800, 794, 795, 796, 798, 795, 794, 799]
drlReluMakespan14 = [795, 798, 798, 798, 805, 798, 798, 798, 795, 794, 800, 796]
drlReluMakespan15 = [795, 798, 795, 805, 798, 794, 795, 798, 796, 794, 795, 796]
drlReluMakespan16 = [798, 795, 796, 799, 796, 798, 798, 795, 795, 795, 795, 799]
drlReluMakespan17 = [794, 798, 796, 798, 795, 801, 794, 798, 797, 795, 796, 801]
drlReluMakespan18 = [798, 795, 798, 798, 801, 798, 795, 795, 797, 800, 794, 800]
drlReluMakespan19 = [795, 798, 794, 800, 796, 795, 798, 797, 795, 794, 796, 796]
drlReluMakespan20 = [794, 794, 795, 795, 795, 795, 796, 798, 799, 799, 799, 795]
drlReluMakespan21 = [802, 796, 794, 797, 797, 800, 794, 794, 804, 803, 798, 797]
drlReluMakespan22 = [794, 795, 795, 795, 798, 795, 794, 799, 794, 803, 795, 794]
drlReluMakespan23 = [794, 798, 799, 794, 795, 795, 799, 795, 796, 795, 797, 799]
drlReluMakespan24 = [795, 794, 797, 800, 794, 795, 795, 795, 795, 800, 800, 798]
drlReluMakespan25 = [795, 794, 797, 796, 798, 795, 795, 794, 799, 795, 794, 798]
drlReluMakespan26 = [801, 795, 800, 794, 794, 796, 800, 798, 798, 799, 794, 796]
drlReluMakespan27 = [796, 795, 796, 795, 796, 795, 795, 800, 794, 794, 794, 796]
drlReluMakespan28 = [794, 794, 795, 796, 794, 795, 795, 797, 794, 794, 796, 795]
drlReluMakespan29 = [793, 794, 795, 800, 795, 795, 794, 798, 798, 796, 795, 794]
drlReluMakespan30 = [802, 794, 794, 798, 794, 796, 805, 794, 800, 794, 796, 794]
drlReluMakespan31 = [797, 794, 794, 794, 800, 800, 794, 794, 798, 795, 794, 798]
drlReluMakespan32 = [794, 798, 794, 795, 794, 795, 798, 794, 794, 795, 794, 798]
drlReluMakespan33 = [798, 794, 798, 795, 794, 793, 797, 798, 794, 794, 801, 793]
drlReluMakespan34 = [794, 798, 794, 795, 794, 793, 798, 795, 794, 800, 794, 795]
drlReluMakespan35 = [794, 796, 794, 796, 806, 795, 795, 795, 796, 795, 795, 799]
drlReluMakespan36 = [795, 794, 794, 796, 796, 798, 794, 796, 794, 795, 794, 795]
drlReluMakespan37 = [795, 794, 795, 798, 794, 794, 794, 794, 794, 794, 795, 797]
drlReluMakespan38 = [794, 798, 794, 798, 797, 794, 794, 795, 795, 794, 795, 795]
drlReluMakespan39 = [797, 794, 795, 796, 796, 796, 798, 794, 794, 795, 794, 798]
drlReluMakespan40 = [798, 795, 795, 798, 792, 795, 795, 794, 795, 794, 798, 794]
drlReluMakespan41 = [795, 794, 794, 794, 794, 794, 798, 793, 794, 794, 794, 793]
drlReluMakespan42 = [794, 794, 794, 794, 799, 794, 795, 794, 796, 794, 794, 794]
drlReluMakespan43 = [794, 797, 795, 794, 795, 794, 794, 795, 794, 794, 793, 794]
drlReluMakespan44 = [794, 792, 793, 794, 794, 796, 794, 798, 795, 794, 794, 796]
drlReluMakespan45 = [795, 794, 799, 794, 794, 793, 794, 795, 795, 793, 796, 794]
drlReluMakespan46 = [794, 796, 794, 794, 794, 794, 794, 793, 799, 792, 794, 794]
drlReluMakespan47 = [795, 794, 793, 794, 796, 797, 794, 794, 795, 794, 794, 794]
drlReluMakespan48 = [794, 794, 794, 792, 794, 794, 795, 794, 794, 794, 794, 794]
drlReluMakespan49 = [794, 794, 795, 792, 797, 797, 794, 794, 792, 800, 795, 795]
drlReluRewards0 = [-0.17544633017412387, -0.17580964970257765, -0.1778021978021978, -0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.17580964970257765, -0.1759911894273128, -0.17508269018743108, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765]
drlReluRewards1 = [-0.17617264919621228, -0.17617264919621228, -0.1763540290620872, -0.17725973169122497, -0.1768976897689769, -0.17725973169122497, -0.1776214552648934, -0.17580964970257765, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17617264919621228]
drlReluRewards2 = [-0.177078750549934, -0.177078750549934, -0.17580964970257765, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765, -0.1763540290620872, -0.1759911894273128, -0.17617264919621228, -0.17725973169122497, -0.17617264919621228, -0.17617264919621228]
drlReluRewards3 = [-0.17580964970257765, -0.1759911894273128, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.1776214552648934, -0.17671654929577466, -0.17617264919621228, -0.17580964970257765, -0.17526455026455026, -0.1759911894273128, -0.17617264919621228]
drlReluRewards4 = [-0.177078750549934, -0.177078750549934, -0.1759911894273128, -0.17544633017412387, -0.17580964970257765, -0.17671654929577466, -0.1759911894273128, -0.17617264919621228, -0.17617264919621228, -0.17617264919621228, -0.17526455026455026, -0.17508269018743108]
drlReluRewards5 = [-0.1759911894273128, -0.17544633017412387, -0.17526455026455026, -0.17617264919621228, -0.1763540290620872, -0.17544633017412387, -0.17526455026455026, -0.17617264919621228, -0.17671654929577466, -0.17617264919621228, -0.17617264919621228, -0.177078750549934]
drlReluRewards6 = [-0.1759911894273128, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108, -0.177078750549934, -0.17544633017412387, -0.17526455026455026, -0.1759911894273128, -0.17580964970257765, -0.17526455026455026, -0.1768976897689769, -0.17544633017412387]
drlReluRewards7 = [-0.17526455026455026, -0.1759911894273128, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.177078750549934]
drlReluRewards8 = [-0.177078750549934, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.1759911894273128, -0.17617264919621228, -0.17544633017412387, -0.17580964970257765]
drlReluRewards9 = [-0.17562802996914942, -0.17562802996914942, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17562802996914942, -0.17544633017412387, -0.17526455026455026, -0.1763540290620872, -0.1759911894273128]
drlReluRewards10 = [-0.1759911894273128, -0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17562802996914942, -0.1759911894273128]
drlReluRewards11 = [-0.17544633017412387, -0.17580964970257765, -0.17617264919621228, -0.17526455026455026, -0.177078750549934, -0.17508269018743108, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026]
drlReluRewards12 = [-0.17617264919621228, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17617264919621228, -0.177078750549934, -0.17617264919621228, -0.17580964970257765, -0.1768976897689769, -0.1759911894273128, -0.17508269018743108, -0.17671654929577466]
drlReluRewards13 = [-0.17544633017412387, -0.1759911894273128, -0.17580964970257765, -0.17508269018743108, -0.17617264919621228, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.1759911894273128]
drlReluRewards14 = [-0.17526455026455026, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.177078750549934, -0.17580964970257765, -0.17580964970257765, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17617264919621228, -0.17544633017412387]
drlReluRewards15 = [-0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.177078750549934, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17544633017412387, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387]
drlReluRewards16 = [-0.17580964970257765, -0.17526455026455026, -0.17544633017412387, -0.1759911894273128, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.1759911894273128]
drlReluRewards17 = [-0.17508269018743108, -0.17580964970257765, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.1763540290620872, -0.17508269018743108, -0.17580964970257765, -0.17562802996914942, -0.17526455026455026, -0.17544633017412387, -0.1763540290620872]
drlReluRewards18 = [-0.17580964970257765, -0.17526455026455026, -0.17580964970257765, -0.17580964970257765, -0.1763540290620872, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17617264919621228, -0.17508269018743108, -0.17617264919621228]
drlReluRewards19 = [-0.17526455026455026, -0.17580964970257765, -0.17508269018743108, -0.17617264919621228, -0.17544633017412387, -0.17526455026455026, -0.17580964970257765, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17544633017412387]
drlReluRewards20 = [-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17580964970257765, -0.1759911894273128, -0.1759911894273128, -0.1759911894273128, -0.17526455026455026]
drlReluRewards21 = [-0.17653532907770195, -0.17544633017412387, -0.17562802996914942, -0.17508269018743108, -0.17562802996914942, -0.17617264919621228, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.1768976897689769, -0.17671654929577466, -0.17562802996914942]
drlReluRewards22 = [-0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.1759911894273128, -0.17508269018743108, -0.17671654929577466, -0.17526455026455026, -0.17508269018743108]
drlReluRewards23 = [-0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.1759911894273128, -0.17508269018743108, -0.17526455026455026, -0.1759911894273128, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17562802996914942, -0.1759911894273128]
drlReluRewards24 = [-0.17526455026455026, -0.17508269018743108, -0.17562802996914942, -0.17617264919621228, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17617264919621228, -0.17617264919621228, -0.17580964970257765]
drlReluRewards25 = [-0.17526455026455026, -0.17508269018743108, -0.17562802996914942, -0.17544633017412387, -0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.1759911894273128, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765]
drlReluRewards26 = [-0.1763540290620872, -0.17526455026455026, -0.17617264919621228, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17617264919621228, -0.17580964970257765, -0.17580964970257765, -0.1759911894273128, -0.17508269018743108, -0.17544633017412387]
drlReluRewards27 = [-0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17617264919621228, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387]
drlReluRewards28 = [-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026]
drlReluRewards29 = [-0.1749007498897221, -0.17526455026455026, -0.17508269018743108, -0.17617264919621228, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17580964970257765, -0.17544633017412387, -0.17526455026455026, -0.17508269018743108]
drlReluRewards30 = [-0.17653532907770195, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17544633017412387, -0.177078750549934, -0.17508269018743108, -0.17617264919621228, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108]
drlReluRewards31 = [-0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17617264919621228, -0.17617264919621228, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108, -0.17580964970257765]
drlReluRewards32 = [-0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765]
drlReluRewards33 = [-0.17580964970257765, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.17562802996914942, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.1763540290620872, -0.1749007498897221]
drlReluRewards34 = [-0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17617264919621228, -0.17508269018743108, -0.17526455026455026]
drlReluRewards35 = [-0.17508269018743108, -0.17544633017412387, -0.17725973169122497, -0.17508269018743108, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.17526455026455026, -0.17544633017412387, -0.17526455026455026, -0.17526455026455026, -0.1759911894273128]
drlReluRewards36 = [-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026]
drlReluRewards37 = [-0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17562802996914942]
drlReluRewards38 = [-0.17508269018743108, -0.17580964970257765, -0.17508269018743108, -0.17580964970257765, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026]
drlReluRewards39 = [-0.17562802996914942, -0.17508269018743108, -0.17526455026455026, -0.17544633017412387, -0.17544633017412387, -0.17544633017412387, -0.17580964970257765, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765]
drlReluRewards40 = [-0.17580964970257765, -0.17526455026455026, -0.17526455026455026, -0.17580964970257765, -0.17471872931833224, -0.17526455026455026, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17580964970257765, -0.17508269018743108]
drlReluRewards41 = [-0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17580964970257765, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221]
drlReluRewards42 = [-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1759911894273128, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drlReluRewards43 = [-0.17508269018743108, -0.17562802996914942, -0.17526455026455026, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108]
drlReluRewards44 = [-0.17508269018743108, -0.17471872931833224, -0.1749007498897221, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17580964970257765, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17544633017412387]
drlReluRewards45 = [-0.17526455026455026, -0.17508269018743108, -0.1759911894273128, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17526455026455026, -0.17526455026455026, -0.1749007498897221, -0.17544633017412387, -0.17508269018743108]
drlReluRewards46 = [-0.17508269018743108, -0.17544633017412387, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.1749007498897221, -0.1759911894273128, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108]
drlReluRewards47 = [-0.17526455026455026, -0.17508269018743108, -0.1749007498897221, -0.17508269018743108, -0.17544633017412387, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drlReluRewards48 = [-0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108, -0.17508269018743108]
drlReluRewards49 = [-0.17508269018743108, -0.17508269018743108, -0.17526455026455026, -0.17471872931833224, -0.17562802996914942, -0.17562802996914942, -0.17508269018743108, -0.17508269018743108, -0.17471872931833224, -0.17617264919621228, -0.17526455026455026, -0.17526455026455026]
if __name__ == "__main__":
##############################################
##############################################
##############################################
# Deep Recurrent Reinforcement Learning with 1 GRU layer and 4 Dense layers
drnnGRUtanhMakespan = []
drnnGRUtanhRewards = []
drnnGRUtanhMakespanList = []
drnnGRUtanhRewardsList = []
drnnGRUtanhMakespanValues = []
drnnGRUtanhRewardsValues = []
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan0))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan1))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan2))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan3))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan4))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan5))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan6))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan7))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan8))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan9))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan10))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan11))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan12))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan13))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan14))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan15))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan16))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan17))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan18))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan19))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan20))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan21))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan22))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan23))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan24))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan25))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan26))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan27))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan28))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan29))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan30))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan31))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan32))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan33))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan34))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan35))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan36))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan37))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan38))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan39))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan40))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan41))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan42))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan43))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan44))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan45))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan46))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan47))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan48))
drnnGRUtanhMakespan.append(np.mean(drnnGRUtanhMakespan49))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards0))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards1))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards2))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards3))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards4))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards5))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards6))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards7))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards8))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards9))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards10))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards11))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards12))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards13))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards14))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards15))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards16))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards17))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards18))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards19))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards20))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards21))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards22))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards23))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards24))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards25))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards26))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards27))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards28))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards29))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards30))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards31))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards32))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards33))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards34))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards35))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards36))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards37))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards38))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards39))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards40))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards41))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards42))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards43))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards44))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards45))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards46))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards47))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards48))
drnnGRUtanhRewards.append(np.mean(drnnGRUtanhRewards49))
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan0)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan1)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan2)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan3)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan4)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan5)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan6)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan7)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan8)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan9)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan10)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan11)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan12)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan13)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan14)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan15)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan16)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan17)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan18)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan19)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan20)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan21)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan22)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan23)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan24)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan25)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan26)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan27)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan28)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan29)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan30)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan31)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan32)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan33)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan34)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan35)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan36)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan37)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan38)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan39)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan40)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan41)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan42)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan43)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan44)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan45)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan46)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan47)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan48)
drnnGRUtanhMakespanList.append(drnnGRUtanhMakespan49)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards0)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards1)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards2)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards3)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards4)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards5)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards6)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards7)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards8)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards9)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards10)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards11)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards12)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards13)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards14)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards15)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards16)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards17)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards18)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards19)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards20)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards21)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards22)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards23)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards24)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards25)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards26)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards27)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards28)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards29)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards30)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards31)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards32)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards33)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards34)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards35)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards36)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards37)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards38)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards39)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards40)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards41)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards42)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards43)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards44)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards45)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards46)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards47)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards48)
drnnGRUtanhRewardsList.append(drnnGRUtanhRewards49)
drnnGRUreluMakespan = []
drnnGRUreluRewards = []
drnnGRUreluMakespanList = []
drnnGRUreluRewardsList = []
drnnGRUreluMakespanValues = []
drnnGRUreluRewardsValues = []
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan0))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan1))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan2))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan3))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan4))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan5))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan6))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan7))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan8))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan9))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan10))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan11))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan12))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan13))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan14))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan15))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan16))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan17))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan18))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan19))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan20))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan21))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan22))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan23))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan24))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan25))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan26))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan27))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan28))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan29))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan30))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan31))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan32))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan33))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan34))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan35))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan36))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan37))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan38))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan39))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan40))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan41))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan42))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan43))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan44))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan45))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan46))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan47))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan48))
drnnGRUreluMakespan.append(np.mean(drnnGRUreluMakespan49))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards0))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards1))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards2))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards3))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards4))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards5))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards6))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards7))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards8))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards9))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards10))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards11))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards12))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards13))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards14))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards15))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards16))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards17))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards18))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards19))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards20))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards21))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards22))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards23))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards24))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards25))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards26))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards27))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards28))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards29))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards30))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards31))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards32))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards33))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards34))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards35))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards36))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards37))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards38))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards39))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards40))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards41))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards42))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards43))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards44))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards45))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards46))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards47))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards48))
drnnGRUreluRewards.append(np.mean(drnnGRUreluRewards49))
drnnGRUreluMakespanList.append(drnnGRUreluMakespan0)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan1)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan2)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan3)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan4)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan5)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan6)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan7)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan8)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan9)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan10)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan11)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan12)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan13)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan14)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan15)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan16)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan17)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan18)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan19)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan20)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan21)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan22)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan23)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan24)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan25)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan26)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan27)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan28)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan29)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan30)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan31)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan32)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan33)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan34)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan35)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan36)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan37)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan38)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan39)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan40)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan41)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan42)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan43)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan44)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan45)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan46)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan47)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan48)
drnnGRUreluMakespanList.append(drnnGRUreluMakespan49)
drnnGRUreluRewardsList.append(drnnGRUreluRewards0)
drnnGRUreluRewardsList.append(drnnGRUreluRewards1)
drnnGRUreluRewardsList.append(drnnGRUreluRewards2)
drnnGRUreluRewardsList.append(drnnGRUreluRewards3)
drnnGRUreluRewardsList.append(drnnGRUreluRewards4)
drnnGRUreluRewardsList.append(drnnGRUreluRewards5)
drnnGRUreluRewardsList.append(drnnGRUreluRewards6)
drnnGRUreluRewardsList.append(drnnGRUreluRewards7)
drnnGRUreluRewardsList.append(drnnGRUreluRewards8)
drnnGRUreluRewardsList.append(drnnGRUreluRewards9)
drnnGRUreluRewardsList.append(drnnGRUreluRewards10)
drnnGRUreluRewardsList.append(drnnGRUreluRewards11)
drnnGRUreluRewardsList.append(drnnGRUreluRewards12)
drnnGRUreluRewardsList.append(drnnGRUreluRewards13)
drnnGRUreluRewardsList.append(drnnGRUreluRewards14)
drnnGRUreluRewardsList.append(drnnGRUreluRewards15)
drnnGRUreluRewardsList.append(drnnGRUreluRewards16)
drnnGRUreluRewardsList.append(drnnGRUreluRewards17)
drnnGRUreluRewardsList.append(drnnGRUreluRewards18)
drnnGRUreluRewardsList.append(drnnGRUreluRewards19)
drnnGRUreluRewardsList.append(drnnGRUreluRewards20)
drnnGRUreluRewardsList.append(drnnGRUreluRewards21)
drnnGRUreluRewardsList.append(drnnGRUreluRewards22)
drnnGRUreluRewardsList.append(drnnGRUreluRewards23)
drnnGRUreluRewardsList.append(drnnGRUreluRewards24)
drnnGRUreluRewardsList.append(drnnGRUreluRewards25)
drnnGRUreluRewardsList.append(drnnGRUreluRewards26)
drnnGRUreluRewardsList.append(drnnGRUreluRewards27)
drnnGRUreluRewardsList.append(drnnGRUreluRewards28)
drnnGRUreluRewardsList.append(drnnGRUreluRewards29)
drnnGRUreluRewardsList.append(drnnGRUreluRewards30)
drnnGRUreluRewardsList.append(drnnGRUreluRewards31)
drnnGRUreluRewardsList.append(drnnGRUreluRewards32)
drnnGRUreluRewardsList.append(drnnGRUreluRewards33)
drnnGRUreluRewardsList.append(drnnGRUreluRewards34)
drnnGRUreluRewardsList.append(drnnGRUreluRewards35)
drnnGRUreluRewardsList.append(drnnGRUreluRewards36)
drnnGRUreluRewardsList.append(drnnGRUreluRewards37)
drnnGRUreluRewardsList.append(drnnGRUreluRewards38)
drnnGRUreluRewardsList.append(drnnGRUreluRewards39)
drnnGRUreluRewardsList.append(drnnGRUreluRewards40)
drnnGRUreluRewardsList.append(drnnGRUreluRewards41)
drnnGRUreluRewardsList.append(drnnGRUreluRewards42)
drnnGRUreluRewardsList.append(drnnGRUreluRewards43)
drnnGRUreluRewardsList.append(drnnGRUreluRewards44)
drnnGRUreluRewardsList.append(drnnGRUreluRewards45)
drnnGRUreluRewardsList.append(drnnGRUreluRewards46)
drnnGRUreluRewardsList.append(drnnGRUreluRewards47)
drnnGRUreluRewardsList.append(drnnGRUreluRewards48)
drnnGRUreluRewardsList.append(drnnGRUreluRewards49)
for vector in drnnGRUtanhMakespanList:
for element in vector:
drnnGRUtanhMakespanValues.append(element)
for vector in drnnGRUtanhRewardsList:
for element in vector:
drnnGRUtanhRewardsValues.append(element)
##################
for vector in drnnGRUreluMakespanList:
for element in vector:
drnnGRUreluMakespanValues.append(element)
for vector in drnnGRUreluRewardsList:
for element in vector:
drnnGRUreluRewardsValues.append(element)
#####################
smoothGRUtanhMakespanValues = pd.Series(drnnGRUtanhMakespanValues).rolling(12).mean()
plt.plot(smoothGRUtanhMakespanValues)
plt.xlabel("Episodios")
plt.ylabel("Segundos")
plt.title("'Makespan' con red neuronal profunda que incluye 1 capa GRU")
plt.show()
smoothGRUtanhRewardsValues = pd.Series(drnnGRUtanhRewardsValues).rolling(12).mean()
plt.plot(smoothGRUtanhRewardsValues)
plt.xlabel("Episodios")
plt.ylabel("Premio")
plt.title("'Reward' con red neuronal profunda que incluye 1 capa GRU")
plt.show()
#####################
smoothGRUreluMakespanValues = pd.Series(drnnGRUreluMakespanValues).rolling(12).mean()
plt.plot(smoothGRUreluMakespanValues)
plt.xlabel("Episodios")
plt.ylabel("Segundos")
plt.title("'Makespan' con red neuronal profunda que incluye 1 capa GRU y ReLU")
plt.show()
smoothGRUreluRewardsValues = pd.Series(drnnGRUreluRewardsValues).rolling(12).mean()
plt.plot(smoothGRUreluRewardsValues)
plt.xlabel("Episodios")
plt.ylabel("Premio")
plt.title("'Reward' con red neuronal profunda que incluye 1 capa GRU y ReLU")
plt.show()
###################
plt.plot(smoothGRUtanhMakespanValues, color='blue', label='tanh')
plt.plot(smoothGRUreluMakespanValues, color='orange', label='relu')
plt.xlabel("Episodios")
plt.ylabel("Segundos")
plt.title("'Makespan' con red neuronal profunda que incluye 1 capa GRU")
plt.legend()
plt.show()
###################
plt.plot(smoothGRUtanhRewardsValues, color='blue', label='tanh')
plt.plot(smoothGRUreluRewardsValues, color='orange', label='relu')
plt.xlabel("Episodios")
plt.ylabel("Premio")
plt.title("'Reward' con red neuronal profunda que incluye 1 capa GRU")
plt.legend()
plt.show()
###################
drnnLSTMtanhMakespan = []
drnnLSTMtanhRewards = []
drnnLSTMtanhMakespanList = []
drnnLSTMtanhRewardsList = []
drnnLSTMtanhMakespanValues = []
drnnLSTMtanhRewardsValues = []
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan0))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan1))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan2))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan3))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan4))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan5))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan6))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan7))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan8))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan9))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan10))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan11))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan12))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan13))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan14))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan15))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan16))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan17))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan18))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan19))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan20))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan21))
drnnLSTMtanhMakespan.append(np.mean(drnnLSTMtanhMakespan22))
drnnLSTMtanhMakespan.append( | np.mean(drnnLSTMtanhMakespan23) | numpy.mean |
import argparse
import cv2
import numpy as np
import torch
from torch.autograd import Function
from torchvision import models
import torch.nn as nn
from model import *
import matplotlib.pyplot as plt
class FeatureExtractor():
""" Class for extracting activations and
registering gradients from targetted intermediate layers """
def __init__(self, model, target_layers):
self.model = model
self.target_layers = target_layers
self.gradients = []
def save_gradient(self, grad):
self.gradients.append(grad)
def __call__(self, x):
outputs = []
self.gradients = []
for name, module in self.model._modules.items():
x = module(x)
if name in self.target_layers:
x.register_hook(self.save_gradient)
outputs += [x]
return outputs, x
class ModelOutputs():
""" Class for making a forward pass, and getting:
1. The network output.
2. Activations from intermeddiate targetted layers.
3. Gradients from intermeddiate targetted layers. """
def __init__(self, model, target_layers):
self.model = model
self.feature_extractor = FeatureExtractor(self.model.features, target_layers)
def get_gradients(self):
return self.feature_extractor.gradients
def __call__(self, x):
target_activations, output = self.feature_extractor(x)
output = output.view(output.size(0), -1)
output = self.model.classifier(output)
return target_activations, output
def preprocess_image(img):
means = [0.485, 0.456, 0.406]
stds = [0.229, 0.224, 0.225]
preprocessed_img = img.copy()[:, :, ::-1]
for i in range(3):
preprocessed_img[:, :, i] = preprocessed_img[:, :, i] - means[i]
preprocessed_img[:, :, i] = preprocessed_img[:, :, i] / stds[i]
preprocessed_img = \
np.ascontiguousarray(np.transpose(preprocessed_img, (2, 0, 1)))
preprocessed_img = torch.from_numpy(preprocessed_img)
preprocessed_img.unsqueeze_(0)
input = preprocessed_img.requires_grad_(True)
return input
def show_cam_on_image(img, mask):
heatmap = cv2.applyColorMap(np.uint8(255 * mask), cv2.COLORMAP_JET)
heatmap = np.float32(heatmap) / 255
cam = heatmap + np.float32(img)
cam = cam / np.max(cam)
print("Cam Shape" , cam.shape)
fig = plt.figure()
cam = cv2.cvtColor(cam, cv2.COLOR_RGB2BGR)
plt.axis("off")
plt.imshow(cam)
plt.show()
fig.savefig("People_class_GC_1.png", transparent=True)
class GradCam:
def __init__(self, model, target_layer_names, use_cuda):
self.model = model
self.model.eval()
self.cuda = use_cuda
if self.cuda:
self.model = model.cuda()
self.extractor = ModelOutputs(self.model, target_layer_names)
def forward(self, input):
return self.model(input)
def __call__(self, input, index=None):
if self.cuda:
features, output = self.extractor(input.cuda())
else:
features, output = self.extractor(input)
if index == None:
index = np.argmax(output.cpu().data.numpy())
one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)
one_hot[0][index] = 1
one_hot = torch.from_numpy(one_hot).requires_grad_(True)
if self.cuda:
one_hot = torch.sum(one_hot.cuda() * output)
else:
one_hot = torch.sum(one_hot * output)
self.model.features.zero_grad()
self.model.classifier.zero_grad()
one_hot.backward(retain_graph=True)
grads_val = self.extractor.get_gradients()[-1].cpu().data.numpy()
target = features[-1]
target = target.cpu().data.numpy()[0, :]
weights = np.mean(grads_val, axis=(2, 3))[0, :]
cam = np.zeros(target.shape[1:], dtype=np.float32)
for i, w in enumerate(weights):
cam += w * target[i, :, :]
cam = np.maximum(cam, 0)
cam = cv2.resize(cam, (224, 224))
cam = cam - np.min(cam)
cam = cam / np.max(cam)
return cam
class GuidedBackpropReLU(Function):
@staticmethod
def forward(self, input):
positive_mask = (input > 0).type_as(input)
output = torch.addcmul(torch.zeros(input.size()).type_as(input), input, positive_mask)
self.save_for_backward(input, output)
return output
@staticmethod
def backward(self, grad_output):
input, output = self.saved_tensors
grad_input = None
positive_mask_1 = (input > 0).type_as(grad_output)
positive_mask_2 = (grad_output > 0).type_as(grad_output)
grad_input = torch.addcmul(torch.zeros(input.size()).type_as(input),
torch.addcmul(torch.zeros(input.size()).type_as(input), grad_output,
positive_mask_1), positive_mask_2)
return grad_input
class GuidedBackpropReLUModel:
def __init__(self, model, use_cuda):
self.model = model
self.model.eval()
self.cuda = use_cuda
if self.cuda:
self.model = model.cuda()
# replace ReLU with GuidedBackpropReLU
for idx, module in self.model.features._modules.items():
if module.__class__.__name__ == 'ReLU':
self.model.features._modules[idx] = GuidedBackpropReLU.apply
def forward(self, input):
return self.model(input)
def __call__(self, input, index=None):
if self.cuda:
output = self.forward(input.cuda())
else:
output = self.forward(input)
if index == None:
index = np.argmax(output.cpu().data.numpy())
one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)
one_hot[0][index] = 1
one_hot = torch.from_numpy(one_hot).requires_grad_(True)
if self.cuda:
one_hot = torch.sum(one_hot.cuda() * output)
else:
one_hot = torch.sum(one_hot * output)
# self.model.features.zero_grad()
# self.model.classifier.zero_grad()
one_hot.backward(retain_graph=True)
output = input.grad.cpu().data.numpy()
output = output[0, :, :, :]
return output
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument('--use-cuda', action='store_true', default=False,
help='Use NVIDIA GPU acceleration')
parser.add_argument('--image-path', type=str, default='./examples/both.png',
help='Input image path')
args = parser.parse_args()
args.use_cuda = args.use_cuda and torch.cuda.is_available()
if args.use_cuda:
print("Using GPU for acceleration")
else:
print("Using CPU for computation")
return args
def deprocess_image(img):
""" see https://github.com/jacobgil/keras-grad-cam/blob/master/grad-cam.py#L65 """
img = img - | np.mean(img) | numpy.mean |
"""
This file serves as a playground for understanding some of the concepts used
in the development of the DeepDream algorithm.
"""
import time
import os
import numpy as np
import scipy.ndimage as nd
import matplotlib.pyplot as plt
import torch
import cv2 as cv
from torchvision import transforms
from utils.constants import IMAGENET_MEAN_1, IMAGENET_STD_1
import utils.utils as utils
import utils.video_utils as video_utils
from deepdream import gradient_ascent
from models.definitions.vggs import Vgg16
# Note: don't use scipy.ndimage it's way slower than OpenCV
def understand_frame_transform():
"""
Pick different transform matrices here and see what they do.
"""
height, width, num_channels = [500, 500, 3]
s = 0.05
# Create a white square on the black background
img = np.zeros((height, width, num_channels))
img[100:400, 100:400] = 1.0
img_center = (width / 2, height / 2)
# Translation
tx, ty = [10, 5]
translation_matrix = np.asarray([[1., 0., tx],
[0., 1., ty],
[0., 0., 1.]])
# Rotation
deg = 10 # rotation in degrees
theta = (deg / 180) * np.pi # convert to radians
origin_rotation_matrix = np.asarray([[np.cos(theta), -np.sin(theta), 0],
[np.sin(theta), np.cos(theta), 0],
[0., 0., 1.]])
# Does a similar thing to above but returns 2x3 matrix so just append the last row
rotation_matrix = cv.getRotationMatrix2D(img_center, deg, scale=1.09)
full_rotation_matrix = np.vstack([rotation_matrix, np.asarray([0., 0., 1.])])
# Affine
pts1 = np.float32([[50, 50], [200, 50], [50, 200]])
pts2 = | np.float32([[10, 100], [200, 50], [100, 250]]) | numpy.float32 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: Austin
"""
import numpy as np
import threading
class GeneticAlgorithm:
"""
Class to help in testing Genetic Algorithms
Args:
gene_length => How many possible digits for each gene in a genome
genome_length => How many genes in each genome
pop_size => How many genomes in the population (default=500)
x_rate => Percent chance of performing crossover after parents selected (default=0.9)
mutation_rate => Percent chance of performing mutation on any given gene in a selected genome (default=0.005)
parent_selection_method => Method used for performing parent-selection… (default='roulette')
'roulette': Choose 2 parents at random where each genome's probability of being chosen is equal to its fitness / total of all fitnesses
'rank': Choose 2 parents at random where each genome's probability of being chosen is equal to its index after sorted by best fitness / the sum of all ranks
'tournament': Randomly select k genomes choose the one with the highest fitness (done twice, to get two parents)
'random': Randomly select 2 genomes at a time
k_tournament_select => Number of genomes in a tournament, when using tournament selection (default=3)
xover_type => Type of crossover to use… (default='one_point')
'one_point': Pick one split point and swap the following two segments
'two_point': Pick two split points and swap the two middle segments
'uniform': At each gene, "flip a coin" to decide weather or not to crossover genes at that point
mutation_type => One of the following options… (default='random_resetting')
'random_resetting': Randomly set mutated gene to another number
'swap_mutation': Pick two genes in a genome to swap
'scramble_mutation': Randomly shuffle a subset of the genome
'inversion_mutation': Invert the genome
elitism => What percent of the population (or number of genomes) to preserve unchanged for the next round. (default=0.05)
random_seed => Set the random seed (default=None)
multithread => Use multithreading for calculating population fitness (default=False)
Example:
1. Instantiate your genetic algorithm
>>> ga = GeneticAlgorithm(2, 30, 500, x_rate=0.9, mutation_rate=0.005, xover_type='two_point')
2. Redefine the fitness function
>>> def fitness(genome):
... return genome.sum()
>>> ga.fitness = fitness
3. Run the GA
>>> ga.run(500, print_step=5, logfile='logtest.csv', stop_value=30, stop_measure='max')
4. Get the best genomes
>>> best_genomes = ga.get_current_population()
"""
def __init__(self, gene_length, genome_length, pop_size=500, x_rate=0.9, mutation_rate=0.005, parent_selection_method='roulette', k_tournament_select=3, xover_type='one_point', mutation_type='random_resetting', elitism=0.05, random_seed=None, multithread=False):
# Settings
self.gene_length = gene_length
self.genome_length = genome_length
self.pop_size = pop_size
self.x_rate = x_rate
self.mutation_rate = mutation_rate
if 0 < elitism < 1:
self.elitism = int(np.round(elitism * pop_size))
else:
self.elitism = elitism
self.population = None
self.pop_fitness = None
self.generation = 0
self.max_fitness = None
self.avg_fitness = None
self.std_fitness = None
self.min_fitness = None
np.random.seed(random_seed)
self.multithread = multithread
# Set crossover method
assert xover_type in ['one_point', 'two_point', 'uniform'],\
"xover_type must be one of the following: 'one_point', 'two_point', 'uniform'"
if xover_type == 'one_point':
self.crossover = self.one_point_xover
elif xover_type == 'two_point':
self.crossover = self.two_point_xover
elif xover_type == 'uniform':
self.crossover = self.uniform_xover
self.xover_type = xover_type
# Set method of parent selection
assert parent_selection_method in ['roulette', 'rank', 'tournament', 'random'],\
"selection_type must be one of the following: 'roulette', 'rank', 'tournament', 'random'"
if parent_selection_method == 'roulette':
self.parent_selection = self.roulette_selection
elif parent_selection_method == 'rank':
self.parent_selection = self.rank_selection
elif parent_selection_method == 'tournament':
self.parent_selection = self.tournament_selection
elif parent_selection_method == 'random':
self.parent_selection = self.random_selection
self.parent_selection_method = parent_selection_method
self.k_tournament_select = k_tournament_select
# Set mutation method
assert mutation_type in ['random_resetting', 'swap_mutation', 'scramble_mutation', 'inversion_mutation'], \
"mutation_type must be one of the following: 'random_resetting', 'swap_mutation', 'scramble_mutation', 'inversion_mutation'"
if mutation_type == 'random_resetting':
self.mutate = self.random_mutation
elif mutation_type == 'swap_mutation':
self.mutate = self.swap_mutation
elif mutation_type == 'scramble_mutation':
self.mutate = self.scramble_mutation
elif mutation_type == 'inversion_mutation':
self.mutate = self.inversion_mutation
self.mutation_type = mutation_type
return
def random_genome(self):
return np.random.randint(self.gene_length, size=(self.genome_length,))
def make_population(self):
return np.array([self.random_genome() for _ in range(self.pop_size)])
def fitness(self, genome):
"""Replace this function with a user-defined fitness function."""
raise FitnessUndefinedError
return
def place_fitness(self, a, i, genome):
a[i] = self.fitness(genome)
return
def evaluate_pop_fitness(self):
try:
assert self.population is not None
except:
raise NoPopulationError
if self.multithread:
fitnesses = np.zeros(len(self.population))
threads = []
for i, g in enumerate(self.population):
threads.append(threading.Thread(target=self.place_fitness, args=(fitnesses, i, g)))
for t in threads:
t.start()
for t in threads:
t.join()
else:
fitnesses = np.array([self.fitness(g) for g in self.population])
# Set current fitness metrics
self.max_fitness = fitnesses.max()
self.avg_fitness = fitnesses.mean()
self.std_fitness = fitnesses.std()
self.min_fitness = fitnesses.min()
self.pop_fitness = fitnesses
return
def one_point_xover(self, g1, g2):
split = np.random.randint(1, self.genome_length-1)
new_g1 = np.concatenate((g1[:split], g2[split:]))
new_g2 = np.concatenate((g2[:split], g1[split:]))
return new_g1, new_g2
def two_point_xover(self, g1, g2):
start = | np.random.randint(0, self.genome_length-1) | numpy.random.randint |
import os
import random
import numpy as np
import scipy.io as sio
import matplotlib as mpl
mpl.use('agg')
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from collections import Counter
if __name__ == '__main__':
k = 20
random.seed(0)
plt.figure(figsize=(7.5, 3.5))
source_features_path = 'features/duke/gallery-duke2market-all-intra5-inter15-nomix-scale10_model_60.mat'
target_features_path = 'features/market/gallery-duke2market-all-intra5-inter15-nomix-scale10_model_60.mat'
print('Loading...')
source_mat = sio.loadmat(source_features_path)
target_mat = sio.loadmat(target_features_path)
print('Done!')
source_features = source_mat["feat"]
source_ids = source_mat["ids"].squeeze()
source_cam_ids = source_mat["cam_ids"].squeeze()
source_img_paths = source_mat['img_path']
target_features = target_mat["feat"]
target_ids = -target_mat["ids"].squeeze()
target_cam_ids = target_mat["cam_ids"].squeeze()
target_img_paths = target_mat['img_path']
s_counter = Counter(source_ids)
t_counter = Counter(target_ids)
s_select_ids = []
t_select_ids = []
for idx, num in s_counter.items():
if 30 < num < 50 and idx not in [0, -1]:
s_select_ids.append(idx)
for idx, num in t_counter.items():
if 30 < num < 50 and idx not in [0, -1]:
t_select_ids.append(idx)
assert len(s_select_ids) >= k
assert len(t_select_ids) >= k
s_select_ids = random.sample(s_select_ids, k)
t_select_ids = random.sample(t_select_ids, k)
s_flags = np.in1d(source_ids, s_select_ids)
t_flags = np.in1d(target_ids, t_select_ids)
s_ids = source_ids[s_flags]
t_ids = target_ids[t_flags]
ids = np.concatenate([s_ids, t_ids], axis=0).tolist()
id_map = dict(zip(s_select_ids + t_select_ids, range(2 * k)))
new_ids = []
for x in ids:
new_ids.append(id_map[x])
s_feats = source_features[s_flags]
t_feats = target_features[t_flags]
feats = np.concatenate([s_feats, t_feats], axis=0)
tsne = TSNE(n_components=2, random_state=0)
proj = tsne.fit_transform(feats)
ax = plt.subplot(121)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.set_xticks([])
ax.set_yticks([])
t_size = t_feats.shape[0]
s_size = s_feats.shape[0]
ax.scatter(proj[-t_size:, 0], proj[-t_size:, 1], c=['b'] * t_size, marker='.')
ax.scatter(proj[:s_size, 0], proj[:s_size, 1], c=['r'] * s_size, marker='.')
# --------------------------------------------------------------------- #
source_features_path = 'features/duke/gallery-duke2market-all-intra5-inter15-mix0.6-scale10-0.8_model_60.mat'
target_features_path = 'features/market/gallery-duke2market-all-intra5-inter15-mix0.6-scale10-0.8_model_60.mat'
print('Loading...')
source_mat = sio.loadmat(source_features_path)
target_mat = sio.loadmat(target_features_path)
print('Done!')
source_features = source_mat["feat"]
source_ids = source_mat["ids"].squeeze()
source_cam_ids = source_mat["cam_ids"].squeeze()
target_features = target_mat["feat"]
target_ids = -target_mat["ids"].squeeze()
target_cam_ids = target_mat["cam_ids"].squeeze()
s_flags = | np.in1d(source_ids, s_select_ids) | numpy.in1d |
#!/usr/bin/env python
from __future__ import division, print_function
#import pyximport; pyximport.install()
#import cycic
import math
import numpy as np
import matplotlib.pyplot as plt
import itertools
import readsnapshots.readsnapHDF5 as rs
import h5py
# Width of simulation box
BOXWIDTH = 25.0 # Mpc
# Number of cells
NDIM = 128
CELLWIDTH = BOXWIDTH / NDIM
# Spatial dimensions
SPACE = 3
BOXWIDTHS = np.array((BOXWIDTH,) * SPACE)
NDIMS = (NDIM,) * SPACE
# Unit conversions
MPCTOCM = 3.08567758e24
SOLTOGRAM = 1.9891e33
# Baryonic density
OMEGAB = 0.18
# Particle mass
MPART = OMEGAB * 8.72e6 * SOLTOGRAM
# Number of particles for random data generation
NPART = 512
# File location
SNAPPREFIX = "/home/slz/Dropbox (MIT)/urop/2016-c/data/parent/snapdir_127/snap_127"
def cic(points, ndims):
"""A basic cloud-in-cell algorithm for arbitrary spatial dimensions.
Parameters
----------
points : iterable of points
ndims : number of cells, per side"""
# spatial dimentions
space = len(ndims)
points = np.array(points, copy=False)
ndims = np.array(ndims, copy=False)
assert space == points.shape[1]
assert (points <= ndims).all()
# Initialize number density field
ndensity = np.zeros(ndims + 2)
for p in points:
# Find the cell nearest to p
cell = np.array( | np.floor(p - 0.5) | numpy.floor |
import numpy as np
def get_bands(nscf_out, tgrid0):
"""Get bands and kgrid info from nscf output
data contains: kvecs, bands, tgrid, raxes, gvecs
kvecs (nk, ndim) are reciprocal points possible in the irreducible wedge
kvecs are in 2\pi/alat units
bands (nk, nstate) are the Kohn-Sham eigenvalues
bands are in eV units
tgrid (ndim) is grid size in each dimension
!!!! currently assumed to be the same as x
raxes (ndim, ndim) is the reciprocal lattice
gvecs (nk, ndim) are reciprocal lattice points (kvecs) converted to integers
Args:
nscf_out (str): output file
tgrid0 (int): grid along x
Return:
dict: data
"""
from qharv.inspect import axes_pos
import qe_reader as qer
# get bands
data = qer.parse_nscf_bands(nscf_out)
kvecs = data['kvecs']
# get raxes, gvecs
tgrid = np.array([tgrid0]*3)
axes = qer.read_out_cell(nscf_out)
raxes = axes_pos.raxes(axes)
gcand = np.dot(kvecs, np.linalg.inv(raxes/tgrid))
gvecs = np.around(gcand).astype(int)
data['tgrid'] = tgrid
data['raxes'] = raxes
data['gvecs'] = gvecs
data.pop('nkpt')
return data
def get_ekmap(scf_out):
"""Obtain the internal variable 'equiv' from kpoint_grid.f90 in QE/PW
store the maps between full BZ (fBZ) and irreducible BZ (iBZ)
Args:
scf_out (str): output file
Return:
(dict, dict): (fBZ->iBZ, iBZ->fBZ) maps
"""
from qharv.reel import ascii_out
mm = ascii_out.read(scf_out)
text = ascii_out.block_text(mm, 'equivalent kpoints begin', 'end')
lines = text.split('\n')
emap = {} # full kgrid to irreducible wedge
kmap = {} # irreducible wedge to full kgrid
for line in lines:
tokens = line.split('equiv')
if len(tokens) != 2: continue
left, right = map(int, tokens)
emap[left] = right
if right in kmap:
kmap[right].append(left)
else:
kmap[right] = [left]
mm.close()
return emap, kmap
def get_weights(equiv_out):
"""Get weights of irreducible kpoints.
Args:
equiv_out (str): QE output file
Return:
np.array: weights, number of equivalent kpoints for each irrek
"""
emap, kmap = get_ekmap(equiv_out)
sidxl = kmap.keys()
sidxl.sort()
weights = []
for sidx in sidxl:
kwt = len(kmap[sidx])
weights.append(kwt)
return np.array(weights)
def unfold2(bands, emap, kmap, axis=0):
"""unfold method 2: steal equivalence map from QE kpoint_grid.f90
kpoints in bands MUST be ordered in the same way as the QE irreducible kpts
Args:
bands (np.array): band energy with kpoint (and state) labels
emap (dict): int -> int equivalence map of kpoint indices (full -> irrek)
kmap (dict): inverse of emap
axis (int, optional): kpoint axis, default is 0
Return:
np.array: unfolded bands
"""
idxl = kmap.keys()
idxl.sort()
nktot = len(emap)
# extend the kpoint axis
new_shape = list(bands.shape)
new_shape[axis] = nktot
vals = np.zeros(new_shape)
# fill existing values
for i, idx in enumerate(idxl):
if axis == 0:
vals[idx-1] = bands[i]
elif axis == 1:
vals[:, idx-1] = bands[:, i]
else:
raise RuntimeError('need to implement axis %d (add another :,)' % axis)
# map symmetry points
for idx0, idx1 in emap.items():
if axis == 0:
vals[idx0-1] = vals[idx1-1]
elif axis == 1:
vals[:, idx0-1] = vals[:, idx1-1]
return vals
def get_mats_vecs(symops):
mats = []
vecs = []
for so in symops:
mat = np.array(so['mat'], int)
vec = np.array(so['vec'], int)
mats.append(mat)
vecs.append(vec)
return | np.array(mats) | numpy.array |
import numpy as np
import pickle
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
from gurobi import *
###########
## Primal-Dual solver utility functions
###########
def in_constraint(v):
if v[1]:
return True
else:
return False
def make_alpha_mapping(I,J,T,alphas,valid_matches):
'''Creates an index into the alpha array for each position in valid matches'''
constraints_d, _ = dual_constraint_matrix(valid_matches,pairing_weights,I,J,T,k)
constraints_d = constraints_d[:,:alphas.size]
alpha_map = np.zeros((*valid_matches.shape,constraints_d.shape[1]),dtype=np.bool)
cix=0
for i in range(I):
for j in range(J):
for t in range(T):
if valid_matches[i][j][t]:
alpha_map[i,j,t,:] = constraints_d[cix,:]
cix += 1
return alpha_map
def sum_alpha_it(I,T, alphas,i,t,k):
'''Return the alpha terms summed at a given i,t'''
alpha_it = alphas.reshape(I,T)
startit = max(t-k[i]+1,0)
return np.sum(alpha_it[i,startit:t+1])
###########
## Primal-Dual solver functions
###########
########
## To make the primal constraint matrix:
## Apply constraint equations for each position in valid matches, then flatten to a 2D form understood by Gurobi
#######
def primal_constraint_matrix(valid_matches,I,J,T,k):
constraints = np.zeros((T*I+J,valid_matches.size),dtype=np.float128)
cix = 0
#constraints limiting to one resource allocation in the time interval
for i in range(I):
for t in range(T):
constraint = np.zeros((I,J,T), np.int)
valid_mask = constraint.copy()
endix = min(t+k[i],T)
valid_mask[i,:,t:endix] = 1
constraint[(valid_mask == 1)] = 1
constraints[cix,:] = constraint.reshape((1, constraint.shape[0] * constraint.shape[1] * constraint.shape[2]))
cix += 1
#constraints limiting each agent to only match once
for j in range(J):
constraint = np.zeros((I,J,T), np.int)
valid_mask = constraint.copy()
valid_mask[1:,j,:] = 1
constraint[(valid_matches == 1) & (valid_mask ==1)] = 1
constraints[cix+j,:] = constraint.reshape((1, constraint.shape[0] * constraint.shape[1] * constraint.shape[2]))
return constraints
########
## To make the dual constraint matrix:
## Create a constraint map to see which alphas/betas apply at a given location in the primal.
## Each valid location will correspond with a constraint in the dual, and the variables==1 will be those in the `cmap[i][j][t]`
#######
def dual_constraint_matrix(valid_matches,pairing_weights,I,J,T,k):
'''
Dual constraint matrix: Number IJT positions * number dual variables
- Each row corresponds to an IJT position in the grid
- Each column corresponds to a dual variable
'''
num_positions = I*J*T
num_primal_constraints = I*T+J
dual_constraint_matrix = np.zeros((num_positions, num_primal_constraints))
inequalities = np.zeros(num_positions)
constraint_map = | np.zeros((I,J,T,num_primal_constraints), np.int) | numpy.zeros |
import numpy as np
import pandas as pd
import cv2
import matplotlib.pyplot as plt
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras import layers
import tensorflow as tf
from keras.preprocessing.image import img_to_array
from tensorflow.keras import backend
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import os
from sklearn.metrics import classification_report
import sklearn.metrics as metrics
import itertools
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
def data_set(dir_data):
data=[]
target=[]
data_map = {
'with_mask':1,
'without_mask':0
}
skipped=0
root=dir_data+'_annotations.csv'
df1 = pd.read_csv(root)
df1.dataframeName = '_annotations.csv'
nRow, nCol = df1.shape
for i in range(len(df1)):
without_mask='without_mask'
k=dir_data+df1['filename'][i]
image=cv2.imread(k)
xmin=int(df1['xmin'][i])
ymin=int(df1['ymin'][i])
xmax=int(df1['xmax'][i])
ymax=int(df1['ymax'][i])
#image=image[ymin:ymax, xmin:xmax]
try:
# resizing to (70 x 70)
image = cv2.resize(image,(70,70))
except Exception as E:
skipped += 1
print(E)
continue
if(df1['class'][i]=='mask'):
without_mask='with_mask'
image=img_to_array(image)
data.append(image)
target.append(data_map[without_mask])
data = np.array(data, dtype="float") / 255.0
target = tf.keras.utils.to_categorical(np.array(target), num_classes=2)
return data, target
training_data,training_target=data_set('./Face-Mask-Detection/kaggle/input/face-mask-detection/train/')
testing_data,testing_target=data_set('./Face-Mask-Detection/kaggle/input/face-mask-detection/test/')
valid_data,valid_target=data_set('./Face-Mask-Detection/kaggle/input/face-mask-detection/valid/')
plt.figure(0, figsize=(100,100))
for i in range(1,10):
plt.subplot(10,5,i)
plt.imshow(training_data[i])
img_shape=training_data[0].shape
depth, height, width=3, img_shape[0], img_shape[1]
img_shape=(height, width, depth)
chanDim=-1
if backend.image_data_format() == "channels_first": #Returns a string, either 'channels_first' or 'channels_last'
img_shape = (depth, height, width)
chanDim = 1
model=Sequential()
model.add(layers.Conv2D(32,(3,3),input_shape=img_shape))
model.add(layers.MaxPooling2D(pool_size=(2,2)))
model.add(layers.Conv2D(64,(3,3)))
model.add(layers.Activation('relu'))
model.add(layers.MaxPooling2D(pool_size=(2,2)))
model.add(layers.Conv2D(128,(3,3)))
model.add(layers.Activation('relu'))
model.add(layers.MaxPooling2D(pool_size=(2,2)))
model.add(layers.Conv2D(256,(3,3)))
model.add(layers.Activation('relu'))
model.add(layers.MaxPooling2D(pool_size=(2,2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(64,activation='relu'))
model.add(layers.Dropout(0.4))
model.add(layers.Dense(2,activation='softmax'))
adam =tf.keras.optimizers.Adam(0.001)
model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy'])
model.summary()
aug = ImageDataGenerator(rotation_range=25, width_shift_range=0.1,
height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,
horizontal_flip=True, fill_mode="nearest")
history = model.fit(aug.flow(training_data, training_target, batch_size=10),
epochs=70,
validation_data=(valid_data, valid_target),
verbose=2,
shuffle=True)
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.ylabel(['accuracy'])
plt.xlabel(['epoch'])
plt.legend(['accuracy', 'val_accuracy'])
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel(['loss'])
plt.xlabel(['epoch'])
plt.legend(['loss', 'val_loss'])
loss, accuracy = model.evaluate(testing_data,testing_target)
print('accuracy= ',loss," loss= ",loss)
yhat = model.predict(testing_data)
test_pred= | np.argmax(yhat,axis=1) | numpy.argmax |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.4'
# jupytext_version: 1.1.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # s_strong_dominance [<img src="https://www.arpm.co/lab/icons/icon_permalink.png" width=30 height=30 style="display: inline;">](https://www.arpm.co/lab/redirect.php?code=s_strong_dominance&codeLang=Python)
# For details, see [here](https://www.arpm.co/lab/redirect.php?permalink=doc-s_strong_dominance).
# +
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
from arpym.statistics import simulate_normal
from arpym.tools import add_logo
# -
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_strong_dominance-parameters)
mu_ = np.array([1, 0]) # mean vector of jointly normal variables
sigma2_ = np.array([[1, 0],
[0, 1]]) # covariance matrix
j_ = 1000 # number of simulations
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_strong_dominance-implementation-step01): Simulate jointly normal random variables X_1 and X_2
x = simulate_normal(mu_, sigma2_, j_)
x_1, x_2 = x[:, 0], x[:, 1]
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_strong_dominance-implementation-step02): Simulate X_3 = X_2 + Y, Y chi-squared with 1 degree of freedom
x_3 = x_2 + sp.stats.chi2.rvs(1, size=(1, j_))
# ## Plots
# +
# set figure specifications
plt.style.use('arpm')
f, ax = plt.subplots(1, 2, figsize=(1280.0/72.0, 720.0/72.0), dpi=72.0,
subplot_kw={'aspect': 'equal'})
# create subplot for general case: x_2 versus x_1
plt.sca(ax[0])
plt.scatter(x_2, x_1, marker='.')
min1 = np.floor(mu_[0]-4*np.sqrt(sigma2_[0, 0]))
min2 = np.floor(mu_[1]-4*np.sqrt(sigma2_[1, 1]))
max1 = np.ceil(mu_[0]+4*np.sqrt(sigma2_[0, 0]))
max2 = np.ceil(mu_[1]+4*np.sqrt(sigma2_[1, 1]))
plt.axis([min(min1, min2), max(max1, max2), min(min1, min2), max(max1, max2)])
plt.plot(np.linspace(min(min1, min2), max(max1, max2)),
np.linspace(min(min1, min2), max(max1, max2)),
color='black', lw=2)
plt.title('General case', fontsize=20, fontweight='bold')
plt.xlabel(r'$X_2$', fontsize=17)
plt.ylabel(r'$X_1$', fontsize=17)
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
ax[0].spines['top'].set_visible(False)
ax[0].spines['right'].set_visible(False)
# create subplot of strong dominance: x_2 versus x_3
plt.sca(ax[1])
plt.scatter(x_2, x_3, marker='.')
plt.axis([min2, max2+4, min2, max2+4])
plt.plot( | np.linspace(min2, max2+4) | numpy.linspace |
"""
defines various methods to access high level BDF data:
- GetCard()
- get_card_ids_by_card_types(self, card_types=None, reset_type_to_slot_map=False,
stop_on_missing_card=False, combine=False)
- get_rslot_map(self, reset_type_to_slot_map=False)
- get_cards_by_card_types(self, card_types, reset_type_to_slot_map=False,
stop_on_missing_card=False)
- get_SPCx_node_ids(self, spc_id, stop_on_failure=True)
- get_SPCx_node_ids_c1( spc_id, stop_on_failure=True)
- get_MPCx_node_ids( mpc_id, stop_on_failure=True)
- get_MPCx_node_ids_c1( mpc_id, stop_on_failure=True)
- get_load_arrays(self, subcase_id, nid_map, eid_map, node_ids, normals)
- get_pressure_array(self, load_case, eids)
- get_reduced_loads(self, load_id, scale=1., skip_scale_factor0=True, msg='')
- get_reduced_dloads(self, dload_id, scale=1., skip_scale_factor0=True, msg='')
- get_rigid_elements_with_node_ids(self, node_ids)
- get_dependent_nid_to_components(self, mpc_id=None)
- get_node_ids_with_elements(self, eids, msg='')
- get_elements_nodes_by_property_type(self, dtype='int32',
save_element_types=False)
- get_elements_properties_nodes_by_element_type(self, dtype='int32', solids=None)
- get_element_ids_list_with_pids(self, pids=None)
- get_pid_to_node_ids_and_elements_array(self, pids=None, etypes=None, idtype='int32')
- get_element_ids_dict_with_pids(self, pids=None, stop_if_no_eids=True)
- get_node_id_to_element_ids_map(self)
- get_node_id_to_elements_map(self)
- get_property_id_to_element_ids_map(self):
- get_material_id_to_property_ids_map(self)
- get_reduced_mpcs(self, mpc_id)
- get_reduced_spcs(self, spc_id)
- get_spcs(self, spc_id, consider_nodes=False)
- get_mpcs(self, mpc_id)
"""
# pylint: disable=C0103
from __future__ import (nested_scopes, generators, division, absolute_import,
print_function, unicode_literals)
from copy import deepcopy
from collections import defaultdict
from typing import List, Dict, Set, Optional, Any
from six import string_types
import numpy as np
from pyNastran.bdf.bdf_interface.get_methods import GetMethods
from pyNastran.bdf.cards.optimization import get_dvprel_key
from pyNastran.utils.numpy_utils import integer_types
from pyNastran.bdf.cards.loads.static_loads import update_pload4_vector_for_surf
class GetCard(GetMethods):
"""defines various methods to access high level BDF data"""
def __init__(self):
self._type_to_slot_map = {}
GetMethods.__init__(self)
def get_card_ids_by_card_types(self, card_types=None, reset_type_to_slot_map=False,
stop_on_missing_card=False, combine=False):
"""
Parameters
----------
card_types : str / List[str] / default=None
the list of keys to consider (list of strings; string)
None : all cards
reset_type_to_slot_map : bool
should the mapping dictionary be rebuilt (default=False);
set to True if you added cards
stop_on_missing_card : bool
crashes if you request a card and it doesn't exist
combine : bool; default=False
change out_dict into out_list
combine the list of cards
Returns
-------
out_dict: dict[str]=List[ids]
the key=card_type, value=the ID of the card object
out_list: List[ids]
value=the ID of the card object
useful
Examples
---------
>>> out_dict = model.get_card_ids_by_card_types(
card_types=['GRID', 'CTRIA3', 'CQUAD4'], combine=False)
>>> out_dict = {
'GRID' : [1, 2, 10, 42, 1000],
'CTRIA3' : [1, 2, 3, 5],
'CQUAD4' : [4],
}
**shell elements**
>>> out_dict = model.get_card_ids_by_card_types(
card_types=['CTRIA3', 'CQUAD4'], combine=True)
>>> out_dict = {
[1, 2, 3, 4, 5],
}
"""
if card_types is None:
card_types = list(self.cards_to_read)
if isinstance(card_types, string_types):
card_types = [card_types]
elif not isinstance(card_types, (list, tuple)):
raise TypeError('card_types must be a list/tuple; type=%s' % type(card_types))
#if reset_type_to_slot_map or self._type_to_slot_map is None:
#self._type_to_slot_map = rslot_map
if reset_type_to_slot_map:
self._reset_type_to_slot_map()
#out_dict = {
#(key) : (self._type_to_id_map[key] if key in self.card_count else [])
#for key in card_types
#}
out_dict = {}
for key in card_types:
if key in self.card_count:
out_dict[key] = sorted(self._type_to_id_map[key])
else:
if stop_on_missing_card:
raise RuntimeError('%r is not in the card_count; keys=%s' %
str(sorted(self.card_count.keys())))
out_dict[key] = []
if combine:
out_list = []
for key, value in sorted(out_dict.items()):
out_list += value
return out_list
return out_dict
def _reset_type_to_slot_map(self):
"""resets self._type_to_slot_map"""
rslot_map = defaultdict(list)
for dict_name, card_names in self._slot_to_type_map.items():
#print('card_names=%s dict_name=%s' % (card_names, dict_name))
card_name0 = card_names[0]
if card_name0 in ['DTABLE', 'GRDSET', 'SESUP', 'DOPTPRM', 'MONPNT1', 'SUPORT',
'MKAERO1', 'MATHP']:
pass
else:
adict = getattr(self, dict_name)
if isinstance(adict, dict):
for key, card in adict.items():
if isinstance(card, list):
alist = card
for cardi in alist:
rslot_map[cardi.type].append(key)
#msg = '%s; names=%s \ncard=%s' % (type(card), card_names, card)
#raise NotImplementedError(msg)
else:
rslot_map[card.type].append(key)
elif isinstance(adict, list):
alist = adict
for value in alist:
if isinstance(value, list):
msg = '%s; names=%s value=%s' % (type(value), card_names, value)
raise NotImplementedError(msg)
else:
if value.type in ['CSET1', 'CSET']:
pass
#rslot_map[value.type] = value.
else:
raise NotImplementedError('list; names=%s' % card_names)
else:
raise NotImplementedError('%s; names=%s' % (type(adict), card_names))
return rslot_map
def get_rslot_map(self, reset_type_to_slot_map=False):
"""gets the rslot_map"""
if (reset_type_to_slot_map or self._type_to_slot_map is None or
len(self._type_to_slot_map) == 0):
self.reset_rslot_map()
rslot_map = self._type_to_slot_map
assert 'GRID' in rslot_map
return rslot_map
def reset_rslot_map(self):
"""helper method for get_rslot_map"""
rslot_map = {}
for key, values in self._slot_to_type_map.items():
for value in values:
rslot_map[value] = key
self._type_to_slot_map = rslot_map
@property
def nid_map(self):
"""
Gets the GRID/SPOINT/EPOINT ids to a sorted order.
Parameters
----------
sort_ids : bool; default=True
sort the ids
Returns
-------
nid_map : Dict[nid] : i
nid : int
the GRID/SPOINT/EPOINT id
i : int
the index
..note :: GRIDs, SPOINTs, & EPOINTs are stored in separate slots,
so they are unorganized.
..note :: see ``self.get_nid_map(sort_ids=False)`` for the unsorted version
"""
return self.get_nid_map(sort_ids=True)
def get_nid_map(self, sort_ids=True):
"""
Maps the GRID/SPOINT/EPOINT ids to a sorted/unsorted order.
Parameters
----------
sort_ids : bool; default=True
sort the ids
Returns
-------
nid_map : Dict[nid] : i
nid : int
the GRID/SPOINT/EPOINT id
i : int
the index
..note :: GRIDs, SPOINTs, & EPOINTs are stored in separate slots,
so they are unorganized.
"""
nids = []
index_nids = []
i = 0
for nid in self.nodes:
nids.append(nid)
index_nids.append(i)
i += 1
for nid in self.spoints:
nids.append(nid)
index_nids.append(i)
i += 1
for nid in self.epoints:
nids.append(nid)
index_nids.append(i)
i += 1
if sort_ids:
inids = np.argsort(nids)
nids = np.sort(nids)
index_nids = np.array(index_nids)[inids]
nid_map = {}
for nid, i in zip(nids, index_nids):
nid_map[nid] = i
return nid_map
def get_cards_by_card_types(self, card_types, reset_type_to_slot_map=False,
stop_on_missing_card=False):
"""
Parameters
----------
card_types : List[str]
the list of keys to consider
reset_type_to_slot_map : bool
should the mapping dictionary be rebuilt (default=False);
set to True if you added cards
stop_on_missing_card : bool
crashes if you request a card and it doesn't exist
Returns
-------
out_dict : dict[str] = List[BDFCard()]
the key=card_type, value=the card object
"""
if not isinstance(card_types, (list, tuple)):
raise TypeError('card_types must be a list/tuple; type=%s' % type(card_types))
#self._type_to_id_map = {
# 'CQUAD4' : [1, 2, 3]
#}
#self._slot_to_type_map = {'elements' : [CQUAD4, CTRIA3]}
rslot_map = self.get_rslot_map(reset_type_to_slot_map=False)
out = {}
for card_type in card_types:
if card_type not in self.card_count:
if stop_on_missing_card:
raise RuntimeError('%r is not in the card_count; keys=%s'
% str(sorted(self.card_count.keys())))
out[card_type] = []
continue
#print('card_type=%r' % card_type)
try:
key = rslot_map[card_type] # update attributes.py ~line 640
except:
print(rslot_map.keys())
self.log.error("card_type=%r' hasn't been added to "
"self._slot_to_type_map...check for typos")
raise
try:
slot = getattr(self, key)
except AttributeError:
if hasattr(self.zona, key):
slot = getattr(self.zona, key)
else:
raise
ids = self._type_to_id_map[card_type]
cards = []
if isinstance(ids, bool):
continue
for idi in ids:
try:
card = slot[idi]
except KeyError:
print(slot)
msg = 'key=%r id=%r cannot be found\n' % (key, idi)
msg += 'id=%s not found. Allowed=%s' % (
key, np.unique(ids))
#print(msg)
raise KeyError(msg)
except TypeError:
msg = 'key=%s id=%s cannot be found' % (key, idi)
#print(msg)
raise TypeError(msg)
if isinstance(card, list):
for cardi in card: # loads/spc/mpc
if cardi.type == card_type: # loads
cards.append(cardi)
else:
cards.append(card)
#for card in cards:
#print('%s' % str(card).split('\n')[0])
out[card_type] = cards
return out
def get_SPCx_node_ids(self, spc_id, stop_on_failure=True):
"""
Get the SPC/SPCADD/SPC1/SPCAX IDs.
Parameters
----------
spc_id : int
the SPC id
stop_on_failure : bool; default=True
errors if parsing something new
Returns
-------
node_ids : List[int]
the constrained associated node ids
"""
spcs = self.get_reduced_spcs(spc_id, stop_on_failure=stop_on_failure)
warnings = ''
node_ids = []
for card in spcs:
if card.type == 'SPC':
nids = card.node_ids
elif card.type == 'SPC1':
nids = card.node_ids
elif card.type in ['GMSPC', 'SPCAX']:
warnings += str(card)
continue
else:
warnings += str(card)
continue
node_ids += nids
if warnings:
self.log.warning("get_SPCx_node_ids doesn't consider:\n%s" % warnings.rstrip('\n'))
return node_ids
def get_SPCx_node_ids_c1(self, spc_id, stop_on_failure=True):
"""
Get the SPC/SPCADD/SPC1/SPCAX IDs.
Parameters
----------
spc_id : int
the SPC id
stop_on_failure : bool; default=True
errors if parsing something new
Returns
-------
node_ids_c1 : Dict[component] = node_ids
component : str
the DOF to constrain
node_ids : List[int]
the constrained node ids
"""
spcs = self.get_reduced_spcs(spc_id, stop_on_failure=stop_on_failure)
node_ids_c1 = defaultdict(str)
#print('spcs = ', spcs)
warnings = ''
for card in spcs: # used to be sorted(spcs)
if card.type == 'SPC':
for nid, c1 in zip(card.node_ids, card.components):
assert nid is not None, card.node_ids
node_ids_c1[nid] += c1
elif card.type == 'SPC1':
nids = card.node_ids
c1 = card.components
for nid in nids:
node_ids_c1[nid] += c1
elif card.type in ['GMSPC', 'SPCAX']:
warnings += str(card)
else:
msg = 'get_SPCx_node_ids_c1 doesnt supprt %r' % card.type
if stop_on_failure:
raise RuntimeError(msg)
else:
self.log.warning(msg)
if warnings:
self.log.warning("get_SPCx_node_ids_c1 doesn't consider:\n%s" % warnings.rstrip('\n'))
return node_ids_c1
def get_MPCx_node_ids(self, mpc_id, stop_on_failure=True):
r"""
Get the MPC/MPCADD IDs.
Parameters
----------
mpc_id : int
the MPC id
stop_on_failure : bool; default=True
errors if parsing something new
Returns
-------
lines : List[[independent, dependent]]
independent : int
the independent node id
dependent : int
the dependent node id
I I
\ /
I---D---I
"""
lines = []
mpcs = self.get_reduced_mpcs(mpc_id, stop_on_failure=stop_on_failure)
# dependent, independent
for card in mpcs:
if card.type == 'MPC':
nids = card.node_ids
nid0 = nids[0]
#component0 = card.components[0]
#enforced0 = card.coefficients[0]
#card.constraints[1:]
for nid, coefficient in zip(nids[1:], card.coefficients[1:]):
if coefficient != 0.0:
lines.append([nid0, nid])
else:
msg = 'get_MPCx_node_ids doesnt support %r' % card.type
if stop_on_failure:
raise RuntimeError(msg)
else:
self.log.warning(msg)
return lines
def get_MPCx_node_ids_c1(self, mpc_id, stop_on_failure=True):
r"""
Get the MPC/MPCADD IDs.
Parameters
----------
mpc_id : int
the MPC id
stop_on_failure : bool; default=True
errors if parsing something new
Returns
-------
independent_node_ids_c1 : Dict[component] = node_ids
component : str
the DOF to constrain
node_ids : List[int]
the constrained node ids
dependent_node_ids_c1 : Dict[component] = node_ids
component : str
the DOF to constrain
node_ids : List[int]
the constrained node ids
I I
\ /
I---D---I
"""
if not isinstance(mpc_id, integer_types):
msg = 'mpc_id must be an integer; type=%s, mpc_id=\n%r' % (type(mpc_id), mpc_id)
raise TypeError(msg)
mpcs = self.get_reduced_mpcs(mpc_id, stop_on_failure=stop_on_failure)
# dependent, independent
independent_node_ids_c1 = defaultdict(list)
dependent_node_ids_c1 = defaultdict(list)
for card in mpcs:
if card.type == 'MPC':
nids = card.node_ids
nid0 = nids[0]
#component0 = card.components[0]
#coefficient0 = card.coefficients[0]
#card.constraints[1:]
dofs = card.components
for dof in dofs:
independent_node_ids_c1[dof].append(nid0)
for nid, coefficient in zip(nids[1:], card.coefficients[1:]):
if coefficient != 0.0:
for dof in dofs:
dependent_node_ids_c1[dof].append(nid)
else:
msg = 'get_MPCx_node_ids_c1 doesnt support %r' % card.type
if stop_on_failure:
raise RuntimeError(msg)
else:
self.log.warning(msg)
return independent_node_ids_c1, dependent_node_ids_c1
def get_load_arrays(self, subcase_id, eid_map, node_ids, normals, nid_map=None):
"""
Gets the following load arrays for the GUI
Loads include:
- Temperature
- Pressure (Centroidal)
- Forces
- SPCD
Parameters
----------
model : BDF()
the BDF object
subcase_id : int
the subcase id
Returns
-------
found_load : bool
a flag that indicates if load data was found
found_temperature : bool
a flag that indicates if temperature data was found
temperature_data : tuple(temperature_key, temperatures)
temperature_key : str
One of the following:
TEMPERATURE(MATERIAL)
TEMPERATURE(INITIAL)
TEMPERATURE(LOAD)
TEMPERATURE(BOTH)
temperatures : (nnodes, 1) float ndarray
the temperatures
load_data : tuple(centroidal_pressures, forces, spcd)
centroidal_pressures : (nelements, 1) float ndarray
the pressure
forces : (nnodes, 3) float ndarray
the pressure
spcd : (nnodes, 3) float ndarray
the SPCD load application
"""
if nid_map is None:
nid_map = self.nid_map
assert len(nid_map) == len(node_ids), 'len(nid_map)=%s len(node_ids)=%s' % (len(nid_map), len(node_ids))
subcase = self.subcases[subcase_id]
is_loads = False
is_temperatures = False
load_keys = (
'LOAD', 'TEMPERATURE(MATERIAL)', 'TEMPERATURE(INITIAL)',
'TEMPERATURE(LOAD)', 'TEMPERATURE(BOTH)')
temperature_keys = (
'TEMPERATURE(MATERIAL)', 'TEMPERATURE(INITIAL)',
'TEMPERATURE(LOAD)', 'TEMPERATURE(BOTH)')
centroidal_pressures = None
forces = None
spcd = None
temperature_key = None
temperatures = None
for key in load_keys:
try:
load_case_id = subcase.get_parameter(key)[0]
except KeyError:
# print('no %s for isubcase=%s' % (key, subcase_id))
continue
try:
load_case = self.get_reduced_loads(
load_case_id, scale=1.,
consider_load_combinations=True,
skip_scale_factor0=False,
stop_on_failure=False,
msg='')
except KeyError:
self.log.warning('LOAD=%s not found' % load_case_id)
continue
if key == 'LOAD':
p0 = np.array([0., 0., 0.], dtype='float32')
centroidal_pressures, forces, spcd = self._get_forces_moments_array(
p0, load_case_id,
eid_map=eid_map,
node_ids=node_ids,
normals=normals,
dependents_nodes=self.node_ids,
nid_map=nid_map,
include_grav=False)
if centroidal_pressures is not None: # or any of the others
is_loads = True
elif key in temperature_keys:
is_temperatures, temperatures = self._get_temperatures_array(
load_case_id, nid_map=nid_map)
temperature_key = key
else:
raise NotImplementedError(key)
temperature_data = (temperature_key, temperatures)
load_data = (centroidal_pressures, forces, spcd)
return is_loads, is_temperatures, temperature_data, load_data
def _get_dvprel_ndarrays(self, nelements, pids, fdtype='float32', idtype='int32'):
"""
creates arrays for dvprel results
Parameters
----------
nelements : int
the number of elements
pids : (nelements,) int ndarray
properties array to map the results to
fdtype : str; default='float32'
the type of the init/min/max arrays
idtype : str; default='int32'
the type of the design_region
Returns
-------
dvprel_dict[key] : (design_region, dvprel_init, dvprel_min, dvprel_max)
key : str
the optimization string
design_region : (nelements,) int ndarray
dvprel_init : (nelements,) float ndarray
the initial values of the variable
dvprel_min : (nelements,)float ndarray
the min values of the variable
dvprel_max : (nelements,)float ndarray
the max values of the variable
"""
dvprel_dict = {}
def get_dvprel_data(key):
if key in dvprel_dict:
return dvprel_dict[key]
dvprel_t_init = np.full(nelements, np.nan, dtype=fdtype)
dvprel_t_min = np.full(nelements, np.nan, dtype=fdtype)
dvprel_t_max = np.full(nelements, np.nan, dtype=fdtype)
design_region = np.zeros(nelements, dtype=idtype)
dvprel_dict[key] = (design_region, dvprel_t_init, dvprel_t_min, dvprel_t_max)
return design_region, dvprel_t_init, dvprel_t_min, dvprel_t_max
for dvprel_key, dvprel in self.dvprels.items():
prop_type = dvprel.prop_type
desvars = dvprel.dvids
if dvprel.pid_ref is not None:
pid = dvprel.pid_ref.pid
else:
pid = dvprel.pid
var_to_change = dvprel.pname_fid
prop = self.properties[pid]
if not prop.type == prop_type:
raise RuntimeError('Property type mismatch\n%s%s' % (str(dvprel), str(prop)))
key, msg = get_dvprel_key(dvprel, prop)
if dvprel.type == 'DVPREL1':
assert len(desvars) == 1, len(desvars)
coeffs = dvprel.coeffs
if msg:
self.log.warning(msg)
continue
i = np.where(pids == pid)[0]
if len(i) == 0:
continue
assert len(i) > 0, i
design_region, dvprel_init, dvprel_min, dvprel_max = get_dvprel_data(key)
optimization_region = dvprel.oid
assert optimization_region > 0, str(self)
design_region[i] = optimization_region
#value = 0.
lower_bound = 0.
upper_bound = 0.
for desvar, coeff in zip(desvars, coeffs):
if isinstance(desvar, integer_types):
desvar_ref = self.desvars[desvar]
else:
desvar_ref = desvar.desvar_ref
xiniti = desvar_ref.xinit
if desvar_ref.xlb != -1e20:
xiniti = max(xiniti, desvar_ref.xlb)
lower_bound = desvar_ref.xlb
if desvar_ref.xub != 1e20:
xiniti = min(xiniti, desvar_ref.xub)
upper_bound = desvar_ref.xub
# code validation
if desvar_ref.delx is not None and desvar_ref.delx != 1e20:
pass
# TODO: haven't quite decided what to do
if desvar_ref.ddval is not None:
msg = 'DESVAR id=%s DDVAL is not None\n%s' % str(desvar_ref)
assert desvar_ref.ddval is None, desvar_ref
xinit = coeff * xiniti
dvprel_init[i] = xinit
dvprel_min[i] = lower_bound
dvprel_max[i] = upper_bound
#elif dvprel.type == 'DVPREL2':
#print(dvprel.get_stats())
else:
msg = 'dvprel.type=%r; dvprel=\n%s' % (dvprel.type, str(dvprel))
raise NotImplementedError(msg)
# TODO: haven't quite decided what to do
if dvprel.p_max != 1e20:
dvprel.p_max
# TODO: haven't quite decided what to do
if dvprel.p_min is not None:
dvprel.p_min
#dvprel_dict['PSHELL']['T'] = dvprel_t_init, dvprel_t_min, dvprel_t_max
return dvprel_dict
def _get_forces_moments_array(self, p0, load_case_id,
eid_map, node_ids, normals, dependents_nodes,
nid_map=None, include_grav=False):
"""
Gets the forces/moments on the nodes for the GUI, but there may
be a use outside of that
Parameters
----------
p0 : (3, ) float ndarray
the reference location
load_case_id : int
the load id
nid_map : ???
???
eid_map : ???
???
node_ids : ???
???
normals : (nelements, 3) float ndarray
the normal vectors for the shells
dependents_nodes : ???
???
include_grav : bool; default=False
is the mass of the elements considered; unused
Returns
-------
temperature_data : tuple(temperature_key, temperatures)
temperature_key : str
One of the following:
TEMPERATURE(MATERIAL)
TEMPERATURE(INITIAL)
TEMPERATURE(LOAD)
TEMPERATURE(BOTH)
temperatures : (nnodes, 1) float ndarray
the temperatures
load_data : tuple(centroidal_pressures, forces, spcd)
centroidal_pressures : (nelements, 1) float ndarray
the pressure
forces : (nnodes, 3) float ndarray
the pressure
spcd : (nnodes, 3) float ndarray
the SPCD load application
Considers
FORCE
PLOAD2 - CTRIA3, CQUAD4, CSHEAR
PLOAD4 - CTRIA3, CTRIA6, CTRIAR
CQUAD4, CQUAD8, CQUAD, CQUADR, CSHEAR
CTETRA, CPENTA, CHEXA
SPCD
"""
if nid_map is None:
nid_map = self.nid_map
if not any(['FORCE' in self.card_count,
'PLOAD' in self.card_count, 'PLOAD2' in self.card_count,
'PLOAD4' in self.card_count, 'SPCD' in self.card_count,
'SLOAD' in self.card_count]):
return None, None, None
nnodes = len(node_ids)
assert len(nid_map) == len(node_ids), 'len(nid_map)=%s len(node_ids)=%s' % (len(nid_map), len(node_ids))
loads, scale_factors = self.get_reduced_loads(
load_case_id, skip_scale_factor0=True)[:2]
#eids = sorted(self.elements.keys())
centroidal_pressures = np.zeros(len(self.elements), dtype='float32')
nodal_pressures = np.zeros(len(self.node_ids), dtype='float32')
forces = | np.zeros((nnodes, 3), dtype='float32') | numpy.zeros |
import numpy as np
from ..basic import gamma, gammaRatio
def coeff(v, N=7, method='2'):
'''
Return the fractional coefficients.
Parameters
----------
v : float
Order of the diffinetration.
N : int, optional
Length of the corresponding coefficients. Default is 7.
method : str
Diffintegration operator. {'1' or '2' (default)}.
Returns
----------
coefficients : ndarray
Coefficients are from from C_{0} to C_{N-1}.
'''
if method == '2':
n = N - 2
coefficients = np.zeros(N)
temp = np.array([v/4 + v**2 / 8, 1 - v**2 / 4, -v/4 + v**2 / 8])
coefficients[0] = temp[0]
coefficients[1] = 1 - v**2 / 2 - v**3 / 8
for k in range(1, n - 1):
coefficients[k + 1] = gammaRatio(k - v + 1, -v) / gamma(k + 2) * temp[0] + gammaRatio(
k - v, -v) / gamma(k + 1) * temp[1] + gammaRatio(k - v - 1, -v) / gamma(k) * temp[2]
coefficients[n] = gammaRatio(n - v - 1, -v) / gamma(n) * \
temp[1] + gammaRatio(n - v - 2, -v) / gamma(n - 1) * temp[2]
coefficients[-1] = gammaRatio(n - v - 1, -v) / gamma(n) * temp[2]
return coefficients
elif method == '1':
n = N - 1
coefficients = np.zeros(N)
coefficients[0] = 1
coefficients[1] = -v
for k in range(2, N):
coefficients[k] = gammaRatio(k - v, -v) / gamma(k + 1)
return coefficients
def dotPos(xq, N=7, a=0, method='2'):
'''
Return the position array for the mask convolution.
Parameters
----------
xq : float
Point at which function is diffintegrated.
N : int, optional
Length of the corresponding coefficients. Default is 7.
a : float, optional
Lower limit of the diffintegration. Default is 0.
method : str
Diffintegration operator. {'1' or '2' (default)}.
Returns
----------
h : float
Step size of the interval.
x_arr : ndarray
Positions for mask convolution.
'''
if method == '2':
h = (xq - a) / (N - 2)
x_arr = np.linspace(xq + h, a, N)
return h, x_arr
elif method == '1':
h = (xq - a) / N
x_arr = np.linspace(xq, a + h, N)
return h, x_arr
def deriv(fun, xq, v, N=7, a=0, method='2'):
'''
Calculate the fractional diffintegral.
Parameters
----------
fun : callable
Diffintegrand function.
xq : ndarray or float
Point at which fun is diffintegrated.
v : float
Diffintegration order.
N : int, optional
Length of the corresponding coefficients. Default is 7.
a : float, optional
Lower limit of the diffintegration. Default is 0.
method : str
Diffintegration operator. {'1' or '2' (default)}.
Returns
----------
yq : ndarray or float
The diffintegral value at xq.
'''
C = coeff(v, N, method)
if hasattr(xq, "__len__"):
num = len(xq)
yq = np.zeros(num)
for i in range(num):
h, x_tmp = dotPos(xq[i], N, a, method)
yq[i] = np.dot(C, fun(x_tmp)) / h**(v)
return yq
else:
h, x_tmp = dotPos(xq, N, a, method)
return np.dot(C, fun(x_tmp)) / h**(v)
def mask(v, N=13, method='Tiansi'):
'''
Return fractional mask operator.
Parameters
----------
v : float
Diffintegration order.
N : int, optional
Mask size of the corresponding operator. Default is 13 x 13.
method : str
Diffintegration operator. {'Tiansi' (1, default) or 'lcr' (2)}.
Returns
----------
result_mask : 2darray
The fractional mask.
'''
center = int((N - 1) / 2)
result_mask = np.zeros((N, N))
if method == 'Tiansi' or method == '1':
C = coeff(v, center + 1, '1')
elif method == 'lcr' or method == '2':
C = coeff(v, center + 2, '2')
C[2] += C[0]
C = C[1:]
result_mask[center, center] = 8 * C[0]
for i in range(1, center + 1):
c = C[i]
result_mask[center - i, center] = c
result_mask[center + i, center] = c
result_mask[center, center - i] = c
result_mask[center, center + i] = c
result_mask[center + i, center - i] = c
result_mask[center - i, center + i] = c
result_mask[center - i, center - i] = c
result_mask[center + i, center + i] = c
return result_mask
def deriv8(A, v, method='2', N=7):
'''
Compute the fractional diffintegral in the eight direction of a matrix A
Parameters
----------
A : 2darray
Matrix (image) that need to be diffintegrated.
v : float
Diffintegration order.
method : str
Diffintegration operator. {'1' or '2' (default)}.
N : int, optional
Length of the corresponding coefficients. Default is 7.
Returns
----------
d8 : 3darray
fractional diffintegral result. First dimension represents direction in the following order: u, d, l, r, ld, ru, lu, rd.
'''
len_x, len_y = A.shape
C = coeff(v, N, method)
d8 = np.zeros((8, len_x, len_y))
if method == '1':
A_pad = np.pad(A, N - 1, mode='symmetric')
for k in range(N):
c = C[k]
d8[0] += c * A_pad[(N - 1 - k):(N - 1 - k + len_x), (N - 1):(N - 1 + len_y)]
d8[1] += c * A_pad[(N - 1 + k):(N - 1 + k + len_x), (N - 1):(N - 1 + len_y)]
d8[2] += c * A_pad[(N - 1):(N - 1 + len_x), (N - 1 - k):(N - 1 - k + len_y)]
d8[3] += c * A_pad[(N - 1):(N - 1 + len_x), (N - 1 + k):(N - 1 + k + len_y)]
d8[4] += c * A_pad[(N - 1 + k):(N - 1 + k + len_x), (N - 1 - k):(N - 1 - k + len_y)]
d8[5] += c * A_pad[(N - 1 - k):(N - 1 - k + len_x), (N - 1 + k):(N - 1 + k + len_y)]
d8[6] += c * A_pad[(N - 1 - k):(N - 1 - k + len_x), (N - 1 - k):(N - 1 - k + len_y)]
d8[7] += c * A_pad[(N - 1 + k):(N - 1 + k + len_x), (N - 1 + k):(N - 1 + k + len_y)]
elif method == '2':
A_pad = | np.pad(A, N - 2, mode='symmetric') | numpy.pad |
"""
Python script to test the accuracy of the TIME command.
Author: <NAME>
Date: 4/27/18
"""
# This is pyserial
import serial
import numpy
import statistics
import cmath
import datetime
import os
import time
import matplotlib.pyplot as plt
def average(arr):
return sum(arr) / len(arr)
print("Enter the com port")
port = str(input())
print("Enter the frequency in MHz")
fMin = int(float(input()) * 1e6)
print("Enter number of samples")
samp = int(input())
start = time.time()
filename = str(os.path.splitext(os.path.basename(__file__))[0]) + "_" + str(datetime.datetime.now()).replace(":", "-")\
.replace(".", "-").replace(" ", "_") + ".dat"
if not os.path.exists("measurements"):
os.makedirs("measurements")
file = open("measurements/" + filename, 'w+')
try:
ser = serial.Serial(port, 115200, timeout=3)
except serial.serialutil.SerialException:
print("Could not open the port")
exit()
if not ser.is_open:
print("Could not open port")
exit()
time.sleep(1)
ser.flush()
command = "^SAMPLERATE,1"+"$\n"
ser.write(command.encode())
Fs = int(ser.readline())
N = int(ser.readline().decode().strip(' \n'))
F_IF = int(ser.readline().decode().strip(' \n'))
T = 1./float(Fs)
file.write("Time Test\n")
file.write("Frequency = " + str(fMin) + '\n')
file.write("Samples = " + str(samp) + '\n')
file.write("Port = " + str(port) + '\n')
file.write("FS = " + str(Fs) + '\n')
file.write("N = " + str(N) + '\n')
file.write("F_IF = " + str(F_IF) + '\n')
file.write("T = " + str(T) + '\n\n\n')
endRef = []
endMeas = []
for x in range(samp):
print("Getting " + str(x) + '\n')
command = "^TIME," + str(fMin) + "$\n"
ser.write(command.encode())
ref = ser.readline().decode()
meas = ser.readline().decode()
ref = ref.split(',')
meas = meas.split(',')
refSanitized = [int(x.strip(' \n')) for x in ref if x.strip(' \n')]
measSanitized = [int(x.strip(' \n')) for x in meas if x.strip(' \n')]
ref = [x - average(refSanitized) for x in refSanitized]
meas = [x - average(measSanitized) for x in measSanitized]
endRef.append(ref)
endMeas.append(meas)
ser.close()
plt.plot(numpy.arange(0, len(endRef[0]) / Fs, 1/Fs), endRef[0],numpy.arange(0, len(endMeas[0]) / Fs, 1/Fs), endMeas[0])
plt.show()
#plt.plot(numpy.arange(0, len(endMeas[0]) / Fs, 1/Fs), endMeas[0])
#plt.show()
ref = []
meas = []
H1 = []
H3 = []
H5 = []
H7 = []
window = numpy.hanning(N)
for x in range(samp):
print("Computing " + str(x) + '\n')
for y in range(len(endRef[x])):
endRef[x][y] *= window[y]
for y in range(len(endMeas[x])):
endMeas[x][y] *= window[y]
reffft = numpy.fft.fft(endRef[x])
measfft = numpy.fft.fft(endMeas[x])
ref.append(reffft[int(F_IF*N/Fs+1)])
meas.append(measfft[int(F_IF*N/Fs+1)])
H1.append(measfft[int(F_IF * N / Fs + 1)] / reffft[int(F_IF * N / Fs + 1)])
H3.append(measfft[int(3 * F_IF * N / Fs + 1)] / reffft[int(3 * F_IF * N / Fs + 1)])
H5.append(measfft[int(5 * F_IF * N / Fs + 1)] / reffft[int(5 * F_IF * N / Fs + 1)])
H7.append(measfft[int(7 * F_IF * N / Fs + 1)] / reffft[int(7 * F_IF * N / Fs + 1)])
file.write("Measurement " + str(x + 1) + '\n')
file.write('Ref: ' + str(ref[x]) + '\n')
file.write('Meas: ' + str(meas[x]) + '\n')
file.write('H1: ' + str(H1[x]) + '\n')
file.write('H3: ' + str(H3[x]) + '\n')
file.write('H5: ' + str(H5[x]) + '\n')
file.write('H7: ' + str(H7[x]) + '\n\n\n')
X0 = numpy.fft.fftshift(numpy.fft.fft(endRef[0])/N)
f = numpy.arange(-1/(2*T),1/(2*T),1/(N*T))
plt.plot(f,numpy.abs(X0))
plt.show()
X1 = numpy.fft.fftshift( | numpy.fft.fft(endRef[0]) | numpy.fft.fft |
"""Simple minimizer is a wrapper around scipy.leastsq, allowing a user to build
a fitting model as a function of general purpose Fit Parameters that can be
fixed or varied, bounded, and written as a simple expression of other Fit
Parameters.
The user sets up a model in terms of instance of Parameters and writes a
function-to-be-minimized (residual function) in terms of these Parameters.
Original copyright:
Copyright (c) 2011 <NAME>, The University of Chicago
See LICENSE for more complete authorship information and license.
"""
from collections import namedtuple
from copy import deepcopy
import multiprocessing
import numbers
import warnings
import numpy as np
from numpy import dot, eye, ndarray, ones_like, sqrt, take, transpose, triu
from numpy.dual import inv
from numpy.linalg import LinAlgError
from scipy.optimize import brute as scipy_brute
from scipy.optimize import leastsq as scipy_leastsq
from scipy.optimize import minimize as scipy_minimize
from scipy.optimize import differential_evolution
from scipy.stats import cauchy as cauchy_dist
from scipy.stats import norm as norm_dist
import six
# use locally modified version of uncertainties package
from . import uncertainties
from .parameter import Parameter, Parameters
# scipy version notes:
# currently scipy 0.15 is required.
# feature scipy version added
# minimize 0.11
# OptimizeResult 0.13
# diff_evolution 0.15
# least_squares 0.17
# check for scipy.opitimize.least_squares
HAS_LEAST_SQUARES = False
try:
from scipy.optimize import least_squares
HAS_LEAST_SQUARES = True
except ImportError:
pass
# check for EMCEE
HAS_EMCEE = False
try:
import emcee as emcee
HAS_EMCEE = True
except ImportError:
pass
# check for pandas
HAS_PANDAS = False
try:
import pandas as pd
HAS_PANDAS = True
except ImportError:
pass
def asteval_with_uncertainties(*vals, **kwargs):
"""Calculate object value, given values for variables.
This is used by the uncertainties package to calculate the
uncertainty in an object even with a complicated expression.
"""
_obj = kwargs.get('_obj', None)
_pars = kwargs.get('_pars', None)
_names = kwargs.get('_names', None)
_asteval = _pars._asteval
if (_obj is None or _pars is None or _names is None or
_asteval is None or _obj._expr_ast is None):
return 0
for val, name in zip(vals, _names):
_asteval.symtable[name] = val
return _asteval.eval(_obj._expr_ast)
wrap_ueval = uncertainties.wrap(asteval_with_uncertainties)
def eval_stderr(obj, uvars, _names, _pars):
"""Evaluate uncertainty and set .stderr for a parameter `obj`.
Given the uncertain values `uvars` (a list of uncertainties.ufloats), a
list of parameter names that matches uvars, and a dict of param objects,
keyed by name.
This uses the uncertainties package wrapped function to evaluate the
uncertainty for an arbitrary expression (in obj._expr_ast) of parameters.
"""
if not isinstance(obj, Parameter) or getattr(obj, '_expr_ast', None) is None:
return
uval = wrap_ueval(*uvars, _obj=obj, _names=_names, _pars=_pars)
try:
obj.stderr = uval.std_dev()
except:
obj.stderr = 0
class MinimizerException(Exception):
"""General Purpose Exception."""
def __init__(self, msg):
Exception.__init__(self)
self.msg = msg
def __str__(self):
return "\n%s" % self.msg
SCALAR_METHODS = {'nelder': 'Nelder-Mead',
'powell': 'Powell',
'cg': 'CG',
'bfgs': 'BFGS',
'newton': 'Newton-CG',
'lbfgsb': 'L-BFGS-B',
'l-bfgsb': 'L-BFGS-B',
'tnc': 'TNC',
'cobyla': 'COBYLA',
'slsqp': 'SLSQP',
'dogleg': 'dogleg',
'trust-ncg': 'trust-ncg',
'differential_evolution': 'differential_evolution'}
def reduce_chisquare(r):
"""Reduce residual array to scalar (chi-square).
Calculate the chi-square value from the residual array `r`: (r*r).sum()
Parameters
----------
r : numpy.ndarray
Residual array.
Returns
-------
float
Chi-square calculated from the residual array
"""
return (r*r).sum()
def reduce_negentropy(r):
"""Reduce residual array to scalar (negentropy).
Reduce residual array `r` to scalar using negative entropy and the normal
(Gaussian) probability distribution of `r` as pdf:
(norm.pdf(r)*norm.logpdf(r)).sum()
since pdf(r) = exp(-r*r/2)/sqrt(2*pi), this is
((r*r/2 - log(sqrt(2*pi))) * exp(-r*r/2)).sum()
Parameters
----------
r : numpy.ndarray
Residual array.
Returns
-------
float
Negative entropy value calculated from the residual array
"""
return (norm_dist.pdf(r)*norm_dist.logpdf(r)).sum()
def reduce_cauchylogpdf(r):
"""Reduce residual array to scalar (cauchylogpdf).
Reduce residual array `r` to scalar using negative log-likelihood and a
Cauchy (Lorentzian) distribution of `r`:
-scipy.stats.cauchy.logpdf(r)
(where the Cauchy pdf = 1/(pi*(1+r*r))). This gives greater
suppression of outliers compared to normal sum-of-squares.
Parameters
----------
r : numpy.ndarray
Residual array.
Returns
-------
float
Negative entropy value calculated from the residual array
"""
return -cauchy_dist.logpdf(r).sum()
class MinimizerResult(object):
r"""
The results of a minimization.
Minimization results include data such as status and error messages,
fit statistics, and the updated (i.e., best-fit) parameters themselves
in the :attr:`params` attribute.
The list of (possible) `MinimizerResult` attributes is given below:
Attributes
----------
params : :class:`~lmfit.parameter.Parameters`
The best-fit parameters resulting from the fit.
status : int
Termination status of the optimizer. Its value depends on the
underlying solver. Refer to `message` for details.
var_names : list
Ordered list of variable parameter names used in optimization, and
useful for understanding the values in :attr:`init_vals` and
:attr:`covar`.
covar : numpy.ndarray
Covariance matrix from minimization (`leastsq` only), with
rows and columns corresponding to :attr:`var_names`.
init_vals : list
List of initial values for variable parameters using :attr:`var_names`.
init_values : dict
Dictionary of initial values for variable parameters.
nfev : int
Number of function evaluations.
success : bool
True if the fit succeeded, otherwise False.
errorbars : bool
True if uncertainties were estimated, otherwise False.
message : str
Message about fit success.
ier : int
Integer error value from :scipydoc:`optimize.leastsq` (`leastsq` only).
lmdif_message : str
Message from :scipydoc:`optimize.leastsq` (`leastsq` only).
nvarys : int
Number of variables in fit: :math:`N_{\rm varys}`.
ndata : int
Number of data points: :math:`N`.
nfree : int
Degrees of freedom in fit: :math:`N - N_{\rm varys}`.
residual : numpy.ndarray
Residual array :math:`{\rm Resid_i}`. Return value of the objective
function when using the best-fit values of the parameters.
chisqr : float
Chi-square: :math:`\chi^2 = \sum_i^N [{\rm Resid}_i]^2`.
redchi : float
Reduced chi-square:
:math:`\chi^2_{\nu}= {\chi^2} / {(N - N_{\rm varys})}`.
aic : float
Akaike Information Criterion statistic:
:math:`N \ln(\chi^2/N) + 2 N_{\rm varys}`.
bic : float
Bayesian Information Criterion statistic:
:math:`N \ln(\chi^2/N) + \ln(N) N_{\rm varys}`.
flatchain : pandas.DataFrame
A flatchain view of the sampling chain from the `emcee` method.
Methods
-------
show_candidates
Pretty_print() representation of candidates from the `brute` method.
"""
def __init__(self, **kws):
for key, val in kws.items():
setattr(self, key, val)
@property
def flatchain(self):
"""A flatchain view of the sampling chain from the `emcee` method."""
if hasattr(self, 'chain'):
if HAS_PANDAS:
if len(self.chain.shape) == 4:
return pd.DataFrame(self.chain[0, ...].reshape((-1, self.nvarys)),
columns=self.var_names)
elif len(self.chain.shape) == 3:
return pd.DataFrame(self.chain.reshape((-1, self.nvarys)),
columns=self.var_names)
else:
raise NotImplementedError('Please install Pandas to see the '
'flattened chain')
else:
return None
def show_candidates(self, candidate_nmb='all'):
"""A pretty_print() representation of the candidates.
Showing candidates (default is 'all') or the specified candidate-#
from the `brute` method.
Parameters
----------
candidate_nmb : int or 'all'
The candidate-number to show using the :meth:`pretty_print` method.
"""
if hasattr(self, 'candidates'):
try:
candidate = self.candidates[candidate_nmb]
print("\nCandidate #{}, chisqr = "
"{:.3f}".format(candidate_nmb, candidate.score))
candidate.params.pretty_print()
except:
for i, candidate in enumerate(self.candidates):
print("\nCandidate #{}, chisqr = "
"{:.3f}".format(i, candidate.score))
candidate.params.pretty_print()
class Minimizer(object):
"""A general minimizer for curve fitting and optimization."""
_err_nonparam = ("params must be a minimizer.Parameters() instance or list "
"of Parameters()")
_err_maxfev = ("Too many function calls (max set to %i)! Use:"
" minimize(func, params, ..., maxfev=NNN)"
"or set leastsq_kws['maxfev'] to increase this maximum.")
def __init__(self, userfcn, params, fcn_args=None, fcn_kws=None,
iter_cb=None, scale_covar=True, nan_policy='raise',
reduce_fcn=None, **kws):
"""
Parameters
----------
userfcn : callable
Objective function that returns the residual (difference between
model and data) to be minimized in a least-squares sense. This
function must have the signature::
userfcn(params, *fcn_args, **fcn_kws)
params : :class:`~lmfit.parameter.Parameters`
Contains the Parameters for the model.
fcn_args : tuple, optional
Positional arguments to pass to `userfcn`.
fcn_kws : dict, optional
Keyword arguments to pass to `userfcn`.
iter_cb : callable, optional
Function to be called at each fit iteration. This function should
have the signature::
iter_cb(params, iter, resid, *fcn_args, **fcn_kws)
where `params` will have the current parameter values, `iter`
the iteration, `resid` the current residual array, and `*fcn_args`
and `**fcn_kws` are passed to the objective function.
scale_covar : bool, optional
Whether to automatically scale the covariance matrix (`leastsq` only).
nan_policy : str, optional
Specifies action if `userfcn` (or a Jacobian) returns NaN
values. One of:
- 'raise' : a `ValueError` is raised
- 'propagate' : the values returned from `userfcn` are un-altered
- 'omit' : non-finite values are filtered
reduce_fcn : str or callable, optional
Function to convert a residual array to a scalar value for the scalar
minimizers. Optional values are (where `r` is the residual array):
- None : sum of squares of residual [default]
= (r*r).sum()
- 'negentropy' : neg entropy, using normal distribution
= rho*log(rho).sum()`, where rho = exp(-r*r/2)/(sqrt(2*pi))
- 'neglogcauchy': neg log likelihood, using Cauchy distribution
= -log(1/(pi*(1+r*r))).sum()
- callable : must take one argument (`r`) and return a float.
**kws : dict, optional
Options to pass to the minimizer being used.
Notes
-----
The objective function should return the value to be minimized. For
the Levenberg-Marquardt algorithm from :meth:`leastsq` or
:meth:`least_squares`, this returned value must be an array, with a
length greater than or equal to the number of fitting variables in
the model. For the other methods, the return value can either be a
scalar or an array. If an array is returned, the sum of squares of
the array will be sent to the underlying fitting method, effectively
doing a least-squares optimization of the return values. If the
objective function returns non-finite values then a `ValueError`
will be raised because the underlying solvers cannot deal with them.
A common use for the `fcn_args` and `fcn_kws` would be to pass in
other data needed to calculate the residual, including such things
as the data array, dependent variable, uncertainties in the data,
and other data structures for the model calculation.
"""
self.userfcn = userfcn
self.userargs = fcn_args
if self.userargs is None:
self.userargs = []
self.userkws = fcn_kws
if self.userkws is None:
self.userkws = {}
self.kws = kws
self.iter_cb = iter_cb
self.scale_covar = scale_covar
self.nfev = 0
self.nfree = 0
self.ndata = 0
self.ier = 0
self._abort = False
self.success = True
self.errorbars = False
self.message = None
self.lmdif_message = None
self.chisqr = None
self.redchi = None
self.covar = None
self.residual = None
self.reduce_fcn = reduce_fcn
self.params = params
self.jacfcn = None
self.nan_policy = nan_policy
@property
def values(self):
"""Return Parameter values in a simple dictionary."""
return {name: p.value for name, p in self.result.params.items()}
def __residual(self, fvars, apply_bounds_transformation=True):
"""Residual function used for least-squares fit.
With the new, candidate values of `fvars` (the fitting variables),
this evaluates all parameters, including setting bounds and
evaluating constraints, and then passes those to the user-supplied
function to calculate the residual.
Parameters
----------
fvars : numpy.ndarray
Array of new parameter values suggested by the minimizer.
apply_bounds_transformation : bool, optional
Whether to apply lmfits parameter transformation to constrain
parameters (default is True). This is needed for solvers without
inbuilt support for bounds.
Returns
-------
residual : numpy.ndarray
The evaluated function values for given `fvars`.
"""
# set parameter values
if self._abort:
return None
params = self.result.params
if fvars.shape == ():
fvars = fvars.reshape((1,))
if apply_bounds_transformation:
for name, val in zip(self.result.var_names, fvars):
params[name].value = params[name].from_internal(val)
else:
for name, val in zip(self.result.var_names, fvars):
params[name].value = val
params.update_constraints()
self.result.nfev += 1
out = self.userfcn(params, *self.userargs, **self.userkws)
out = _nan_policy(out, nan_policy=self.nan_policy)
if callable(self.iter_cb):
abort = self.iter_cb(params, self.result.nfev, out,
*self.userargs, **self.userkws)
self._abort = self._abort or abort
self._abort = self._abort and self.result.nfev > len(fvars)
if not self._abort:
return np.asarray(out).ravel()
def __jacobian(self, fvars):
"""Reuturn analytical jacobian to be used with Levenberg-Marquardt.
modified 02-01-2012 by <NAME>, Aberystwyth University
modified 06-29-2015 M Newville to apply gradient scaling for
bounded variables (thanks to <NAME>, <NAME>)
"""
pars = self.result.params
grad_scale = ones_like(fvars)
for ivar, name in enumerate(self.result.var_names):
val = fvars[ivar]
pars[name].value = pars[name].from_internal(val)
grad_scale[ivar] = pars[name].scale_gradient(val)
self.result.nfev += 1
pars.update_constraints()
# compute the jacobian for "internal" unbounded variables,
# then rescale for bounded "external" variables.
jac = self.jacfcn(pars, *self.userargs, **self.userkws)
jac = _nan_policy(jac, nan_policy=self.nan_policy)
if self.col_deriv:
jac = (jac.transpose()*grad_scale).transpose()
else:
jac *= grad_scale
return jac
def penalty(self, fvars):
"""Penalty function for scalar minimizers.
Parameters
----------
fvars : numpy.ndarray
Array of values for the variable parameters.
Returns
-------
r : float
The evaluated user-supplied objective function.
If the objective function is an array of size greater than 1,
use the scalar returned by `self.reduce_fcn`. This defaults
to sum-of-squares, but can be replaced by other options.
"""
r = self.__residual(fvars)
if isinstance(r, ndarray) and r.size > 1:
r = self.reduce_fcn(r)
if isinstance(r, ndarray) and r.size > 1:
r = r.sum()
return r
def penalty_brute(self, fvars):
"""Penalty function for brute force method.
Parameters
----------
fvars : numpy.ndarray
Array of values for the variable parameters
Returns
-------
r : float
The evaluated user-supplied objective function.
If the objective function is an array of size greater than 1,
use the scalar returned by `self.reduce_fcn`. This defaults
to sum-of-squares, but can be replaced by other options.
"""
r = self.__residual(fvars, apply_bounds_transformation=False)
if isinstance(r, ndarray) and r.size > 1:
r = (r*r).sum()
return r
def prepare_fit(self, params=None):
"""Prepare parameters for fitting.
Prepares and initializes model and Parameters for subsequent
fitting. This routine prepares the conversion of :class:`Parameters`
into fit variables, organizes parameter bounds, and parses, "compiles"
and checks constrain expressions. The method also creates and returns
a new instance of a :class:`MinimizerResult` object that contains the
copy of the Parameters that will actually be varied in the fit.
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Contains the Parameters for the model; if None, then the
Parameters used to initialize the Minimizer object are used.
Returns
-------
:class:`MinimizerResult`
Notes
-----
This method is called directly by the fitting methods, and it is
generally not necessary to call this function explicitly.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
"""
# determine which parameters are actually variables
# and which are defined expressions.
self.result = MinimizerResult()
result = self.result
if params is not None:
self.params = params
if isinstance(self.params, Parameters):
result.params = deepcopy(self.params)
elif isinstance(self.params, (list, tuple)):
result.params = Parameters()
for par in self.params:
if not isinstance(par, Parameter):
raise MinimizerException(self._err_nonparam)
else:
result.params[par.name] = par
elif self.params is None:
raise MinimizerException(self._err_nonparam)
# determine which parameters are actually variables
# and which are defined expressions.
result.var_names = [] # note that this *does* belong to self...
result.init_vals = []
result.params.update_constraints()
result.nfev = 0
result.errorbars = False
result.aborted = False
for name, par in self.result.params.items():
par.stderr = None
par.correl = None
if par.expr is not None:
par.vary = False
if par.vary:
result.var_names.append(name)
result.init_vals.append(par.setup_bounds())
par.init_value = par.value
if par.name is None:
par.name = name
result.nvarys = len(result.var_names)
result.init_values = {n: v for n, v in zip(result.var_names,
result.init_vals)}
# set up reduce function for scalar minimizers
# 1. user supplied callable
# 2. string starting with 'neglogc' or 'negent'
# 3. sum of squares
if not callable(self.reduce_fcn):
if isinstance(self.reduce_fcn, six.string_types):
if self.reduce_fcn.lower().startswith('neglogc'):
self.reduce_fcn = reduce_cauchylogpdf
elif self.reduce_fcn.lower().startswith('negent'):
self.reduce_fcn = reduce_negentropy
if self.reduce_fcn is None:
self.reduce_fcn = reduce_chisquare
return result
def unprepare_fit(self):
"""Clean fit state, so that subsequent fits need to call prepare_fit().
removes AST compilations of constraint expressions.
"""
pass
def scalar_minimize(self, method='Nelder-Mead', params=None, **kws):
"""Scalar minimization using :scipydoc:`optimize.minimize`.
Perform fit with any of the scalar minimization algorithms supported by
:scipydoc:`optimize.minimize`. Default argument values are:
+-------------------------+-----------------+-----------------------------------------------------+
| :meth:`scalar_minimize` | Default Value | Description |
| arg | | |
+=========================+=================+=====================================================+
| method | ``Nelder-Mead`` | fitting method |
+-------------------------+-----------------+-----------------------------------------------------+
| tol | 1.e-7 | fitting and parameter tolerance |
+-------------------------+-----------------+-----------------------------------------------------+
| hess | None | Hessian of objective function |
+-------------------------+-----------------+-----------------------------------------------------+
Parameters
----------
method : str, optional
Name of the fitting method to use. One of:
- 'Nelder-Mead' (default)
- 'L-BFGS-B'
- 'Powell'
- 'CG'
- 'Newton-CG'
- 'COBYLA'
- 'TNC'
- 'trust-ncg'
- 'dogleg'
- 'SLSQP'
- 'differential_evolution'
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point.
**kws : dict, optional
Minimizer options pass to :scipydoc:`optimize.minimize`.
Returns
-------
:class:`MinimizerResult`
Object containing the optimized parameter and several
goodness-of-fit statistics.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
Notes
-----
If the objective function returns a NumPy array instead
of the expected scalar, the sum of squares of the array
will be used.
Note that bounds and constraints can be set on Parameters
for any of these methods, so are not supported separately
for those designed to use bounds. However, if you use the
differential_evolution method you must specify finite
(min, max) for each varying Parameter.
"""
result = self.prepare_fit(params=params)
result.method = method
vars = result.init_vals
params = result.params
fmin_kws = dict(method=method,
options={'maxiter': 1000 * (len(vars) + 1)})
fmin_kws.update(self.kws)
fmin_kws.update(kws)
# hess supported only in some methods
if 'hess' in fmin_kws and method not in ('Newton-CG',
'dogleg', 'trust-ncg'):
fmin_kws.pop('hess')
# jac supported only in some methods (and Dfun could be used...)
if 'jac' not in fmin_kws and fmin_kws.get('Dfun', None) is not None:
self.jacfcn = fmin_kws.pop('jac')
fmin_kws['jac'] = self.__jacobian
if 'jac' in fmin_kws and method not in ('CG', 'BFGS', 'Newton-CG',
'dogleg', 'trust-ncg'):
self.jacfcn = None
fmin_kws.pop('jac')
if method == 'differential_evolution':
for par in params.values():
if (par.vary and
not (np.isfinite(par.min) and np.isfinite(par.max))):
raise ValueError('differential_evolution requires finite '
'bound for all varying parameters')
_bounds = [(-np.pi / 2., np.pi / 2.)] * len(vars)
kwargs = dict(args=(), strategy='best1bin', maxiter=None,
popsize=15, tol=0.01, mutation=(0.5, 1),
recombination=0.7, seed=None, callback=None,
disp=False, polish=True, init='latinhypercube')
for k, v in fmin_kws.items():
if k in kwargs:
kwargs[k] = v
ret = differential_evolution(self.penalty, _bounds, **kwargs)
else:
ret = scipy_minimize(self.penalty, vars, **fmin_kws)
result.aborted = self._abort
self._abort = False
if isinstance(ret, dict):
for attr, value in ret.items():
setattr(result, attr, value)
else:
for attr in dir(ret):
if not attr.startswith('_'):
setattr(result, attr, getattr(ret, attr))
result.x = np.atleast_1d(result.x)
result.chisqr = result.residual = self.__residual(result.x)
result.nvarys = len(vars)
result.ndata = 1
result.nfree = 1
if isinstance(result.residual, ndarray):
result.chisqr = (result.chisqr**2).sum()
result.ndata = len(result.residual)
result.nfree = result.ndata - result.nvarys
result.redchi = result.chisqr / max(1, result.nfree)
# this is -2*loglikelihood
_neg2_log_likel = result.ndata * np.log(result.chisqr / result.ndata)
result.aic = _neg2_log_likel + 2 * result.nvarys
result.bic = _neg2_log_likel + np.log(result.ndata) * result.nvarys
return result
def emcee(self, params=None, steps=1000, nwalkers=100, burn=0, thin=1,
ntemps=1, pos=None, reuse_sampler=False, workers=1,
float_behavior='posterior', is_weighted=True, seed=None):
r"""
Bayesian sampling of the posterior distribution using `emcee`.
Bayesian sampling of the posterior distribution for the parameters
using the `emcee` Markov Chain Monte Carlo package. The method assumes
that the prior is Uniform. You need to have `emcee` installed to use
this method.
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point. If this is not specified
then the Parameters used to initialize the Minimizer object are
used.
steps : int, optional
How many samples you would like to draw from the posterior
distribution for each of the walkers?
nwalkers : int, optional
Should be set so :math:`nwalkers >> nvarys`, where `nvarys` are
the number of parameters being varied during the fit.
"Walkers are the members of the ensemble. They are almost like
separate Metropolis-Hastings chains but, of course, the proposal
distribution for a given walker depends on the positions of all
the other walkers in the ensemble." - from the `emcee` webpage.
burn : int, optional
Discard this many samples from the start of the sampling regime.
thin : int, optional
Only accept 1 in every `thin` samples.
ntemps : int, optional
If `ntemps > 1` perform a Parallel Tempering.
pos : numpy.ndarray, optional
Specify the initial positions for the sampler. If `ntemps == 1`
then `pos.shape` should be `(nwalkers, nvarys)`. Otherwise,
`(ntemps, nwalkers, nvarys)`. You can also initialise using a
previous chain that had the same `ntemps`, `nwalkers` and
`nvarys`. Note that `nvarys` may be one larger than you expect it
to be if your `userfcn` returns an array and `is_weighted is
False`.
reuse_sampler : bool, optional
If you have already run `emcee` on a given `Minimizer` object then
it possesses an internal ``sampler`` attribute. You can continue to
draw from the same sampler (retaining the chain history) if you set
this option to True. Otherwise a new sampler is created. The
`nwalkers`, `ntemps`, `pos`, and `params` keywords are ignored with
this option.
**Important**: the Parameters used to create the sampler must not
change in-between calls to `emcee`. Alteration of Parameters
would include changed ``min``, ``max``, ``vary`` and ``expr``
attributes. This may happen, for example, if you use an altered
Parameters object and call the `minimize` method in-between calls
to `emcee`.
workers : Pool-like or int, optional
For parallelization of sampling. It can be any Pool-like object
with a map method that follows the same calling sequence as the
built-in `map` function. If int is given as the argument, then a
multiprocessing-based pool is spawned internally with the
corresponding number of parallel processes. 'mpi4py'-based
parallelization and 'joblib'-based parallelization pools can also
be used here. **Note**: because of multiprocessing overhead it may
only be worth parallelising if the objective function is expensive
to calculate, or if there are a large number of objective
evaluations per step (`ntemps * nwalkers * nvarys`).
float_behavior : str, optional
Specifies meaning of the objective function output if it returns a
float. One of:
- 'posterior' - objective function returns a log-posterior
probability
- 'chi2' - objective function returns :math:`\chi^2`
See Notes for further details.
is_weighted : bool, optional
Has your objective function been weighted by measurement
uncertainties? If `is_weighted is True` then your objective
function is assumed to return residuals that have been divided by
the true measurement uncertainty `(data - model) / sigma`. If
`is_weighted is False` then the objective function is assumed to
return unweighted residuals, `data - model`. In this case `emcee`
will employ a positive measurement uncertainty during the sampling.
This measurement uncertainty will be present in the output params
and output chain with the name `__lnsigma`. A side effect of this
is that you cannot use this parameter name yourself.
**Important** this parameter only has any effect if your objective
function returns an array. If your objective function returns a
float, then this parameter is ignored. See Notes for more details.
seed : int or `numpy.random.RandomState`, optional
If `seed` is an int, a new `numpy.random.RandomState` instance is
used, seeded with `seed`.
If `seed` is already a `numpy.random.RandomState` instance, then
that `numpy.random.RandomState` instance is used.
Specify `seed` for repeatable minimizations.
Returns
-------
:class:`MinimizerResult`
MinimizerResult object containing updated params, statistics,
etc. The updated params represent the median (50th percentile) of
all the samples, whilst the parameter uncertainties are half of the
difference between the 15.87 and 84.13 percentiles.
The `MinimizerResult` also contains the ``chain``, ``flatchain``
and ``lnprob`` attributes. The ``chain`` and ``flatchain``
attributes contain the samples and have the shape
`(nwalkers, (steps - burn) // thin, nvarys)` or
`(ntemps, nwalkers, (steps - burn) // thin, nvarys)`,
depending on whether Parallel tempering was used or not.
`nvarys` is the number of parameters that are allowed to vary.
The ``flatchain`` attribute is a `pandas.DataFrame` of the
flattened chain, `chain.reshape(-1, nvarys)`. To access flattened
chain values for a particular parameter use
`result.flatchain[parname]`. The ``lnprob`` attribute contains the
log probability for each sample in ``chain``. The sample with the
highest probability corresponds to the maximum likelihood estimate.
Notes
-----
This method samples the posterior distribution of the parameters using
Markov Chain Monte Carlo. To do so it needs to calculate the
log-posterior probability of the model parameters, `F`, given the data,
`D`, :math:`\ln p(F_{true} | D)`. This 'posterior probability' is
calculated as:
.. math::
\ln p(F_{true} | D) \propto \ln p(D | F_{true}) + \ln p(F_{true})
where :math:`\ln p(D | F_{true})` is the 'log-likelihood' and
:math:`\ln p(F_{true})` is the 'log-prior'. The default log-prior
encodes prior information already known about the model. This method
assumes that the log-prior probability is `-numpy.inf` (impossible) if
the one of the parameters is outside its limits. The log-prior probability
term is zero if all the parameters are inside their bounds (known as a
uniform prior). The log-likelihood function is given by [1]_:
.. math::
\ln p(D|F_{true}) = -\frac{1}{2}\sum_n \left[\frac{(g_n(F_{true}) - D_n)^2}{s_n^2}+\ln (2\pi s_n^2)\right]
The first summand in the square brackets represents the residual for a
given datapoint (:math:`g` being the generative model, :math:`D_n` the
data and :math:`s_n` the standard deviation, or measurement
uncertainty, of the datapoint). This term represents :math:`\chi^2`
when summed over all data points.
Ideally the objective function used to create `lmfit.Minimizer` should
return the log-posterior probability, :math:`\ln p(F_{true} | D)`.
However, since the in-built log-prior term is zero, the objective
function can also just return the log-likelihood, unless you wish to
create a non-uniform prior.
If a float value is returned by the objective function then this value
is assumed by default to be the log-posterior probability, i.e.
`float_behavior is 'posterior'`. If your objective function returns
:math:`\chi^2`, then you should use a value of `'chi2'` for
`float_behavior`. `emcee` will then multiply your :math:`\chi^2` value
by -0.5 to obtain the posterior probability.
However, the default behaviour of many objective functions is to return
a vector of (possibly weighted) residuals. Therefore, if your objective
function returns a vector, `res`, then the vector is assumed to contain
the residuals. If `is_weighted is True` then your residuals are assumed
to be correctly weighted by the standard deviation (measurement
uncertainty) of the data points (`res = (data - model) / sigma`) and
the log-likelihood (and log-posterior probability) is calculated as:
`-0.5 * numpy.sum(res**2)`.
This ignores the second summand in the square brackets. Consequently,
in order to calculate a fully correct log-posterior probability value
your objective function should return a single value. If
`is_weighted is False` then the data uncertainty, `s_n`, will be
treated as a nuisance parameter and will be marginalized out. This is
achieved by employing a strictly positive uncertainty
(homoscedasticity) for each data point, :math:`s_n = \exp(\_\_lnsigma)`.
`__lnsigma` will be present in `MinimizerResult.params`, as well as
`Minimizer.chain`, `nvarys` will also be increased by one.
References
----------
.. [1] http://dan.iel.fm/emcee/current/user/line/
"""
if not HAS_EMCEE:
raise NotImplementedError('You must have emcee to use'
' the emcee method')
tparams = params
# if you're reusing the sampler then ntemps, nwalkers have to be
# determined from the previous sampling
if reuse_sampler:
if not hasattr(self, 'sampler') or not hasattr(self, '_lastpos'):
raise ValueError("You wanted to use an existing sampler, but"
"it hasn't been created yet")
if len(self._lastpos.shape) == 2:
ntemps = 1
nwalkers = self._lastpos.shape[0]
elif len(self._lastpos.shape) == 3:
ntemps = self._lastpos.shape[0]
nwalkers = self._lastpos.shape[1]
tparams = None
result = self.prepare_fit(params=tparams)
result.method = 'emcee'
params = result.params
# check if the userfcn returns a vector of residuals
out = self.userfcn(params, *self.userargs, **self.userkws)
out = np.asarray(out).ravel()
if out.size > 1 and is_weighted is False:
# we need to marginalise over a constant data uncertainty
if '__lnsigma' not in params:
# __lnsigma should already be in params if is_weighted was
# previously set to True.
params.add('__lnsigma', value=0.01, min=-np.inf, max=np.inf, vary=True)
# have to re-prepare the fit
result = self.prepare_fit(params)
params = result.params
# Removing internal parameter scaling. We could possibly keep it,
# but I don't know how this affects the emcee sampling.
bounds = []
var_arr = np.zeros(len(result.var_names))
i = 0
for par in params:
param = params[par]
if param.expr is not None:
param.vary = False
if param.vary:
var_arr[i] = param.value
i += 1
else:
# don't want to append bounds if they're not being varied.
continue
param.from_internal = lambda val: val
lb, ub = param.min, param.max
if lb is None or lb is np.nan:
lb = -np.inf
if ub is None or ub is np.nan:
ub = np.inf
bounds.append((lb, ub))
bounds = np.array(bounds)
self.nvarys = len(result.var_names)
# set up multiprocessing options for the samplers
auto_pool = None
sampler_kwargs = {}
if isinstance(workers, int) and workers > 1:
auto_pool = multiprocessing.Pool(workers)
sampler_kwargs['pool'] = auto_pool
elif hasattr(workers, 'map'):
sampler_kwargs['pool'] = workers
# function arguments for the log-probability functions
# these values are sent to the log-probability functions by the sampler.
lnprob_args = (self.userfcn, params, result.var_names, bounds)
lnprob_kwargs = {'is_weighted': is_weighted,
'float_behavior': float_behavior,
'userargs': self.userargs,
'userkws': self.userkws,
'nan_policy': self.nan_policy}
if ntemps > 1:
# the prior and likelihood function args and kwargs are the same
sampler_kwargs['loglargs'] = lnprob_args
sampler_kwargs['loglkwargs'] = lnprob_kwargs
sampler_kwargs['logpargs'] = (bounds,)
else:
sampler_kwargs['args'] = lnprob_args
sampler_kwargs['kwargs'] = lnprob_kwargs
# set up the random number generator
rng = _make_random_gen(seed)
# now initialise the samplers
if reuse_sampler:
if auto_pool is not None:
self.sampler.pool = auto_pool
p0 = self._lastpos
if p0.shape[-1] != self.nvarys:
raise ValueError("You cannot reuse the sampler if the number"
"of varying parameters has changed")
elif ntemps > 1:
# Parallel Tempering
# jitter the starting position by scaled Gaussian noise
p0 = 1 + rng.randn(ntemps, nwalkers, self.nvarys) * 1.e-4
p0 *= var_arr
self.sampler = emcee.PTSampler(ntemps, nwalkers, self.nvarys,
_lnpost, _lnprior, **sampler_kwargs)
else:
p0 = 1 + rng.randn(nwalkers, self.nvarys) * 1.e-4
p0 *= var_arr
self.sampler = emcee.EnsembleSampler(nwalkers, self.nvarys,
_lnpost, **sampler_kwargs)
# user supplies an initialisation position for the chain
# If you try to run the sampler with p0 of a wrong size then you'll get
# a ValueError. Note, you can't initialise with a position if you are
# reusing the sampler.
if pos is not None and not reuse_sampler:
tpos = np.asfarray(pos)
if p0.shape == tpos.shape:
pass
# trying to initialise with a previous chain
elif tpos.shape[0::2] == (nwalkers, self.nvarys):
tpos = tpos[:, -1, :]
# initialising with a PTsampler chain.
elif ntemps > 1 and tpos.ndim == 4:
tpos_shape = list(tpos.shape)
tpos_shape.pop(2)
if tpos_shape == (ntemps, nwalkers, self.nvarys):
tpos = tpos[..., -1, :]
else:
raise ValueError('pos should have shape (nwalkers, nvarys)'
'or (ntemps, nwalkers, nvarys) if ntemps > 1')
p0 = tpos
# if you specified a seed then you also need to seed the sampler
if seed is not None:
self.sampler.random_state = rng.get_state()
# now do a production run, sampling all the time
output = self.sampler.run_mcmc(p0, steps)
self._lastpos = output[0]
# discard the burn samples and thin
chain = self.sampler.chain[..., burn::thin, :]
lnprobability = self.sampler.lnprobability[..., burn::thin]
# take the zero'th PTsampler temperature for the parameter estimators
if ntemps > 1:
flatchain = chain[0, ...].reshape((-1, self.nvarys))
else:
flatchain = chain.reshape((-1, self.nvarys))
quantiles = np.percentile(flatchain, [15.87, 50, 84.13], axis=0)
for i, var_name in enumerate(result.var_names):
std_l, median, std_u = quantiles[:, i]
params[var_name].value = median
params[var_name].stderr = 0.5 * (std_u - std_l)
params[var_name].correl = {}
params.update_constraints()
# work out correlation coefficients
corrcoefs = np.corrcoef(flatchain.T)
for i, var_name in enumerate(result.var_names):
for j, var_name2 in enumerate(result.var_names):
if i != j:
result.params[var_name].correl[var_name2] = corrcoefs[i, j]
result.chain = np.copy(chain)
result.lnprob = np.copy(lnprobability)
result.errorbars = True
result.nvarys = len(result.var_names)
if auto_pool is not None:
auto_pool.terminate()
return result
def least_squares(self, params=None, **kws):
"""Use the `least_squares` (new in scipy 0.17) to perform a fit.
It assumes that the input Parameters have been initialized, and
a function to minimize has been properly set up.
When possible, this calculates the estimated uncertainties and
variable correlations from the covariance matrix.
This method wraps :scipydoc:`optimize.least_squares`, which
has inbuilt support for bounds and robust loss functions.
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point.
**kws : dict, optional
Minimizer options to pass to :scipydoc:`optimize.least_squares`.
Returns
-------
:class:`MinimizerResult`
Object containing the optimized parameter and several
goodness-of-fit statistics.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
"""
if not HAS_LEAST_SQUARES:
raise NotImplementedError("SciPy with a version higher than 0.17 "
"is needed for this method.")
result = self.prepare_fit(params)
result.method = 'least_squares'
replace_none = lambda x, sign: sign*np.inf if x is None else x
upper_bounds = [replace_none(i.max, 1) for i in self.params.values()]
lower_bounds = [replace_none(i.min, -1) for i in self.params.values()]
start_vals = [i.value for i in self.params.values()]
ret = least_squares(self.__residual,
start_vals,
bounds=(lower_bounds, upper_bounds),
kwargs=dict(apply_bounds_transformation=False),
**kws)
for attr in ret:
setattr(result, attr, ret[attr])
result.x = np.atleast_1d(result.x)
result.chisqr = result.residual = self.__residual(result.x, False)
result.nvarys = len(start_vals)
result.ndata = 1
result.nfree = 1
if isinstance(result.residual, ndarray):
result.chisqr = (result.chisqr**2).sum()
result.ndata = len(result.residual)
result.nfree = result.ndata - result.nvarys
result.redchi = result.chisqr / result.nfree
# this is -2*loglikelihood
_neg2_log_likel = result.ndata * np.log(result.chisqr / result.ndata)
result.aic = _neg2_log_likel + 2 * result.nvarys
result.bic = _neg2_log_likel + np.log(result.ndata) * result.nvarys
return result
def leastsq(self, params=None, **kws):
"""Use Levenberg-Marquardt minimization to perform a fit.
It assumes that the input Parameters have been initialized, and
a function to minimize has been properly set up.
When possible, this calculates the estimated uncertainties and
variable correlations from the covariance matrix.
This method calls :scipydoc:`optimize.leastsq`.
By default, numerical derivatives are used, and the following
arguments are set:
+------------------+----------------+------------------------------------------------------------+
| :meth:`leastsq` | Default Value | Description |
| arg | | |
+==================+================+============================================================+
| xtol | 1.e-7 | Relative error in the approximate solution |
+------------------+----------------+------------------------------------------------------------+
| ftol | 1.e-7 | Relative error in the desired sum of squares |
+------------------+----------------+------------------------------------------------------------+
| maxfev | 2000*(nvar+1) | Maximum number of function calls (nvar= # of variables) |
+------------------+----------------+------------------------------------------------------------+
| Dfun | None | Function to call for Jacobian calculation |
+------------------+----------------+------------------------------------------------------------+
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point.
**kws : dict, optional
Minimizer options to pass to :scipydoc:`optimize.leastsq`.
Returns
-------
:class:`MinimizerResult`
Object containing the optimized parameter
and several goodness-of-fit statistics.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
"""
result = self.prepare_fit(params=params)
result.method = 'leastsq'
vars = result.init_vals
nvars = len(vars)
lskws = dict(full_output=1, xtol=1.e-7, ftol=1.e-7, col_deriv=False,
gtol=1.e-7, maxfev=2000*(nvars+1), Dfun=None)
lskws.update(self.kws)
lskws.update(kws)
self.col_deriv = False
if lskws['Dfun'] is not None:
self.jacfcn = lskws['Dfun']
self.col_deriv = lskws['col_deriv']
lskws['Dfun'] = self.__jacobian
# suppress runtime warnings during fit and error analysis
orig_warn_settings = np.geterr()
np.seterr(all='ignore')
lsout = scipy_leastsq(self.__residual, vars, **lskws)
_best, _cov, infodict, errmsg, ier = lsout
result.aborted = self._abort
self._abort = False
result.residual = resid = infodict['fvec']
result.ier = ier
result.lmdif_message = errmsg
result.success = ier in [1, 2, 3, 4]
if result.aborted:
result.message = 'Fit aborted by user callback.'
result.success = False
elif ier in {1, 2, 3}:
result.message = 'Fit succeeded.'
elif ier == 0:
result.message = ('Invalid Input Parameters. I.e. more variables '
'than data points given, tolerance < 0.0, or '
'no data provided.')
elif ier == 4:
result.message = 'One or more variable did not affect the fit.'
elif ier == 5:
result.message = self._err_maxfev % lskws['maxfev']
else:
result.message = 'Tolerance seems to be too small.'
result.ndata = len(resid)
result.chisqr = (resid**2).sum()
result.nfree = (result.ndata - nvars)
result.redchi = result.chisqr / result.nfree
result.nvarys = nvars
# this is -2*loglikelihood
_neg2_log_likel = result.ndata * np.log(result.chisqr / result.ndata)
result.aic = _neg2_log_likel + 2 * result.nvarys
result.bic = _neg2_log_likel + np.log(result.ndata) * result.nvarys
params = result.params
# need to map _best values to params, then calculate the
# grad for the variable parameters
grad = ones_like(_best)
vbest = ones_like(_best)
# ensure that _best, vbest, and grad are not
# broken 1-element ndarrays.
if len(np.shape(_best)) == 0:
_best = np.array([_best])
if len(np.shape(vbest)) == 0:
vbest = np.array([vbest])
if len(np.shape(grad)) == 0:
grad = np.array([grad])
for ivar, name in enumerate(result.var_names):
grad[ivar] = params[name].scale_gradient(_best[ivar])
vbest[ivar] = params[name].value
# modified from <NAME>' leastsqbound.py
infodict['fjac'] = transpose(transpose(infodict['fjac']) /
take(grad, infodict['ipvt'] - 1))
rvec = dot(triu( | transpose(infodict['fjac']) | numpy.transpose |
import array
from collections import defaultdict
import ConfigParser
import cPickle as pickle
import numpy as np
import os
__author__ = '<NAME>'
__version__ = 1.0
FS_PATHS = 'FileSystemPaths'
FS_BASE_DIR = 'base_dir'
config = ConfigParser.ConfigParser()
config.read('config.ini')
EXT_INFO = 'spr'
EXT_DATA = 'sdt'
TYPES = {
0: 'B', # 'unsigned char',
2: 'i', # 'int',
3: 'f', # 'float',
5: 'd' # 'double'
}
MODE_CHIPS = 1
MODE_IMAGES = 2
MODE_TABLES = 3
BASE_PATH = config.get(FS_PATHS, FS_BASE_DIR)
paths = {
MODE_CHIPS: BASE_PATH + 'Chips',
MODE_IMAGES: BASE_PATH + 'Images',
MODE_TABLES: BASE_PATH + 'Tables'
}
def get_idx():
if os.path.isfile('idx.p'):
return pickle.load(open('idx.p'))
else:
ci = ChipsIndex()
pickle.dump(ci, open('idx.p', 'w'))
return ci
def normalize_chip(chip, mu, sigma):
A = ((chip - mu) * np.ones(chip.shape[0])) / sigma
return A
class ChipsIndex(object):
SPLIT_TRN = 'trn'
SPLIT_TST = 'tst'
SPLIT_BOTH = ['trn', 'tst']
HOM4 = ['A1', 'A2', 'A3', 'A4']
HOM38 = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6']
HOM56 = ['C1']
HET36 = ['D1', 'D2', 'D3', 'D4']
HET5 = ['E1', 'E2', 'E3', 'E4', 'E5']
ALL = ['C1', 'D4']
def __init__(self, exp='C', do_reshape=False):
self.exp = exp
self.do_reshape = do_reshape
self.vread = vread
self.x = None
self.y = None
self.i = None
self.normalized = None
self.__populate()
self.scoring = {}
self._load_scoring_table()
self.image_stats = {}
self._load_image_stats()
def _load_scoring_table(self):
with open("{0}/Experiments_Scoring_Table".format(paths[MODE_TABLES])) as fp:
data = [x for x in fp.readlines() if not x.startswith("%")]
for line in data:
exp, sub_exp, img_area, n_detection_opps = line.split()
for s in range(int(sub_exp)):
key = "{0}{1}".format(exp, s)
self.scoring[key] = {
'area': img_area,
'n_detections': n_detection_opps
}
def _load_image_stats(self):
ndim = 1024 ** 2
for i in range(1, 135):
A = np.reshape(vread('img' + str(i)), [ndim, 1])
self.image_stats[i] = (np.mean(A), np.std(A))
def __populate(self):
matches = defaultdict(dict)
for chip_name in get_chip_names():
A = vread(chip_name, MODE_CHIPS)
parts = chip_name.split("_")
exp_id, exp_letter, exp_split = parts[1], parts[2][0], parts[2][1:]
if exp_letter != self.exp: # Only interested in particular experiments
continue
if A.shape[0] % 15 != 0:
raise Exception("This says it's a C experiment, but rows % 15 != 0")
continue
windows = []
for i in range(A.shape[1]):
this_window = A[:,i]
if self.do_reshape:
this_window = np.reshape(this_window, [15, 15])
windows.append(this_window)
matches[exp_id][exp_split] = windows
self.idx = matches
def reshape(self, source, target_dims=[15, 15]):
if source.shape[0] % target_dims[0] != 0:
raise Exception("Incorrect dimensions")
return | np.reshape(source, target_dims) | numpy.reshape |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This file contains all the classes for copula objects.
"""
__author__ = "<NAME>"
__license__ = "Apache 2.0"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
from . import archimedean_generators as generators
from . import math_misc
from .math_misc import multivariate_t_distribution
from . import estimation
import numpy as np
from numpy.linalg import inv
import scipy
import scipy.misc
from scipy.stats import kendalltau, pearsonr, spearmanr, norm, t, multivariate_normal
from scipy.linalg import sqrtm
from scipy.optimize import fsolve
import scipy.integrate as integrate
# An abstract copula object
class Copula():
def __init__(self, dim=2, name='indep'):
"""
Creates a new abstract Copula.
Parameters
----------
dim : integer (greater than 1)
The dimension of the copula.
name : string
Default copula. 'indep' is for independence copula, 'frechet_up' the upper Fréchet-Hoeffding bound and 'frechet_down' the lower Fréchet-Hoeffding bound.
"""
if dim < 2 or int(dim) != dim:
raise ValueError("Copula dimension must be an integer greater than 1.")
self.dim = dim
self.name = name
self.kendall = None
self.pearson = None
self.spearman = None
def __str__(self):
return "Copula ({0}).".format(self.name)
def _check_dimension(self, x):
if len(x) != self.dim:
raise ValueError("Expected vector of dimension {0}, get vector of dimension {1}".format(self.dim, len(x)))
def dimension(self):
"""
Returns the dimension of the copula.
"""
return self.dim
def correlations(self, X):
"""
Compute the correlations of the specified data. Only available when dimension of copula is 2.
Parameters
----------
X : numpy array (of size n * 2)
Values to compute correlations.
Returns
-------
kendall : float
The Kendall tau.
pearson : float
The Pearson's R
spearman : float
The Spearman's R
"""
if self.dim != 2:
raise Exception("Correlations can not be computed when dimension is greater than 2.")
self.kendall = kendalltau(X[:,0], X[:,1])[0]
self.pearson = pearsonr(X[:,0], X[:,1])[0]
self.spearman = spearmanr(X[:,0], X[:,1])[0]
return self.kendall, self.pearson, self.spearman
def kendall(self):
"""
Returns the Kendall's tau. Note that you should previously have computed correlations.
"""
if self.kendall == None:
raise ValueError("You must compute correlations before accessing to Kendall's tau.")
return self.kendall
def pearson(self):
"""
Returns the Pearson's r. Note that you should previously have computed correlations.
"""
if self.pearson == None:
raise ValueError("You must compute correlations before accessing to Pearson's r.")
return self.pearson
def spearman(self):
"""
Returns the Spearman's rho. Note that you should previously have computed correlations.
"""
if self.pearson == None:
raise ValueError("You must compute correlations before accessing to Spearman's rho.")
return self.spearman
def cdf(self, x):
"""
Returns the cumulative distribution function (CDF) of the copula.
Parameters
----------
x : numpy array (of size d)
Values to compute CDF.
"""
self._check_dimension(x)
if self.name == 'indep':
return np.prod(x)
elif self.name == 'frechet_up':
return min(x)
elif self.name == 'frechet_down':
return max(sum(x) - self.dim + 1., 0)
def pdf(self, x):
"""
Returns the probability distribution function (PDF) of the copula.
Parameters
----------
x : numpy array (of size d)
Values to compute PDF.
"""
self._check_dimension(x)
if self.name == 'indep':
return sum([ np.prod([ x[j] for j in range(self.dim) if j != i ]) for i in range(self.dim) ])
elif self.name in [ 'frechet_down', 'frechet_up' ]:
raise NotImplementedError("PDF is not available for Fréchet-Hoeffding bounds.")
def concentration_down(self, x):
"""
Returns the theoretical lower concentration function.
Parameters
----------
x : float (between 0 and 0.5)
"""
if x > 0.5 or x < 0:
raise ValueError("The argument must be included between 0 and 0.5.")
return self.cdf([x, x]) / x
def concentration_up(self, x):
"""
Returns the theoritical upper concentration function.
Parameters
----------
x : float (between 0.5 and 1)
"""
if x < 0.5 or x > 1:
raise ValueError("The argument must be included between 0.5 and 1.")
return (1. - 2*x + self.cdf([x, x])) / (1. - x)
def concentration_function(self, x):
"""
Returns the theoritical concentration function.
Parameters
----------
x : float (between 0 and 1)
"""
if x < 0 or x > 1:
raise ValueError("The argument must be included between 0 and 1.")
if x < 0.5:
return self.concentration_down(x)
return self.concentration_up(x)
class ArchimedeanCopula(Copula):
families = [ 'clayton', 'gumbel', 'frank', 'joe', 'amh' ]
def __init__(self, family='clayton', dim=2):
"""
Creates an Archimedean copula.
Parameters
----------
family : str
The name of the copula.
dim : int
The dimension of the copula.
"""
super(ArchimedeanCopula, self).__init__(dim=dim)
self.family = family
self.parameter = 1.5
if family == 'clayton':
self.generator = generators.claytonGenerator
self.generatorInvert = generators.claytonGeneratorInvert
elif family == 'gumbel':
self.generator = generators.gumbelGenerator
self.generatorInvert = generators.gumbelGeneratorInvert
elif family == 'frank':
self.generator = generators.frankGenerator
self.generatorInvert = generators.frankGeneratorInvert
elif family == 'joe':
self.generator = generators.joeGenerator
self.generatorInvert = generators.joeGeneratorInvert
elif family == 'amh':
self.parameter = 0.5
self.generator = generators.aliMikhailHaqGenerator
self.generatorInvert = generators.aliMikhailHaqGeneratorInvert
else:
raise ValueError("The family name '{0}' is not defined.".format(family))
def __str__(self):
return "Archimedean Copula ({0}) :".format(self.family) + "\n*\tParameter : {:1.6f}".format(self.parameter)
def generator(self, x):
return self.generator(x, self.parameter)
def inverse_generator(self, x):
return self.generatorInvert(x, self.parameter)
def get_parameter(self):
return self.parameter
def set_parameter(self, theta):
self.parameter = theta
def getFamily(self):
return self.family
def _check_dimension(self, x):
"""
Check if the number of variables is equal to the dimension of the copula.
"""
if len(x) != self.dim:
raise ValueError("Expected vector of dimension {0}, get vector of dimension {1}".format(self.dim, len(x)))
def cdf(self, x):
"""
Returns the CDF of the copula.
Parameters
----------
x : numpy array (of size copula dimension or n * copula dimension)
Quantiles.
Returns
-------
float
The CDF value on x.
"""
if len(np.asarray(x).shape) > 1:
self._check_dimension(x[0])
return [ self.generatorInvert(sum([ self.generator(v, self.parameter) for v in row ]), self.parameter) for row in x ]
else:
self._check_dimension(x)
return self.generatorInvert(sum([ self.generator(v, self.parameter) for v in x ]), self.parameter)
def pdf_param(self, x, theta):
"""
Returns the PDF of the copula with the specified theta. Use this when you want to compute PDF with another parameter.
Parameters
----------
x : numpy array (of size n * copula dimension)
Quantiles.
theta : float
The custom parameter.
Returns
-------
float
The PDF value on x.
"""
self._check_dimension(x)
# prod is the product of the derivatives of the generator for each variable
prod = 1
# The sum of generators that will be computed on the invert derivative
sumInvert = 0
# The future function (if it exists) corresponding to the n-th derivative of the invert
invertNDerivative = None
# Exactly 0 causes instability during computing for these copulas
if self.family in [ "frank", "clayton"] and theta == 0:
theta = 1e-8
# For each family, the structure is the same
if self.family == 'clayton':
# We compute product and sum
for i in range(self.dim):
prod *= -x[i]**(-theta - 1.)
sumInvert += self.generator(x[i], theta)
# We define (when possible) the n-th derivative of the invert of the generator
def claytonInvertnDerivative(t, theta, order):
product = 1
for i in range(1, order):
product *= (-1. / theta - i)
if theta * t < -1:
return -theta**(order - 1) * product
return -theta**(order - 1) * product * (1. + theta * t)**(-1. / theta - order)
invertNDerivative = claytonInvertnDerivative
elif self.family == 'gumbel':
if self.dim == 2:
for i in range(self.dim):
prod *= (theta / (np.log(x[i]) * x[i]))*(-np.log(x[i]))**theta
sumInvert += self.generator(x[i], theta)
def gumbelInvertDerivative(t, theta, order):
return 1. / theta**2 * t**(1. / theta - 2.) * (theta + t**(1. / theta) - 1.) * np.exp(-t**(1. / theta))
if self.dim == 2:
invertNDerivative = gumbelInvertDerivative
elif self.family == 'frank':
if self.dim == 2:
for i in range(self.dim):
prod *= theta / (1. - np.exp(theta * x[i]))
sumInvert += self.generator(x[i], theta)
def frankInvertDerivative(t, theta, order):
C = np.exp(-theta) - 1.
return - C / theta * np.exp(t) / (C + np.exp(t))**2
invertNDerivative = frankInvertDerivative
elif self.family == 'joe':
if self.dim == 2:
for i in range(self.dim):
prod *= -theta * (1. - x[i])**(theta - 1.) / (1. - (1. - x[i])**theta)
sumInvert += self.generator(x[i], theta)
def joeInvertDerivative(t, theta, order):
return 1. / theta**2 * (1. - np.exp(-t))**(1. / theta) * (theta * np.exp(t) - 1.) / (np.exp(t) - 1.)**2
invertNDerivative = joeInvertDerivative
elif self.family == 'amh':
if self.dim == 2:
for i in range(self.dim):
prod *= (theta - 1.) / (x[i] * (1. - theta * (1. - x[i])))
sumInvert += self.generator(x[i], theta)
def amhInvertDerivative(t, theta, order):
return (1. - theta) * np.exp(t) * (theta + np.exp(t)) / (np.exp(t) - theta)**3
invertNDerivative = amhInvertDerivative
if invertNDerivative == None:
try:
invertNDerivative = lambda t, theta, order: scipy.misc.derivative(lambda x: self.generatorInvert(x, theta), t, n=order, order=order+order%2+1)
except:
raise Exception("The {0}-th derivative of the invert of the generator could not be computed.".format(self.dim))
# We compute the PDF of the copula
return prod * invertNDerivative(sumInvert, theta, self.dim)
def pdf(self, x):
return self.pdf_param(x, self.parameter)
def fit(self, X, method='cmle', verbose=False, theta_bounds=None, **kwargs):
"""
Fit the archimedean copula with specified data.
Parameters
----------
X : numpy array (of size n * copula dimension)
The data to fit.
method : str
The estimation method to use. Default is 'cmle'.
verbose : bool
Output various informations during fitting process.
theta_bounds : tuple
Definition set of theta. Use this only with custom family.
**kwargs
Arguments of method. See estimation for more details.
Returns
-------
float
The estimated parameter of the archimedean copula.
estimationData
Various data from estimation method. Often estimated hyper-parameters.
"""
n = X.shape[0]
if n < 1:
raise ValueError("At least two values are needed to fit the copula.")
self._check_dimension(X[0,:])
estimationData = None
# Moments method (only when dimension = 2)
if method == 'moments':
if self.kendall == None:
self.correlations(X)
if self.family == 'clayton':
self.parameter = 2. * self.kendall / (1. - self.kendall)
elif self.family == 'gumbel':
self.parameter = 1. / (1. - self.kendall)
elif self.family == 'frank':
def target(x):
return 1 - 4 / x + 4 / x**2 * integrate.quad(lambda t: t / (np.exp(t) - 1), np.finfo(np.float32).eps, x)[0] - self.kendall
self.parameter = fsolve(target, 1)[0]
else:
raise Exception("Moments estimation is not available for this copula.")
# Canonical Maximum Likelihood Estimation
elif method == 'cmle':
# Pseudo-observations from real data X
pobs = []
for i in range(self.dim):
order = X[:,i].argsort()
ranks = order.argsort()
u_i = [ (r + 1) / (n + 1) for r in ranks ]
pobs.append(u_i)
pobs = np.transpose(np.asarray(pobs))
is_scalar = True
theta_start = np.array(0.5)
bounds = theta_bounds
if bounds == None:
if self.family == 'amh':
bounds = (-1, 1 - 1e-6)
is_scalar = False
elif self.family == 'clayton':
bounds = (0, 10)
elif self.family in ['gumbel', 'joe'] :
bounds = (1, None)
is_scalar = False
def log_likelihood(theta):
param_obs = np.apply_along_axis(lambda x: self.pdf_param(x, theta), arr=pobs, axis=1)
return -np.log(param_obs).sum()
if self.family == 'amh':
theta_start = np.array(0.5)
elif self.family in ['gumbel', 'joe']:
theta_start = np.array(1.5)
res = estimation.cmle(log_likelihood,
theta_start=theta_start,
theta_bounds=bounds,
optimize_method=kwargs.get('optimize_method', 'Brent'),
bounded_optimize_method=kwargs.get('bounded_optimize_method', 'SLSQP'),
is_scalar=is_scalar)
self.parameter = res['x'] if is_scalar else res['x'][0]
# Maximum Likelihood Estimation and Inference Functions for Margins
elif method in [ 'mle', 'ifm' ]:
if not('marginals' in kwargs):
raise ValueError("Marginals distribution are required for MLE.")
if not('hyper_param' in kwargs):
raise ValueError("Hyper-parameters are required for MLE.")
bounds = theta_bounds
if bounds == None:
if self.family == 'amh':
bounds = (-1, 1 - 1e-6)
elif self.family == 'clayton':
bounds = (0, None)
elif self.family in ['gumbel', 'joe'] :
bounds = (1, None)
theta_start = [ 2 ]
if self.family == 'amh':
theta_start = [ 0.5 ]
if method == 'mle':
res, estimationData = estimation.mle(self, X, marginals=kwargs.get('marginals', None), hyper_param=kwargs.get('hyper_param', None), hyper_param_start=kwargs.get('hyper_param_start', None), hyper_param_bounds=kwargs.get('hyper_param_bounds', None), theta_start=theta_start, theta_bounds=bounds, optimize_method=kwargs.get('optimize_method', 'Nelder-Mead'), bounded_optimize_method=kwargs.get('bounded_optimize_method', 'SLSQP'))
else:
res, estimationData = estimation.ifm(self, X, marginals=kwargs.get('marginals', None), hyper_param=kwargs.get('hyper_param', None), hyper_param_start=kwargs.get('hyper_param_start', None), hyper_param_bounds=kwargs.get('hyper_param_bounds', None), theta_start=theta_start, theta_bounds=bounds, optimize_method=kwargs.get('optimize_method', 'Nelder-Mead'), bounded_optimize_method=kwargs.get('bounded_optimize_method', 'SLSQP'))
self.parameter = res['x'][0]
else:
raise ValueError("Method '{0}' is not defined.".format(method))
return self.parameter, estimationData
class GaussianCopula(Copula):
def __init__(self, dim=2, R=[[1, 0.5], [0.5, 1]]):
super(GaussianCopula, self).__init__(dim=dim)
self.set_corr(R)
def __str__(self):
return "Gaussian Copula :\n*Correlation : \n" + str(self.R)
def cdf(self, x):
self._check_dimension(x)
return multivariate_normal.cdf([ norm.ppf(u) for u in x ], cov=self.R)
def set_corr(self, R):
"""
Set the Correlation matrix of the copula.
Parameters
----------
R : numpy array (of size copula dimensions * copula dimension)
The definite positive correlation matrix. Note that you should check yourself if the matrix is definite positive.
"""
S = np.asarray(R)
if len(S.shape) > 2:
raise ValueError("2-dimensional array expected, get {0}-dimensional array.".format(len(S.shape)))
if S.shape[0] != S.shape[1]:
raise ValueError("Correlation matrix must be a squared matrix of dimension {0}".format(self.dim))
if not(np.array_equal(np.transpose(S), S)):
raise ValueError("Correlation matrix is not symmetric.")
self.R = S
self._R_det = np.linalg.det(S)
self._R_inv = np.linalg.inv(S)
def get_corr(self):
return self.R
def pdf(self, x):
self._check_dimension(x)
u_i = norm.ppf(x)
return self._R_det**(-0.5) * np.exp(-0.5 * np.dot(u_i, np.dot(self._R_inv - np.identity(self.dim), u_i)))
def pdf_param(self, x, R):
self._check_dimension(x)
if self.dim == 2 and not(hasattr(R, '__len__')):
R = [R]
if len(np.asarray(R).shape) == 2 and len(R) != self.dim:
raise ValueError("Expected covariance matrix of dimension {0}.".format(self.dim))
u = norm.ppf(x)
cov = np.ones([ self.dim, self.dim ])
idx = 0
if len( | np.asarray(R) | numpy.asarray |
# This module has been generated automatically from space group information
# obtained from the Computational Crystallography Toolbox
#
"""
Space groups
This module contains a list of all the 230 space groups that can occur in
a crystal. The variable space_groups contains a dictionary that maps
space group numbers and space group names to the corresponding space
group objects.
.. moduleauthor:: <NAME> <<EMAIL>>
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2013 The Mosaic Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file LICENSE.txt, distributed as part of this software.
#-----------------------------------------------------------------------------
import numpy as N
class SpaceGroup(object):
"""
Space group
All possible space group objects are created in this module. Other
modules should access these objects through the dictionary
space_groups rather than create their own space group objects.
"""
def __init__(self, number, symbol, transformations):
"""
:param number: the number assigned to the space group by
international convention
:type number: int
:param symbol: the Hermann-Mauguin space-group symbol as used
in PDB and mmCIF files
:type symbol: str
:param transformations: a list of space group transformations,
each consisting of a tuple of three
integer arrays (rot, tn, td), where
rot is the rotation matrix and tn/td
are the numerator and denominator of the
translation vector. The transformations
are defined in fractional coordinates.
:type transformations: list
"""
self.number = number
self.symbol = symbol
self.transformations = transformations
self.transposed_rotations = N.array([N.transpose(t[0])
for t in transformations])
self.phase_factors = N.exp(N.array([(-2j*N.pi*t[1])/t[2]
for t in transformations]))
def __repr__(self):
return "SpaceGroup(%d, %s)" % (self.number, repr(self.symbol))
def __len__(self):
"""
:return: the number of space group transformations
:rtype: int
"""
return len(self.transformations)
def symmetryEquivalentMillerIndices(self, hkl):
"""
:param hkl: a set of Miller indices
:type hkl: Scientific.N.array_type
:return: a tuple (miller_indices, phase_factor) of two arrays
of length equal to the number of space group
transformations. miller_indices contains the Miller
indices of each reflection equivalent by symmetry to the
reflection hkl (including hkl itself as the first element).
phase_factor contains the phase factors that must be applied
to the structure factor of reflection hkl to obtain the
structure factor of the symmetry equivalent reflection.
:rtype: tuple
"""
hkls = N.dot(self.transposed_rotations, hkl)
p = N.multiply.reduce(self.phase_factors**hkl, -1)
return hkls, p
space_groups = {}
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(1, 'P 1', transformations)
space_groups[1] = sg
space_groups['P 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(2, 'P -1', transformations)
space_groups[2] = sg
space_groups['P -1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(3, 'P 1 2 1', transformations)
space_groups[3] = sg
space_groups['P 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(4, 'P 1 21 1', transformations)
space_groups[4] = sg
space_groups['P 1 21 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(5, 'C 1 2 1', transformations)
space_groups[5] = sg
space_groups['C 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(6, 'P 1 m 1', transformations)
space_groups[6] = sg
space_groups['P 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(7, 'P 1 c 1', transformations)
space_groups[7] = sg
space_groups['P 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(8, 'C 1 m 1', transformations)
space_groups[8] = sg
space_groups['C 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(9, 'C 1 c 1', transformations)
space_groups[9] = sg
space_groups['C 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(10, 'P 1 2/m 1', transformations)
space_groups[10] = sg
space_groups['P 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(11, 'P 1 21/m 1', transformations)
space_groups[11] = sg
space_groups['P 1 21/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(12, 'C 1 2/m 1', transformations)
space_groups[12] = sg
space_groups['C 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(13, 'P 1 2/c 1', transformations)
space_groups[13] = sg
space_groups['P 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(14, 'P 1 21/c 1', transformations)
space_groups[14] = sg
space_groups['P 1 21/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(15, 'C 1 2/c 1', transformations)
space_groups[15] = sg
space_groups['C 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(16, 'P 2 2 2', transformations)
space_groups[16] = sg
space_groups['P 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(17, 'P 2 2 21', transformations)
space_groups[17] = sg
space_groups['P 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(18, 'P 21 21 2', transformations)
space_groups[18] = sg
space_groups['P 21 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(19, 'P 21 21 21', transformations)
space_groups[19] = sg
space_groups['P 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(20, 'C 2 2 21', transformations)
space_groups[20] = sg
space_groups['C 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(21, 'C 2 2 2', transformations)
space_groups[21] = sg
space_groups['C 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(22, 'F 2 2 2', transformations)
space_groups[22] = sg
space_groups['F 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(23, 'I 2 2 2', transformations)
space_groups[23] = sg
space_groups['I 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(24, 'I 21 21 21', transformations)
space_groups[24] = sg
space_groups['I 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(25, 'P m m 2', transformations)
space_groups[25] = sg
space_groups['P m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(26, 'P m c 21', transformations)
space_groups[26] = sg
space_groups['P m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(27, 'P c c 2', transformations)
space_groups[27] = sg
space_groups['P c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(28, 'P m a 2', transformations)
space_groups[28] = sg
space_groups['P m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(29, 'P c a 21', transformations)
space_groups[29] = sg
space_groups['P c a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(30, 'P n c 2', transformations)
space_groups[30] = sg
space_groups['P n c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(31, 'P m n 21', transformations)
space_groups[31] = sg
space_groups['P m n 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(32, 'P b a 2', transformations)
space_groups[32] = sg
space_groups['P b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(33, 'P n a 21', transformations)
space_groups[33] = sg
space_groups['P n a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(34, 'P n n 2', transformations)
space_groups[34] = sg
space_groups['P n n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(35, 'C m m 2', transformations)
space_groups[35] = sg
space_groups['C m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(36, 'C m c 21', transformations)
space_groups[36] = sg
space_groups['C m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(37, 'C c c 2', transformations)
space_groups[37] = sg
space_groups['C c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(38, 'A m m 2', transformations)
space_groups[38] = sg
space_groups['A m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(39, 'A b m 2', transformations)
space_groups[39] = sg
space_groups['A b m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(40, 'A m a 2', transformations)
space_groups[40] = sg
space_groups['A m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(41, 'A b a 2', transformations)
space_groups[41] = sg
space_groups['A b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(42, 'F m m 2', transformations)
space_groups[42] = sg
space_groups['F m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(43, 'F d d 2', transformations)
space_groups[43] = sg
space_groups['F d d 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(44, 'I m m 2', transformations)
space_groups[44] = sg
space_groups['I m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(45, 'I b a 2', transformations)
space_groups[45] = sg
space_groups['I b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(46, 'I m a 2', transformations)
space_groups[46] = sg
space_groups['I m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(47, 'P m m m', transformations)
space_groups[47] = sg
space_groups['P m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(48, 'P n n n :2', transformations)
space_groups[48] = sg
space_groups['P n n n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(49, 'P c c m', transformations)
space_groups[49] = sg
space_groups['P c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(50, 'P b a n :2', transformations)
space_groups[50] = sg
space_groups['P b a n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(51, 'P m m a', transformations)
space_groups[51] = sg
space_groups['P m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(52, 'P n n a', transformations)
space_groups[52] = sg
space_groups['P n n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(53, 'P m n a', transformations)
space_groups[53] = sg
space_groups['P m n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(54, 'P c c a', transformations)
space_groups[54] = sg
space_groups['P c c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(55, 'P b a m', transformations)
space_groups[55] = sg
space_groups['P b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(56, 'P c c n', transformations)
space_groups[56] = sg
space_groups['P c c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(57, 'P b c m', transformations)
space_groups[57] = sg
space_groups['P b c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(58, 'P n n m', transformations)
space_groups[58] = sg
space_groups['P n n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(59, 'P m m n :2', transformations)
space_groups[59] = sg
space_groups['P m m n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(60, 'P b c n', transformations)
space_groups[60] = sg
space_groups['P b c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(61, 'P b c a', transformations)
space_groups[61] = sg
space_groups['P b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(62, 'P n m a', transformations)
space_groups[62] = sg
space_groups['P n m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(63, 'C m c m', transformations)
space_groups[63] = sg
space_groups['C m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(64, 'C m c a', transformations)
space_groups[64] = sg
space_groups['C m c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(65, 'C m m m', transformations)
space_groups[65] = sg
space_groups['C m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(66, 'C c c m', transformations)
space_groups[66] = sg
space_groups['C c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(67, 'C m m a', transformations)
space_groups[67] = sg
space_groups['C m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(68, 'C c c a :2', transformations)
space_groups[68] = sg
space_groups['C c c a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(69, 'F m m m', transformations)
space_groups[69] = sg
space_groups['F m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(70, 'F d d d :2', transformations)
space_groups[70] = sg
space_groups['F d d d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(71, 'I m m m', transformations)
space_groups[71] = sg
space_groups['I m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(72, 'I b a m', transformations)
space_groups[72] = sg
space_groups['I b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(73, 'I b c a', transformations)
space_groups[73] = sg
space_groups['I b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(74, 'I m m a', transformations)
space_groups[74] = sg
space_groups['I m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(75, 'P 4', transformations)
space_groups[75] = sg
space_groups['P 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(76, 'P 41', transformations)
space_groups[76] = sg
space_groups['P 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(77, 'P 42', transformations)
space_groups[77] = sg
space_groups['P 42'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(78, 'P 43', transformations)
space_groups[78] = sg
space_groups['P 43'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(79, 'I 4', transformations)
space_groups[79] = sg
space_groups['I 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(80, 'I 41', transformations)
space_groups[80] = sg
space_groups['I 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(81, 'P -4', transformations)
space_groups[81] = sg
space_groups['P -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(82, 'I -4', transformations)
space_groups[82] = sg
space_groups['I -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(83, 'P 4/m', transformations)
space_groups[83] = sg
space_groups['P 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(84, 'P 42/m', transformations)
space_groups[84] = sg
space_groups['P 42/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(85, 'P 4/n :2', transformations)
space_groups[85] = sg
space_groups['P 4/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(86, 'P 42/n :2', transformations)
space_groups[86] = sg
space_groups['P 42/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(87, 'I 4/m', transformations)
space_groups[87] = sg
space_groups['I 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(88, 'I 41/a :2', transformations)
space_groups[88] = sg
space_groups['I 41/a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(89, 'P 4 2 2', transformations)
space_groups[89] = sg
space_groups['P 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(90, 'P 4 21 2', transformations)
space_groups[90] = sg
space_groups['P 4 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(91, 'P 41 2 2', transformations)
space_groups[91] = sg
space_groups['P 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(92, 'P 41 21 2', transformations)
space_groups[92] = sg
space_groups['P 41 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(93, 'P 42 2 2', transformations)
space_groups[93] = sg
space_groups['P 42 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(94, 'P 42 21 2', transformations)
space_groups[94] = sg
space_groups['P 42 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(95, 'P 43 2 2', transformations)
space_groups[95] = sg
space_groups['P 43 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(96, 'P 43 21 2', transformations)
space_groups[96] = sg
space_groups['P 43 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(97, 'I 4 2 2', transformations)
space_groups[97] = sg
space_groups['I 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(98, 'I 41 2 2', transformations)
space_groups[98] = sg
space_groups['I 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(99, 'P 4 m m', transformations)
space_groups[99] = sg
space_groups['P 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(100, 'P 4 b m', transformations)
space_groups[100] = sg
space_groups['P 4 b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(101, 'P 42 c m', transformations)
space_groups[101] = sg
space_groups['P 42 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(102, 'P 42 n m', transformations)
space_groups[102] = sg
space_groups['P 42 n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(103, 'P 4 c c', transformations)
space_groups[103] = sg
space_groups['P 4 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(104, 'P 4 n c', transformations)
space_groups[104] = sg
space_groups['P 4 n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(105, 'P 42 m c', transformations)
space_groups[105] = sg
space_groups['P 42 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(106, 'P 42 b c', transformations)
space_groups[106] = sg
space_groups['P 42 b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(107, 'I 4 m m', transformations)
space_groups[107] = sg
space_groups['I 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(108, 'I 4 c m', transformations)
space_groups[108] = sg
space_groups['I 4 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(109, 'I 41 m d', transformations)
space_groups[109] = sg
space_groups['I 41 m d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(110, 'I 41 c d', transformations)
space_groups[110] = sg
space_groups['I 41 c d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(111, 'P -4 2 m', transformations)
space_groups[111] = sg
space_groups['P -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(112, 'P -4 2 c', transformations)
space_groups[112] = sg
space_groups['P -4 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(113, 'P -4 21 m', transformations)
space_groups[113] = sg
space_groups['P -4 21 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(114, 'P -4 21 c', transformations)
space_groups[114] = sg
space_groups['P -4 21 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(115, 'P -4 m 2', transformations)
space_groups[115] = sg
space_groups['P -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(116, 'P -4 c 2', transformations)
space_groups[116] = sg
space_groups['P -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(117, 'P -4 b 2', transformations)
space_groups[117] = sg
space_groups['P -4 b 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(118, 'P -4 n 2', transformations)
space_groups[118] = sg
space_groups['P -4 n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(119, 'I -4 m 2', transformations)
space_groups[119] = sg
space_groups['I -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(120, 'I -4 c 2', transformations)
space_groups[120] = sg
space_groups['I -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(121, 'I -4 2 m', transformations)
space_groups[121] = sg
space_groups['I -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(122, 'I -4 2 d', transformations)
space_groups[122] = sg
space_groups['I -4 2 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(123, 'P 4/m m m', transformations)
space_groups[123] = sg
space_groups['P 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(124, 'P 4/m c c', transformations)
space_groups[124] = sg
space_groups['P 4/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(125, 'P 4/n b m :2', transformations)
space_groups[125] = sg
space_groups['P 4/n b m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(126, 'P 4/n n c :2', transformations)
space_groups[126] = sg
space_groups['P 4/n n c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(127, 'P 4/m b m', transformations)
space_groups[127] = sg
space_groups['P 4/m b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(128, 'P 4/m n c', transformations)
space_groups[128] = sg
space_groups['P 4/m n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(129, 'P 4/n m m :2', transformations)
space_groups[129] = sg
space_groups['P 4/n m m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(130, 'P 4/n c c :2', transformations)
space_groups[130] = sg
space_groups['P 4/n c c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(131, 'P 42/m m c', transformations)
space_groups[131] = sg
space_groups['P 42/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(132, 'P 42/m c m', transformations)
space_groups[132] = sg
space_groups['P 42/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(133, 'P 42/n b c :2', transformations)
space_groups[133] = sg
space_groups['P 42/n b c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(134, 'P 42/n n m :2', transformations)
space_groups[134] = sg
space_groups['P 42/n n m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(135, 'P 42/m b c', transformations)
space_groups[135] = sg
space_groups['P 42/m b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(136, 'P 42/m n m', transformations)
space_groups[136] = sg
space_groups['P 42/m n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(137, 'P 42/n m c :2', transformations)
space_groups[137] = sg
space_groups['P 42/n m c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(138, 'P 42/n c m :2', transformations)
space_groups[138] = sg
space_groups['P 42/n c m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(139, 'I 4/m m m', transformations)
space_groups[139] = sg
space_groups['I 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(140, 'I 4/m c m', transformations)
space_groups[140] = sg
space_groups['I 4/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(141, 'I 41/a m d :2', transformations)
space_groups[141] = sg
space_groups['I 41/a m d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(142, 'I 41/a c d :2', transformations)
space_groups[142] = sg
space_groups['I 41/a c d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(143, 'P 3', transformations)
space_groups[143] = sg
space_groups['P 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(144, 'P 31', transformations)
space_groups[144] = sg
space_groups['P 31'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(145, 'P 32', transformations)
space_groups[145] = sg
space_groups['P 32'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(146, 'R 3 :H', transformations)
space_groups[146] = sg
space_groups['R 3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(147, 'P -3', transformations)
space_groups[147] = sg
space_groups['P -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(148, 'R -3 :H', transformations)
space_groups[148] = sg
space_groups['R -3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(149, 'P 3 1 2', transformations)
space_groups[149] = sg
space_groups['P 3 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(150, 'P 3 2 1', transformations)
space_groups[150] = sg
space_groups['P 3 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(151, 'P 31 1 2', transformations)
space_groups[151] = sg
space_groups['P 31 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(152, 'P 31 2 1', transformations)
space_groups[152] = sg
space_groups['P 31 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(153, 'P 32 1 2', transformations)
space_groups[153] = sg
space_groups['P 32 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(154, 'P 32 2 1', transformations)
space_groups[154] = sg
space_groups['P 32 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(155, 'R 3 2 :H', transformations)
space_groups[155] = sg
space_groups['R 3 2 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(156, 'P 3 m 1', transformations)
space_groups[156] = sg
space_groups['P 3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(157, 'P 3 1 m', transformations)
space_groups[157] = sg
space_groups['P 3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(158, 'P 3 c 1', transformations)
space_groups[158] = sg
space_groups['P 3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(159, 'P 3 1 c', transformations)
space_groups[159] = sg
space_groups['P 3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(160, 'R 3 m :H', transformations)
space_groups[160] = sg
space_groups['R 3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(161, 'R 3 c :H', transformations)
space_groups[161] = sg
space_groups['R 3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(162, 'P -3 1 m', transformations)
space_groups[162] = sg
space_groups['P -3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(163, 'P -3 1 c', transformations)
space_groups[163] = sg
space_groups['P -3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(164, 'P -3 m 1', transformations)
space_groups[164] = sg
space_groups['P -3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(165, 'P -3 c 1', transformations)
space_groups[165] = sg
space_groups['P -3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(166, 'R -3 m :H', transformations)
space_groups[166] = sg
space_groups['R -3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(167, 'R -3 c :H', transformations)
space_groups[167] = sg
space_groups['R -3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(168, 'P 6', transformations)
space_groups[168] = sg
space_groups['P 6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(169, 'P 61', transformations)
space_groups[169] = sg
space_groups['P 61'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(170, 'P 65', transformations)
space_groups[170] = sg
space_groups['P 65'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(171, 'P 62', transformations)
space_groups[171] = sg
space_groups['P 62'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(172, 'P 64', transformations)
space_groups[172] = sg
space_groups['P 64'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(173, 'P 63', transformations)
space_groups[173] = sg
space_groups['P 63'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(174, 'P -6', transformations)
space_groups[174] = sg
space_groups['P -6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(175, 'P 6/m', transformations)
space_groups[175] = sg
space_groups['P 6/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(176, 'P 63/m', transformations)
space_groups[176] = sg
space_groups['P 63/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(177, 'P 6 2 2', transformations)
space_groups[177] = sg
space_groups['P 6 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(178, 'P 61 2 2', transformations)
space_groups[178] = sg
space_groups['P 61 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(179, 'P 65 2 2', transformations)
space_groups[179] = sg
space_groups['P 65 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(180, 'P 62 2 2', transformations)
space_groups[180] = sg
space_groups['P 62 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(181, 'P 64 2 2', transformations)
space_groups[181] = sg
space_groups['P 64 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(182, 'P 63 2 2', transformations)
space_groups[182] = sg
space_groups['P 63 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(183, 'P 6 m m', transformations)
space_groups[183] = sg
space_groups['P 6 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(184, 'P 6 c c', transformations)
space_groups[184] = sg
space_groups['P 6 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(185, 'P 63 c m', transformations)
space_groups[185] = sg
space_groups['P 63 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(186, 'P 63 m c', transformations)
space_groups[186] = sg
space_groups['P 63 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(187, 'P -6 m 2', transformations)
space_groups[187] = sg
space_groups['P -6 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(188, 'P -6 c 2', transformations)
space_groups[188] = sg
space_groups['P -6 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(189, 'P -6 2 m', transformations)
space_groups[189] = sg
space_groups['P -6 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(190, 'P -6 2 c', transformations)
space_groups[190] = sg
space_groups['P -6 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(191, 'P 6/m m m', transformations)
space_groups[191] = sg
space_groups['P 6/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(192, 'P 6/m c c', transformations)
space_groups[192] = sg
space_groups['P 6/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(193, 'P 63/m c m', transformations)
space_groups[193] = sg
space_groups['P 63/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(194, 'P 63/m m c', transformations)
space_groups[194] = sg
space_groups['P 63/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(195, 'P 2 3', transformations)
space_groups[195] = sg
space_groups['P 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(196, 'F 2 3', transformations)
space_groups[196] = sg
space_groups['F 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(197, 'I 2 3', transformations)
space_groups[197] = sg
space_groups['I 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(198, 'P 21 3', transformations)
space_groups[198] = sg
space_groups['P 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(199, 'I 21 3', transformations)
space_groups[199] = sg
space_groups['I 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(200, 'P m -3', transformations)
space_groups[200] = sg
space_groups['P m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(201, 'P n -3 :2', transformations)
space_groups[201] = sg
space_groups['P n -3 :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(202, 'F m -3', transformations)
space_groups[202] = sg
space_groups['F m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(203, 'F d -3 :2', transformations)
space_groups[203] = sg
space_groups['F d -3 :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(204, 'I m -3', transformations)
space_groups[204] = sg
space_groups['I m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(205, 'P a -3', transformations)
space_groups[205] = sg
space_groups['P a -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(206, 'I a -3', transformations)
space_groups[206] = sg
space_groups['I a -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(207, 'P 4 3 2', transformations)
space_groups[207] = sg
space_groups['P 4 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(208, 'P 42 3 2', transformations)
space_groups[208] = sg
space_groups['P 42 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(209, 'F 4 3 2', transformations)
space_groups[209] = sg
space_groups['F 4 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(210, 'F 41 3 2', transformations)
space_groups[210] = sg
space_groups['F 41 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(211, 'I 4 3 2', transformations)
space_groups[211] = sg
space_groups['I 4 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(212, 'P 43 3 2', transformations)
space_groups[212] = sg
space_groups['P 43 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(213, 'P 41 3 2', transformations)
space_groups[213] = sg
space_groups['P 41 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(214, 'I 41 3 2', transformations)
space_groups[214] = sg
space_groups['I 41 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(215, 'P -4 3 m', transformations)
space_groups[215] = sg
space_groups['P -4 3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(216, 'F -4 3 m', transformations)
space_groups[216] = sg
space_groups['F -4 3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(217, 'I -4 3 m', transformations)
space_groups[217] = sg
space_groups['I -4 3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(218, 'P -4 3 n', transformations)
space_groups[218] = sg
space_groups['P -4 3 n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(219, 'F -4 3 c', transformations)
space_groups[219] = sg
space_groups['F -4 3 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(220, 'I -4 3 d', transformations)
space_groups[220] = sg
space_groups['I -4 3 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(221, 'P m -3 m', transformations)
space_groups[221] = sg
space_groups['P m -3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(222, 'P n -3 n :2', transformations)
space_groups[222] = sg
space_groups['P n -3 n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(223, 'P m -3 n', transformations)
space_groups[223] = sg
space_groups['P m -3 n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(224, 'P n -3 m :2', transformations)
space_groups[224] = sg
space_groups['P n -3 m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(225, 'F m -3 m', transformations)
space_groups[225] = sg
space_groups['F m -3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = | N.array([1,0,1]) | numpy.array |
import trimesh
import os
import numpy as np
import xml.etree.ElementTree as ET
def generate_grasp_env(model_path, obj_index, out_path):
# step 0: read file
obj_index = str(obj_index).zfill(3)
mesh = trimesh.load(os.path.join(model_path, os.path.join(obj_index, obj_index+'.obj')))
# step 2: write as stl file
new_model_path = os.path.join(model_path, os.path.join(obj_index, obj_index+'.stl'))
mesh.export(new_model_path)
# step 3: record center of mass and box size
convex_com = mesh.center_mass
half_length = mesh.bounding_box.primitive.extents * 0.5
scale = np.random.uniform(0.02, 0.04)/np.median(half_length)
convex_com *= scale
half_length *= scale
# step 4: read template, change template and write to xml
tree = ET.parse(os.path.join("../fetch/random_obj_xml", "grasp_template.xml"))
root = tree.getroot()
root[3][0].attrib["file"] = os.path.join("..", new_model_path)
root[3][0].attrib["scale"] = str(scale) + ' ' + str(scale) + ' ' + str(scale)
# root[3][0].attrib -- {'file': path, 'name': 'obj0', 'scale': scale}
root[4][4].attrib["pos"] = str(half_length[0]) + ' ' + str(half_length[1]) + ' ' + str(half_length[2])
root[4][4][2].attrib["pos"] = str(convex_com[0]) + ' ' + str(convex_com[1]) + ' ' + str(convex_com[2])
root[4][4][2].attrib["size"] = str(half_length[0]/2) + ' ' + str(half_length[1]/2) + ' ' + str(half_length[2]/2)
# root[4][4][2].attrib["pos"] = str(convex_com[0]) + ' ' + str(convex_com[1]) + ' ' + str(convex_com[2])
# root[4][4][2].attrib -- {'type': 'box', 'size': bbox size, 'pos': centroid, 'rgba': '1 0 0 0', 'condim': '3', 'material': 'block_mat', 'mass': '2'}
tree.write(out_path)
def generate_peg_env(model_path, obj_index, out_path):
# step 0: read file
obj_index = str(obj_index).zfill(3)
mesh = trimesh.load(os.path.join(model_path, os.path.join(obj_index, obj_index+'.obj')))
# step 2: write as stl file
new_model_path = os.path.join(model_path, os.path.join(obj_index, obj_index+'.stl'))
mesh.export(new_model_path)
# step 3: record center of mass and box size
convex_com = mesh.center_mass
half_length = mesh.bounding_box.primitive.extents * 0.5
scale = 0.04/np.max(half_length)
convex_com *= scale
half_length *= scale
zaxis = np.zeros(3)
zaxis[ | np.argmin(half_length) | numpy.argmin |
import json
import os
import re
from collections import namedtuple
import numpy as np
ALGORITHMS = [method + '-' + device_type
for device_type in ['CPU', 'GPU']
for method in ['catboost', 'xgboost', 'lightgbm']]
TIME_REGEX = r'Time: \[\s*(\d+\.?\d*)\s*\]\t'
ELAPSED_REGEX = re.compile(r'Elapsed: (\d+\.?\d*)')
LOG_LINE_REGEX = {
'lightgbm': re.compile(TIME_REGEX + r'\[(\d+)\]\tvalid_0\'s (\w+): (\d+\.?\d*)'),
'xgboost': re.compile(TIME_REGEX + r'\[(\d+)\]\t([a-zA-Z\-]+):(\d+\.?\d*)'),
'catboost': re.compile(TIME_REGEX + r'(\d+)'),
'catboost-tsv': re.compile(r'(\d+)(\t(\d+\.?\d*))+\n')
}
class Track:
param_regex = re.compile(r'(\w+)\[(\d+\.?\d*)\]')
def __init__(self, algorithm_name, experiment_name, task_type, parameters_str, time_series, scores, duration):
self.log_name = parameters_str
self.algorithm_name = algorithm_name
self.scores = scores
self.experiment_name = experiment_name
self.task_type = task_type
self.duration = duration
self.parameters_str = parameters_str
assert len(time_series), "Empty time series may indicate that this benchmark failed to parse logs for " + str(algorithm_name)
for i in range(1, time_series.shape[0]):
if time_series[i] - time_series[i - 1] < 0.:
time_series[i:] = time_series[i:] + 60.
dur_series = time_series[-1] - time_series[0]
diff_elapsed_time = np.abs(dur_series - duration)
if diff_elapsed_time > 100:
print(parameters_str)
print('WARNING: difference ' + str(diff_elapsed_time) + ' in calculated duration may indicate broken log.')
self.time_series = time_series
assert(np.all(self.time_series - self.time_series[0] >= 0.))
self.time_per_iter = time_series[1:] - time_series[:-1]
params = Track.param_regex.findall(parameters_str)
param_keys = []
param_values = []
for param in sorted(params, key=lambda x: x[0]):
param_keys.append(param[0])
param_values.append(float(param[1]))
self.params_type = namedtuple('Params', param_keys)
self.params = self.params_type(*param_values)
self.params_dict = {key: value for key, value in zip(param_keys, param_values)}
def __str__(self):
params_str = ''
for i, field in enumerate(self.params._fields):
if field == 'iterations':
continue
params_str += ', ' + field + ':' + str(self.params[i])
return self.algorithm_name + params_str
def __eq__(self, other):
return self.algorithm_name == other.owner_name and self.params == other.params
@staticmethod
def hash(experiment_name, algorithm_name, task_type, parameters_str):
return hash(experiment_name + algorithm_name + task_type + parameters_str)
def __hash__(self):
return Track.hash(self.experiment_name, self.algorithm_name, self.task_type, self.parameters_str)
def dump_to_json(self):
return {
self.__hash__(): {
"dataset": self.experiment_name,
"algorithm_name": self.algorithm_name,
"task_type": self.task_type,
"parameters": self.parameters_str,
"scores": list(self.scores),
"time_series": list(self.time_series),
"duration": self.duration
}
}
def get_series(self):
return self.time_series, self.scores
def get_time_per_iter(self):
return self.time_per_iter
def get_median_time_per_iter(self):
return np.median(self.time_per_iter)
def get_fit_iterations(self):
return self.time_series.shape[0]
def get_best_score(self):
return np.min(self.scores)
TASK_TYPES_ACCURACY = ['binclass', 'multiclass']
METRIC_NAME = {
'lightgbm': {'regression': 'rmse', 'binclass': 'binary_error', 'multiclass': 'multi_error'},
'xgboost': {'regression': 'eval-rmse', 'binclass': 'eval-error', 'multiclass': 'eval-merror'},
'catboost': {'regression': 'RMSE', 'binclass': 'Accuracy', 'multiclass': 'Accuracy'}
}
def parse_catboost_log(test_error_file, task_type, iterations):
values = []
with open(test_error_file) as metric_log:
file_content = metric_log.read()
first_line_idx = file_content.find('\n')
first_line = file_content[:first_line_idx]
header = first_line.split('\t')
column_idx = header.index(METRIC_NAME['catboost'][task_type])
regex = LOG_LINE_REGEX['catboost-tsv']
matches = regex.findall(file_content)
if len(matches) != int(iterations):
print('WARNING: Broken log file (num matches not equal num iterations): ' + test_error_file)
for match in matches:
value = float(match[column_idx])
if task_type in TASK_TYPES_ACCURACY:
# Convert to error
value = 1. - value
values.append(value)
return values
def parse_log(algorithm_name, experiment_name, task_type, params_str, file_name, iterations):
time_series = []
values = []
algorithm = algorithm_name.rstrip('-CPU|GPU')
if algorithm == 'catboost':
catboost_train_dir = file_name + 'dir'
test_error_file = os.path.join(catboost_train_dir, 'test_error.tsv')
values = parse_catboost_log(test_error_file, task_type, iterations)
with open(file_name, 'r') as log:
file_content = log.read()
regex = LOG_LINE_REGEX[algorithm]
matches = regex.findall(file_content)
if len(matches) != int(iterations):
print('WARNING: Broken log file ' + file_name)
for i, match in enumerate(matches):
time_series.append(float(match[0]))
if algorithm in ['lightgbm', 'xgboost']:
metric = match[2]
# Sanity check on parsed metric
assert metric == METRIC_NAME[algorithm][task_type]
values.append(float(match[3]))
duration = ELAPSED_REGEX.findall(file_content)
duration = float(duration[0]) if len(duration) > 0 else 0.
return Track(algorithm_name, experiment_name, task_type, params_str,
np.array(time_series), | np.array(values) | numpy.array |
import numpy as np
from tidepool_data_science_models.models.simple_metabolism_model import SimpleMetabolismModel
def get_bgri(bg_df):
# Calculate LBGI and HBGI using equation from
# <NAME>., & <NAME>. (2009)
bgs = bg_df.copy()
bgs[bgs < 1] = 1 # this is added to take care of edge case BG <= 0
transformed_bg = 1.509 * ((np.log(bgs) ** 1.084) - 5.381)
risk_power = 10 * (transformed_bg) ** 2
low_risk_bool = transformed_bg < 0
high_risk_bool = transformed_bg > 0
rlBG = risk_power * low_risk_bool
rhBG = risk_power * high_risk_bool
LBGI = | np.mean(rlBG) | numpy.mean |
import time as t
from collections import Counter
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import pandas as pd
from fink_fat.others.utils import load_data
from fink_fat.others.utils import get_mpc_database
import json
import os
from astropy.coordinates import SkyCoord
from astropy import units as u
def plot_orbit_type(orbit_param, title, y, ylabel, savefig=False, test_name=""):
g = sns.scatterplot(data=orbit_param, x="a", y=y, hue="Orbit_type")
g.set(xlabel="semi-major axis (UA)", ylabel=ylabel)
g.set_title(title)
# g.legend(bbox_to_anchor= (1.2,1))
if savefig:
if not os.path.exists(test_name):
os.mkdir(test_name)
g.set(xlim=(0, 7))
plt.savefig(os.path.join(test_name, title + "_" + ylabel), dpi=500)
g.set(xlim=(6, 500))
plt.savefig(os.path.join(test_name, title + "_" + ylabel + "_distant"), dpi=500)
plt.close()
# g.set(xlim=(0, 7))
# plt.show()
def plot_stat(stat_df, test_name):
g = sns.barplot(data=stat_df, x="night", y="time")
plt.xticks(rotation=90)
g.set(xlabel="night identifier", ylabel="time (sec)")
g.set_title("Computation time of the associations algorithm over nights")
plt.savefig(os.path.join(test_name, "time_plot"))
plt.close()
cum_time = np.cumsum(stat_df["time"])
stat_df["cum_time"] = cum_time
g = sns.lineplot(data=stat_df, x="night", y="cum_time")
plt.xticks(rotation=90)
g.set(xlabel="night identifier", ylabel="time (sec)")
g.set_title("Cumulative computation time of the associations algorithm over nights")
plt.savefig(os.path.join(test_name, "cum_time_plot"))
plt.close()
g = sns.barplot(data=stat_df, x="night", y="trajectory_size")
g.set(xlabel="night identifier", ylabel="number of recorded trajectory")
g.set_title("Size of the recorded trajectory set over nights")
plt.xticks(rotation=90)
plt.savefig(os.path.join(test_name, "trajectory_plot"))
plt.close()
def detect_tracklets(x, traj_time_window, obs_time_window):
counter = x["assoc"]
most_c = np.array(counter.most_common())
most_c = most_c[most_c[:, 0].argsort()]
if most_c[0][1] == x["trajectory_size"]:
return ["tracklets"]
# elif np.any(most_c[:, 1] == orbfit_limit):
# return ["only detected with tracklets"]
# elif np.all(most_c[:, 1] > 1):
# return ["tracklets_with_trajectories_associations only"]
# elif np.all(most_c[:, 1] == 1):
# return ["observations_associations only"]
else:
counter = np.array([i for i in counter.values()])
diff_nid = np.diff( | np.unique(x["nid"]) | numpy.unique |
"""
Helper function for CQED-CIS in the coherent state basis
References:
Equations and algorithms from
[Haugland:2020:041043], [DePrince:2021:094112], and [McTague:2021:ChemRxiv]
"""
__authors__ = ["<NAME>", "<NAME>"]
__credits__ = ["<NAME>", "<NAME>"]
__copyright_amp__ = "(c) 2014-2018, The Psi4NumPy Developers"
__license__ = "BSD-3-Clause"
__date__ = "2021-01-15"
# ==> Import Psi4, NumPy, & SciPy <==
import psi4
import numpy as np
import scipy.linalg as la
import time
from helper_cqed_rhf import cqed_rhf
def cs_cqed_cis(lambda_vector, omega_val, molecule_string, psi4_options_dict):
"""Computes the QED-RHF energy and density
Arguments
---------
lambda_vector : 1 x 3 array of floats
the electric field vector, see e.g. Eq. (1) in [DePrince:2021:094112]
and (15) in [Haugland:2020:041043]
omega_val : complex float
the complex energy associated with the photon, see Eq. (3) in [McTague:2021:ChemRxiv]
molecule_string : string
specifies the molecular geometry
psi4_options_dict : dictionary
specifies the psi4 options to be used in running requisite psi4 calculations
Returns
-------
cqed_cis_dictionary : dictionary
Contains important quantities from the cqed_rhf calculation, with keys including:
'RHF ENERGY' -> result of canonical RHF calculation using psi4 defined by molecule_string and psi4_options_dict
'CQED-RHF ENERGY' -> result of CQED-RHF calculation, see Eq. (13) of [McTague:2021:ChemRxiv]
'CQED-CIS ENERGY' -> numpy array of complex floats comprising energy eigenvalues of CQED-CIS Hamiltonian
'CQED-CIS L VECTORS' -> numpy array of complex floats comprising the left eigenvectors of CQED-CIS Hamiltonian
Example
-------
>>> cqed_cis_dictionary = cs_cqed_cis([0., 0., 1e-2], 0.2-0.001j, '''\nMg\nH 1 1.7\nsymmetry c1\n1 1\n''', psi4_options_dictionary)
"""
# define geometry using the molecule_string
mol = psi4.geometry(molecule_string)
# define options for the calculation
psi4.set_options(psi4_options_dict)
# run psi4 to get ordinary scf energy and wavefunction object
# scf_e, wfn = psi4.energy('scf', return_wfn=True)
# run cqed_rhf method
cqed_rhf_dict = cqed_rhf(lambda_vector, molecule_string, psi4_options_dict)
# grab necessary quantities from cqed_rhf_dict
scf_e = cqed_rhf_dict["RHF ENERGY"]
cqed_scf_e = cqed_rhf_dict["CQED-RHF ENERGY"]
wfn = cqed_rhf_dict["PSI4 WFN"]
C = cqed_rhf_dict["CQED-RHF C"]
eps = cqed_rhf_dict["CQED-RHF EPS"]
cqed_rhf_dipole_moment = cqed_rhf_dict["CQED-RHF DIPOLE MOMENT"]
# Create instance of MintsHelper class
mints = psi4.core.MintsHelper(wfn.basisset())
# Grab data from wavfunction
# number of doubly occupied orbitals
ndocc = wfn.nalpha()
# total number of orbitals
nmo = wfn.nmo()
# number of virtual orbitals
nvirt = nmo - ndocc
# need to update the Co and Cv core matrix objects so we can
# utlize psi4s fast integral transformation!
# collect rhf wfn object as dictionary
wfn_dict = psi4.core.Wavefunction.to_file(wfn)
# update wfn_dict with orbitals from CQED-RHF
wfn_dict["matrix"]["Ca"] = C
wfn_dict["matrix"]["Cb"] = C
# update wfn object
wfn = psi4.core.Wavefunction.from_file(wfn_dict)
# occupied orbitals as psi4 objects but they correspond to CQED-RHF orbitals
Co = wfn.Ca_subset("AO", "OCC")
# virtual orbitals same way
Cv = wfn.Ca_subset("AO", "VIR")
# 2 electron integrals in CQED-RHF basis
ovov = np.asarray(mints.mo_eri(Co, Cv, Co, Cv))
# build the (oo|vv) integrals:
oovv = np.asarray(mints.mo_eri(Co, Co, Cv, Cv))
# strip out occupied orbital energies, eps_o spans 0..ndocc-1
eps_o = eps[:ndocc]
# strip out virtual orbital energies, eps_v spans 0..nvirt-1
eps_v = eps[ndocc:]
# Extra terms for Pauli-Fierz Hamiltonian
# nuclear dipole
mu_nuc_x = mol.nuclear_dipole()[0]
mu_nuc_y = mol.nuclear_dipole()[1]
mu_nuc_z = mol.nuclear_dipole()[2]
# l \cdot \mu_nuc for d_c
l_dot_mu_nuc = lambda_vector[0] * mu_nuc_x
l_dot_mu_nuc += lambda_vector[1] * mu_nuc_y
l_dot_mu_nuc += lambda_vector[2] * mu_nuc_z
# dipole arrays in AO basis
mu_ao_x = np.asarray(mints.ao_dipole()[0])
mu_ao_y = np.asarray(mints.ao_dipole()[1])
mu_ao_z = np.asarray(mints.ao_dipole()[2])
# transform dipole array to CQED-RHF basis
mu_cmo_x = np.dot(C.T, mu_ao_x).dot(C)
mu_cmo_y = np.dot(C.T, mu_ao_y).dot(C)
mu_cmo_z = np.dot(C.T, mu_ao_z).dot(C)
# \lambda \cdot < \mu >
# e.g. line 6 of Eq. (18) in [McTague:2021:ChemRxiv]
l_dot_mu_exp = 0.0
for i in range(0, 3):
l_dot_mu_exp += lambda_vector[i] * cqed_rhf_dipole_moment[i]
# \lambda \cdot \mu_{el}
# e.g. line 4 Eq. (18) in [McTague:2021:ChemRxiv]
l_dot_mu_el = lambda_vector[0] * mu_cmo_x
l_dot_mu_el += lambda_vector[1] * mu_cmo_y
l_dot_mu_el += lambda_vector[2] * mu_cmo_z
# dipole constants to add to E_CQED_CIS,
# 0.5 * (\lambda \cdot \mu_{nuc})** 2
# - (\lambda \cdot <\mu> ) ( \lambda \cdot \mu_{nuc})
# +0.5 * (\lambda \cdot <\mu>) ** 2
# Eq. (14) of [McTague:2021:ChemRxiv]
d_c = (
0.5 * l_dot_mu_nuc ** 2 - l_dot_mu_nuc * l_dot_mu_exp + 0.5 * l_dot_mu_exp ** 2
)
# check to see if d_c what we have from CQED-RHF calculation
assert np.isclose(d_c, cqed_rhf_dict["DIPOLE ENERGY"])
# create Hamiltonian for elements H[ias, jbt]
Htot = np.zeros((ndocc * nvirt * 2 + 2, ndocc * nvirt * 2 + 2), dtype=complex)
Hep = np.zeros((ndocc * nvirt * 2 + 2, ndocc * nvirt * 2 + 2), dtype=complex)
H1e = np.zeros((ndocc * nvirt * 2 + 2, ndocc * nvirt * 2 + 2), dtype=complex)
H2e = np.zeros((ndocc * nvirt * 2 + 2, ndocc * nvirt * 2 + 2), dtype=complex)
H2edp = np.zeros((ndocc * nvirt * 2 + 2, ndocc * nvirt * 2 + 2), dtype=complex)
Hp = np.zeros((ndocc * nvirt * 2 + 2, ndocc * nvirt * 2 + 2), dtype=complex)
# elements corresponding to <s|<\Phi_0 | H | \Phi_0>|t>
# Eq. (16) of [McTague:2021:ChemRxiv]
Hp[0, 0] = 0.0
Hp[1, 1] = omega_val
# elements corresponding to <s|<\Phi_0 | H | \Phi_i^a>|t>
# Eq. (17) of [McTague:2021:ChemRxiv]
for i in range(0, ndocc):
for a in range(0, nvirt):
A = a + ndocc
ia0 = 2 * (i * nvirt + a) + 2
ia1 = 2 * (i * nvirt + a) + 3
Hep[0, ia1] = Hep[ia1, 0] = (
- | np.sqrt(omega_val) | numpy.sqrt |
import pyglet
from pyglet.gl import *
from .globs import *
from .constants import *
from . import config
import ctypes
import math
from .colors import _getColor, color, blue
try:
import numpy
npy = True
numpy.seterr(divide='ignore')
except:
npy = False
# exports
__all__ = ['PImage', 'loadImage', 'image', 'get', 'setScreen', 'save',
'createImage', 'loadPixels', 'updatePixels', 'screenFilter', 'blend']
# the PImage class
class PImage(object):
"""This basically wraps pyglet's AbstractImage with a Processing-like syntax."""
img = None # this is the actual AbstractImage
def __init__(self, *args):
"""Either creates a new image from scratch or wraps an AbstractImage.
Arguments are of the form
PImage()
PImage(width,height)
PImage(width,height,format)
PImage(img)
"""
if len(args) == 1 and isinstance(args[0], pyglet.image.AbstractImage):
# Wraps an AbstractImage
self.img = args[0]
elif len(args) in (2, 3):
# Creates an ImageData from width, height and type
if len(args) == 2:
# default
w, h = args
format = ARGB
else:
w, h, format = args
data = create_string_buffer(w * h * len(format))
self.img = pyglet.image.ImageData(w, h, format, data.raw)
else:
assert (len(args) == 0)
# Do an initial loading of the pixels[] array
self.loadPixels()
self.updatePixels()
def loadPixels(self):
"""Gets the pixel data as an array of integers."""
n = self.width * self.height
self.buf = self.img.get_image_data().get_data('BGRA', -self.width * 4)
if npy:
self.pixels = numpy.fromstring(self.buf, dtype=ctypes.c_uint)
else:
self.pixels = ctypes.cast(self.buf, ctypes.POINTER(ctypes.c_uint))
def filter(self, mode, *args):
"""Applies a filter to the image.
The existant filters are: GRAY, INVERT, OPAQUE, THRESHOLD, POSTERIZE,
ERODE, DILATE and BLUR. This method requires numpy."""
if not npy:
raise ImportError("Numpy is required")
if mode == GRAY:
# Gray value = (77*(n>>16&0xff) + 151*(n>>8&0xff) + 28*(n&0xff)) >> 8
# Where n is the ARGB color of the pixel
lum1 = numpy.multiply(
numpy.bitwise_and(numpy.right_shift(self.pixels, 16), 0xff), 77)
lum2 = numpy.multiply(
numpy.bitwise_and(numpy.right_shift(self.pixels, 8), 0xff), 151)
lum3 = numpy.multiply(numpy.bitwise_and(self.pixels, 0xff), 28)
lum = numpy.right_shift(numpy.add(numpy.add(lum1, lum2), lum3), 8)
self.pixels = numpy.bitwise_and(self.pixels, 0xff000000)
self.pixels = numpy.bitwise_or(self.pixels,
numpy.left_shift(lum, 16))
self.pixels = numpy.bitwise_or(self.pixels,
numpy.left_shift(lum, 8))
self.pixels = numpy.bitwise_or(self.pixels, lum)
elif mode == INVERT:
# This is the same as applying an exclusive or with the maximum value
self.pixels = numpy.bitwise_xor(self.pixels, 0xffffff)
elif mode == BLUR:
if not args:
args = [3]
# Makes the image square by adding zeros.
# This avoids the convolution (via fourier transform multiplication)
# from jumping to another extreme of the image when a border is reached
if self.width > self.height:
dif = self.width - self.height
updif = numpy.zeros(self.width * dif / 2, dtype=numpy.uint32)
downdif = numpy.zeros(self.width * (dif - dif / 2),
dtype=numpy.uint32)
self.pixels = numpy.concatenate((updif, self.pixels, downdif))
size = self.width
elif self.width < self.height:
dif = self.height - self.width
leftdif = numpy.zeros(self.height * dif / 2, dtype=numpy.uint32)
rightdif = numpy.zeros(self.height * (dif - dif / 2),
dtype=numpy.uint32)
self.pixels = self.pixels.reshape(self.height, self.width)
self.pixels = numpy.transpose(self.pixels)
self.pixels = self.pixels.reshape(self.width * self.height)
self.pixels = numpy.concatenate(
(leftdif, self.pixels, rightdif))
self.pixels = self.pixels.reshape(self.height, self.height)
self.pixels = numpy.transpose(self.pixels)
self.pixels = self.pixels.reshape(self.height * self.height)
size = self.height
else:
size = self.height
# Creates a gaussian kernel of the image's size
_createKernel2d(args[0], size)
# Divides the image's R, G and B channels, reshapes them
# to square matrixes and applies two dimensional fourier transforms
red = numpy.bitwise_and(numpy.right_shift(self.pixels, 16), 0xff)
red = numpy.reshape(red, (size, size))
red = numpy.fft.fft2(red)
green = numpy.bitwise_and(numpy.right_shift(self.pixels, 8), 0xff)
green = numpy.reshape(green, (size, size))
green = numpy.fft.fft2(green)
blue = numpy.bitwise_and(self.pixels, 0xff)
blue = numpy.reshape(blue, (size, size))
blue = numpy.fft.fft2(blue)
# Does a element-wise multiplication of each channel matrix
# and the fourier transform of the kernel matrix
kernel = numpy.fft.fft2(weights)
red = numpy.multiply(red, kernel)
green = numpy.multiply(green, kernel)
blue = numpy.multiply(blue, kernel)
# Reshapes them back to arrays and converts to unsigned integers
red = numpy.reshape(numpy.fft.ifft2(red).real, size * size)
green = numpy.reshape(numpy.fft.ifft2(green).real, size * size)
blue = numpy.reshape(numpy.fft.ifft2(blue).real, size * size)
red = red.astype(numpy.uint32)
green = green.astype(numpy.uint32)
blue = blue.astype(numpy.uint32)
self.pixels = numpy.bitwise_or(numpy.left_shift(green, 8), blue)
self.pixels = numpy.bitwise_or(numpy.left_shift(red, 16),
self.pixels)
# Crops out the zeros added
if self.width > self.height:
self.pixels = self.pixels[
self.width * dif / 2:size * size - self.width * (
dif - dif / 2)]
elif self.width < self.height:
self.pixels = numpy.reshape(self.pixels, (size, size))
self.pixels = numpy.transpose(self.pixels)
self.pixels = numpy.reshape(self.pixels, size * size)
self.pixels = self.pixels[
self.height * dif / 2:size * size - self.height * (
dif - dif / 2)]
self.pixels = numpy.reshape(self.pixels,
(self.width, self.height))
self.pixels = numpy.transpose(self.pixels)
self.pixels = numpy.reshape(self.pixels,
self.height * self.width)
elif mode == OPAQUE:
# This is the same as applying an bitwise or with the maximum value
self.pixels = numpy.bitwise_or(self.pixels, 0xff000000)
elif mode == THRESHOLD:
# Maximum = max((n & 0xff0000) >> 16, max((n & 0xff00)>>8, (n & 0xff)))
# Broken down to Maximum = max(aux,aux2)
# The pixel will be white if its maximum is greater than the threshold
# value, and black if not. This was implemented via a boolean matrix
# multiplication.
if not args:
args = [0.5]
thresh = args[0] * 255
aux = numpy.right_shift(numpy.bitwise_and(self.pixels, 0xff00), 8)
aux = numpy.maximum(aux, numpy.bitwise_and(self.pixels, 0xff))
aux2 = numpy.right_shift(numpy.bitwise_and(self.pixels, 0xff0000),
16)
boolmatrix = numpy.greater_equal(numpy.maximum(aux, aux2), thresh)
self.pixels.fill(0xffffff)
self.pixels = numpy.multiply(self.pixels, boolmatrix)
elif mode == POSTERIZE:
# New channel = ((channel*level)>>8)*255/(level-1)
if not args:
args = [8]
levels1 = args[0] - 1
rlevel = numpy.bitwise_and(numpy.right_shift(self.pixels, 16), 0xff)
glevel = numpy.bitwise_and(numpy.right_shift(self.pixels, 8), 0xff)
blevel = numpy.bitwise_and(self.pixels, 0xff)
rlevel = numpy.right_shift(numpy.multiply(rlevel, args[0]), 8)
rlevel = numpy.divide(numpy.multiply(rlevel, 255), levels1)
glevel = numpy.right_shift(numpy.multiply(glevel, args[0]), 8)
glevel = numpy.divide(numpy.multiply(glevel, 255), levels1)
blevel = numpy.right_shift(numpy.multiply(blevel, args[0]), 8)
blevel = numpy.divide(numpy.multiply(blevel, 255), levels1)
self.pixels = numpy.bitwise_and(self.pixels, 0xff000000)
self.pixels = numpy.bitwise_or(self.pixels,
numpy.left_shift(rlevel, 16))
self.pixels = numpy.bitwise_or(self.pixels,
numpy.left_shift(glevel, 8))
self.pixels = numpy.bitwise_or(self.pixels, blevel)
elif mode == ERODE:
# Checks the pixels directly above, under and to the left and right
# of each pixel of the image. If it has a greater luminosity, then
# the center pixel receives its color
colorOrig = numpy.array(self.pixels)
colOut = numpy.array(self.pixels)
colLeft = numpy.roll(colorOrig, 1)
colRight = numpy.roll(colorOrig, -1)
colUp = numpy.roll(colorOrig, self.width)
colDown = numpy.roll(colorOrig, -self.width)
currLum1 = numpy.bitwise_and(numpy.right_shift(colorOrig, 16), 0xff)
currLum1 = numpy.multiply(currLum1, 77)
currLum2 = numpy.bitwise_and(numpy.right_shift(colorOrig, 8), 0xff)
currLum2 = numpy.multiply(currLum2, 151)
currLum3 = numpy.multiply(numpy.bitwise_and(colorOrig, 0xff), 28)
currLum = numpy.add(numpy.add(currLum1, currLum2), currLum3)
lumLeft1 = numpy.bitwise_and(numpy.right_shift(colLeft, 16), 0xff)
lumLeft1 = numpy.multiply(lumLeft1, 77)
lumLeft2 = numpy.bitwise_and(numpy.right_shift(colLeft, 8), 0xff)
lumLeft2 = numpy.multiply(lumLeft2, 151)
lumLeft3 = numpy.multiply(numpy.bitwise_and(colLeft, 0xff), 28)
lumLeft = numpy.add(numpy.add(lumLeft1, lumLeft2), lumLeft3)
lumRight1 = numpy.bitwise_and(numpy.right_shift(colRight, 16), 0xff)
lumRight1 = numpy.multiply(lumRight1, 77)
lumRight2 = numpy.bitwise_and(numpy.right_shift(colRight, 8), 0xff)
lumRight2 = numpy.multiply(lumRight2, 151)
lumRight3 = numpy.multiply(numpy.bitwise_and(colRight, 0xff), 28)
lumRight = numpy.add(numpy.add(lumRight1, lumRight2), lumRight3)
lumDown1 = numpy.bitwise_and(numpy.right_shift(colDown, 16), 0xff)
lumDown1 = numpy.multiply(lumDown1, 77)
lumDown2 = numpy.bitwise_and(numpy.right_shift(colDown, 8), 0xff)
lumDown2 = numpy.multiply(lumDown2, 151)
lumDown3 = numpy.multiply(numpy.bitwise_and(colDown, 0xff), 28)
lumDown = numpy.add(numpy.add(lumDown1, lumDown2), lumDown3)
lumUp1 = numpy.bitwise_and(numpy.right_shift(colUp, 16), 0xff)
lumUp1 = numpy.multiply(lumUp1, 77)
lumUp2 = numpy.bitwise_and(numpy.right_shift(colUp, 8), 0xff)
lumUp2 = numpy.multiply(lumUp2, 151)
lumUp3 = numpy.multiply(numpy.bitwise_and(colUp, 0xff), 28)
lumUp = numpy.add(numpy.add(lumUp1, lumUp2), lumUp3)
numpy.putmask(colOut, lumLeft > currLum, colLeft)
numpy.putmask(currLum, lumLeft > currLum, lumLeft)
numpy.putmask(colOut, lumRight > currLum, colRight)
numpy.putmask(currLum, lumRight > currLum, lumRight)
numpy.putmask(colOut, lumUp > currLum, colUp)
numpy.putmask(currLum, lumUp > currLum, lumUp)
numpy.putmask(colOut, lumDown > currLum, colDown)
numpy.putmask(currLum, lumDown > currLum, lumDown)
self.pixels = colOut
elif mode == DILATE:
# Checks the pixels directly above, under and to the left and right
# of each pixel of the image. If it has a lesser luminosity, then
# the center pixel receives its color
colorOrig = numpy.array(self.pixels)
colOut = numpy.array(self.pixels)
colLeft = numpy.roll(colorOrig, 1)
colRight = numpy.roll(colorOrig, -1)
colUp = numpy.roll(colorOrig, self.width)
colDown = numpy.roll(colorOrig, -self.width)
currLum1 = numpy.bitwise_and(numpy.right_shift(colorOrig, 16), 0xff)
currLum1 = numpy.multiply(currLum1, 77)
currLum2 = numpy.bitwise_and(numpy.right_shift(colorOrig, 8), 0xff)
currLum2 = numpy.multiply(currLum2, 151)
currLum3 = numpy.multiply(numpy.bitwise_and(colorOrig, 0xff), 28)
currLum = numpy.add(numpy.add(currLum1, currLum2), currLum3)
lumLeft1 = numpy.bitwise_and(numpy.right_shift(colLeft, 16), 0xff)
lumLeft1 = numpy.multiply(lumLeft1, 77)
lumLeft2 = numpy.bitwise_and(numpy.right_shift(colLeft, 8), 0xff)
lumLeft2 = numpy.multiply(lumLeft2, 151)
lumLeft3 = numpy.multiply(numpy.bitwise_and(colLeft, 0xff), 28)
lumLeft = numpy.add(numpy.add(lumLeft1, lumLeft2), lumLeft3)
lumRight1 = numpy.bitwise_and(numpy.right_shift(colRight, 16), 0xff)
lumRight1 = numpy.multiply(lumRight1, 77)
lumRight2 = numpy.bitwise_and(numpy.right_shift(colRight, 8), 0xff)
lumRight2 = numpy.multiply(lumRight2, 151)
lumRight3 = numpy.multiply(numpy.bitwise_and(colRight, 0xff), 28)
lumRight = numpy.add(numpy.add(lumRight1, lumRight2), lumRight3)
lumDown1 = numpy.bitwise_and(numpy.right_shift(colDown, 16), 0xff)
lumDown1 = numpy.multiply(lumDown1, 77)
lumDown2 = numpy.bitwise_and(numpy.right_shift(colDown, 8), 0xff)
lumDown2 = numpy.multiply(lumDown2, 151)
lumDown3 = numpy.multiply(numpy.bitwise_and(colDown, 0xff), 28)
lumDown = numpy.add(numpy.add(lumDown1, lumDown2), lumDown3)
lumUp1 = numpy.bitwise_and(numpy.right_shift(colUp, 16), 0xff)
lumUp1 = numpy.multiply(lumUp1, 77)
lumUp2 = numpy.bitwise_and(numpy.right_shift(colUp, 8), 0xff)
lumUp2 = numpy.multiply(lumUp2, 151)
lumUp3 = numpy.multiply(numpy.bitwise_and(colUp, 0xff), 28)
lumUp = numpy.add(numpy.add(lumUp1, lumUp2), lumUp3)
numpy.putmask(colOut, lumLeft < currLum, colLeft)
numpy.putmask(currLum, lumLeft < currLum, lumLeft)
numpy.putmask(colOut, lumRight < currLum, colRight)
numpy.putmask(currLum, lumRight < currLum, lumRight)
numpy.putmask(colOut, lumUp < currLum, colUp)
numpy.putmask(currLum, lumUp < currLum, lumUp)
numpy.putmask(colOut, lumDown < currLum, colDown)
numpy.putmask(currLum, lumDown < currLum, lumDown)
self.pixels = colOut
self.updatePixels()
def mask(self, image):
"""Uses the image passed as parameter as alpha mask."""
if npy:
aux1 = numpy.bitwise_and(self.pixels, 0xffffff)
aux2 = numpy.bitwise_and(image.pixels, 0xff000000)
self.pixels = numpy.bitwise_or(aux1, aux2)
return
for i in range(self.width):
for j in range(self.height):
n = self.get(i, j)
m = image.get(i, j)
new = ((m & 0xff000000) << 24) | (n & 0xffffff)
self.set(i, j, new)
def updatePixels(self):
"""Saves the pixel data."""
if npy:
self.buf = self.pixels.tostring()
self.img.get_image_data().set_data('BGRA', -self.width * 4, self.buf)
def set(self, x, y, color):
"""Sets the pixel at x,y with the given color."""
self.pixels[y * self.width + x] = color
self.updatePixels()
def get(self, *args):
"""Returns a copy, a part or a pixel of this image.
Arguments are of the form:
get()
get(x,y)
get(x,y,width,height)
"""
if len(args) in (0, 4):
# the result is an image
if len(args) == 0:
x, y, width, height = 0, 0, self.width, self.height
else:
x, y, width, height = args
assert (x >= 0 and x < self.width and y >= 0 and y < self.height and
width > 0 and height > 0 and x + width <= self.width and
y + height <= self.height)
if width != self.width or height != self.height:
source = self.img.get_region(x, self.height - y - height, width,
height)
else:
source = self.img
result = PImage(width, height, self.img.format)
# print source._current_pitch
# print result.img._current_pitch
# buf = source.get_data ('BGRA',result.img._current_pitch)
# result.img.set_data ('BGRA', result.img._current_pitch, buf)
result.img.get_texture().blit_into(source, 0, 0, 0)
return result
else:
# result is a pixel
x, y = args
assert (x >= 0 and x < self.width and y >= 0 and y < self.height)
return self.pixels[y * self.width + x]
def save(self, filename):
"""Saves this image as a file of the proper format."""
self.img.save(filename)
def __getWidth(self):
"""Getter for the width property."""
return self.img.width
width = property(__getWidth)
def __getHeight(self):
"""Getter for the height property."""
return self.img.height
height = property(__getHeight)
# Image functions
def screenFilter(mode, *args):
"""Applies a filter to the current drawing canvas.
This method requires numpy."""
if not npy:
raise ImportError("Numpy is required")
new = createImage(width, height, 'RGBA')
loadPixels()
new.pixels = numpy.array(screen.pixels)
new.filter(mode, *args)
new.updatePixels()
image(new, 0, 0)
def mix(a, b, f):
return a + (((b - a) * f) >> 8);
def _mix(a, b, f):
# Used for the blend function (mixes colors according to their alpha values)
c = numpy.multiply(numpy.subtract(b, a), f)
return numpy.add(numpy.right_shift(c, 8), a)
def _high(a, b):
# Used for the blend function (returns the matrix with the maximum bitwise values)
c = numpy.multiply(a.__le__(b), b)
d = numpy.multiply(a.__gt__(b), a)
return numpy.add(c, d)
def _low(a, b):
# Used for the blend function (returns the matrix with the minimum bitwise values)
c = numpy.multiply(a.__ge__(b), b)
d = numpy.multiply(a.__lt__(b), a)
return numpy.add(c, d)
def _peg(a):
# Used for the blend function (returns the matrix with constrained values)
b = numpy.multiply(a.__ge__(0), a)
c = numpy.multiply(b.__le__(255), b)
d = numpy.multiply(b.__gt__(255), 255)
return numpy.add(c, d)
def _sub(a, b):
# Used for the blend function (mimics an unsigned subtraction with signed arrays)
aux = a
aux1 = numpy.multiply(aux.__ge__(b), b)
aux2 = numpy.multiply(b.__gt__(aux), aux)
b = numpy.add(aux1, aux2)
return numpy.subtract(aux, b)
def blend(source, x, y, swidth, sheight, dx, dy, dwidth, dheight, mode):
"""Blends a region of pixels from one image into another."""
if not npy:
raise ImportError("Numpy is required")
loadPixels()
a = screen.pixels.reshape((height, width))
a = a[dy:dy + dheight, dx:dx + dwidth]
a = a.reshape(a.shape[1] * a.shape[0])
b = source.pixels.reshape((source.height, source.width))
b = b[y:y + sheight, x:x + swidth]
b = b.reshape(b.shape[1] * b.shape[0])
f = numpy.right_shift(numpy.bitwise_and(b, 0xff000000), 24)
a.dtype = "int32"
b.dtype = "int32"
# BLEND Mode
if mode == 0:
alpha = numpy.right_shift(numpy.bitwise_and(a, 0xff000000), 24)
alpha = numpy.left_shift(_low(numpy.add(alpha, f), 0xff), 24)
red = _mix(numpy.bitwise_and(a, 0xff0000),
numpy.bitwise_and(b, 0xff0000), f)
red = numpy.bitwise_and(red, 0xff0000)
green = _mix(numpy.bitwise_and(a, 0xff00), numpy.bitwise_and(b, 0xff00),
f)
green = numpy.bitwise_and(green, 0xff00)
blue = _mix(numpy.bitwise_and(a, 0xff), numpy.bitwise_and(b, 0xff), f)
# ADD Mode
elif mode == 1:
alpha = numpy.right_shift(numpy.bitwise_and(a, 0xff000000), 24)
alpha = numpy.left_shift(_low(numpy.add(alpha, f), 0xff), 24)
red = numpy.bitwise_and(b, 0xff0000)
red = numpy.right_shift(numpy.multiply(red, f), 8)
red = numpy.add(red, numpy.bitwise_and(a, 0xff0000))
red = _low(red, 0xff0000)
red = numpy.bitwise_and(red, 0xff0000)
green = numpy.bitwise_and(b, 0xff00)
green = numpy.right_shift(numpy.multiply(green, f), 8)
green = numpy.add(green, numpy.bitwise_and(a, 0xff00))
green = _low(green, 0xff00)
green = numpy.bitwise_and(green, 0xff00)
blue = numpy.bitwise_and(b, 0xff)
blue = numpy.right_shift(numpy.multiply(blue, f), 8)
blue = numpy.add(blue, numpy.bitwise_and(a, 0xff))
blue = _low(blue, 0xff)
# SUBTRACT Mode
elif mode == 2:
alpha = numpy.right_shift(numpy.bitwise_and(a, 0xff000000), 24)
alpha = numpy.left_shift(_low( | numpy.add(alpha, f) | numpy.add |
# Copyright 2016 The Johns Hopkins University Applied Physics Laboratory
#
# 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 django.conf import settings
import blosc
from rest_framework.test import APITestCase, APIRequestFactory
from rest_framework.test import force_authenticate
from rest_framework import status
from bossspatialdb.views import Cutout
from bosscore.test.setup_db import SetupTestDB
from bosscore.error import BossError
import numpy as np
import zlib
import io
import time
from PIL import Image
from unittest.mock import patch
from fakeredis import FakeStrictRedis
import spdb
import bossutils
from spdb.spatialdb.rediskvio import RedisKVIO
from spdb.spatialdb.state import CacheStateDB
from spdb.spatialdb.spatialdb import SpatialDB
from spdb.spatialdb.object import AWSObjectStore
version = settings.BOSS_VERSION
_test_globals = {'cache': None,
'state': None}
# DMK - can be removed once proper mocking is completed
#class MockBossConfig(bossutils.configuration.BossConfig):
# """Basic mock for BossConfig so 'test databases' are used for redis (1) instead of the default where real data
# can live (0)"""
# def __init__(self):
# super().__init__()
# self.config["aws"]["cache-db"] = "1"
# self.config["aws"]["cache-state-db"] = "1"
#
# def read(self, filename):
# pass
#
# def __getitem__(self, key):
# return self.config[key]
#
#
#class MockSpatialDB(spdb.spatialdb.spatialdb.SpatialDB):
# """mock for redis kvio so the actual server isn't used during unit testing, but a static mockredis-py instead"""
#
# def __init__(self, kv_conf, state_conf, object_store_conf):
# SpatialDB.__init__(kv_conf, state_conf, object_store_conf)
# if not _test_globals['cache']:
# _test_globals['cache'] = RedisKVIO(kv_conf)
# _test_globals['state'] = CacheStateDB(state_conf)
#
# self.kvio = _test_globals['cache']
# self.cache_state = _test_globals['state']
@patch('redis.StrictRedis', FakeStrictRedis)
def mock_init_(self, kv_conf, state_conf, object_store_conf):
print("init mocker")
self.kv_config = kv_conf
self.state_conf = state_conf
self.object_store_config = object_store_conf
# Threshold number of cuboids for using lambda on reads
self.read_lambda_threshold = 600 # Currently high since read lambda not implemented
# Number of seconds to wait for dirty cubes to get clean
self.dirty_read_timeout = 60
if not _test_globals['cache']:
kv_conf["cache_db"] = 1
state_conf["cache_state_db"] = 1
print(kv_conf)
print(state_conf)
_test_globals['cache'] = RedisKVIO(kv_conf)
_test_globals['state'] = CacheStateDB(state_conf)
self.kvio = _test_globals['cache']
self.cache_state = _test_globals['state']
self.objectio = AWSObjectStore(object_store_conf)
class CutoutInterfaceViewUint8TestMixin(object):
def test_channel_uint8_wrong_data_type(self):
""" Test posting the wrong bitdepth data """
config = bossutils.configuration.BossConfig()
test_mat = np.random.randint(1, 2 ** 16 - 1, (16, 128, 128))
test_mat = test_mat.astype(np.uint16)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=16)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/', bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range=None)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_channel_uint8_wrong_data_type_numpy(self):
""" Test posting the wrong bitdepth data using the blosc-numpy interface"""
test_mat = np.random.randint(1, 2 ** 16 - 1, (16, 128, 128))
test_mat = test_mat.astype(np.uint16)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range=None)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_channel_uint8_wrong_dimensions(self):
""" Test posting with the wrong xyz dims"""
test_mat = np.random.randint(1, 2 ** 16 - 1, (16, 128, 128))
test_mat = test_mat.astype(np.uint8)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=8)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/0:100/0:128/0:16/', bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:100', y_range='0:128', z_range='0:16', t_range=None)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_channel_uint8_wrong_dimensions_numpy(self):
""" Test posting with the wrong xyz dims using the numpy interface"""
test_mat = np.random.randint(1, 2 ** 16 - 1, (16, 128, 128))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/0:100/0:128/0:16/', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel2',
resolution='0', x_range='0:100', y_range='0:128', z_range='0:16', t_range=None)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_channel_uint8_get_too_big(self):
""" Test getting a cutout that is over 1GB uncompressed"""
# Create request
factory = APIRequestFactory()
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/0:2048/0:2048/0:131/',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel2',
resolution='0', x_range='0:2048', y_range='0:2048', z_range='0:131', t_range=None)
self.assertEqual(response.status_code, status.HTTP_413_REQUEST_ENTITY_TOO_LARGE)
def test_channel_uint8_cuboid_aligned_no_offset_no_time_blosc(self):
""" Test uint8 data, cuboid aligned, no offset, no time samples"""
test_mat = np.random.randint(1, 254, (16, 128, 128))
test_mat = test_mat.astype(np.uint8)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=8)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/', bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
raw_data = blosc.decompress(response.content)
data_mat = np.fromstring(raw_data, dtype=np.uint8)
data_mat = np.reshape(data_mat, (16, 128, 128), order='C')
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_aligned_no_offset_no_time_blosc_4d(self):
""" Test uint8 data, cuboid aligned, no offset, no time samples"""
test_mat = np.random.randint(1, 254, (1, 16, 128, 128))
test_mat = test_mat.astype(np.uint8)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=8)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/3:4/', bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range="3:4")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/3:4/',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range="3:4").render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
raw_data = blosc.decompress(response.content)
data_mat = np.fromstring(raw_data, dtype=np.uint8)
data_mat = np.reshape(data_mat, (1, 16, 128, 128), order='C')
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_aligned_offset_no_time_blosc(self):
""" Test uint8 data, cuboid aligned, offset, no time samples, blosc interface"""
test_mat = np.random.randint(1, 254, (16, 128, 128))
test_mat = test_mat.astype(np.uint8)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=8)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/128:256/256:384/16:32/', bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='128:256', y_range='256:384', z_range='16:32', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/128:256/256:384/16:32/',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='128:256', y_range='256:384', z_range='16:32', t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
raw_data = blosc.decompress(response.content)
data_mat = np.fromstring(raw_data, dtype=np.uint8)
data_mat = np.reshape(data_mat, (16, 128, 128), order='C')
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_unaligned_offset_no_time_blosc(self):
""" Test uint8 data, not cuboid aligned, offset, no time samples, blosc interface"""
test_mat = np.random.randint(1, 254, (17, 300, 500))
test_mat = test_mat.astype(np.uint8)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=8)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/', bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/',
HTTP_ACCEPT='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37', t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
raw_data = blosc.decompress(response.content)
data_mat = np.fromstring(raw_data, dtype=np.uint8)
data_mat = np.reshape(data_mat, (17, 300, 500), order='C')
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_unaligned_offset_time_blosc(self):
""" Test uint8 data, not cuboid aligned, offset, time samples, blosc interface
Test Requires >=2GB of memory!
"""
test_mat = np.random.randint(1, 254, (3, 17, 300, 500))
test_mat = test_mat.astype(np.uint8)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=8)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/30:47/0:3', bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='30:47', t_range='0:3')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/30:47/0:3',
HTTP_ACCEPT='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='30:47', t_range='0:3').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
raw_data = blosc.decompress(response.content)
data_mat = np.fromstring(raw_data, dtype=np.uint8)
data_mat = np.reshape(data_mat, (3, 17, 300, 500), order='C')
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_aligned_no_offset_no_time_blosc_numpy(self):
""" Test uint8 data, cuboid aligned, no offset, no time samples"""
test_mat = np.random.randint(1, 254, (16, 128, 128))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/0:128/0:128/0:16/',
HTTP_ACCEPT='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='0:128', y_range='0:128', z_range='0:16', t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_mat = blosc.unpack_array(response.content)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_aligned_offset_no_time_blosc_numpy(self):
""" Test uint8 data, cuboid aligned, offset, no time samples, blosc interface"""
test_mat = np.random.randint(1, 254, (16, 128, 128))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/128:256/256:384/16:32/', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='128:256', y_range='256:384', z_range='16:32', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/128:256/256:384/16:32/',
HTTP_ACCEPT='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='128:256', y_range='256:384', z_range='16:32', t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_mat = blosc.unpack_array(response.content)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_unaligned_offset_no_time_blosc_numpy(self):
""" Test uint8 data, not cuboid aligned, offset, no time samples, blosc interface"""
test_mat = np.random.randint(1, 254, (17, 300, 500))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/',
HTTP_ACCEPT='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37', t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_mat = blosc.unpack_array(response.content)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_unaligned_offset_time_blosc_numpy(self):
""" Test uint8 data, not cuboid aligned, offset, time samples, blosc interface
"""
test_mat = np.random.randint(1, 254, (3, 17, 300, 500))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/50:67/0:3', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='50:67', t_range='0:3')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/50:67/0:3',
HTTP_ACCEPT='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='50:67', t_range='0:3').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_mat = blosc.unpack_array(response.content)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_unaligned_offset_time_offset_blosc_numpy(self):
""" Test uint8 data, not cuboid aligned, offset, time samples, blosc interface
Test Requires >=2GB of memory!
"""
test_mat = np.random.randint(1, 254, (3, 17, 300, 500))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/200:203', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37', t_range='200:203')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/200:203',
HTTP_ACCEPT='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37',
t_range='200:203').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_mat = blosc.unpack_array(response.content)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_cuboid_unaligned_offset_time_offset_overwrite_blosc__numpy(self):
""" Test uint8 data, not cuboid aligned, offset, time samples, blosc interface
Test Requires >=2GB of memory!
"""
# Do this a couple times to the same region....should succeed every time
for _ in range(0, 2):
test_mat = np.random.randint(1, 254, (3, 17, 300, 500))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/40:57/200:203', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='40:57',
t_range='200:203')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/40:57/200:203',
HTTP_ACCEPT='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='40:57',
t_range='200:203').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_mat = blosc.unpack_array(response.content)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_notime_npygz_download(self):
""" Test uint8 data, using the npygz interface
"""
test_mat = np.random.randint(1, 254, (17, 300, 500))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make POST data
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37',
HTTP_ACCEPT='application/npygz')
# log in user
force_authenticate(request, user=self.user)
# Make request to GET data
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37',
t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_bytes = zlib.decompress(response.content)
# Open
data_obj = io.BytesIO(data_bytes)
data_mat = np.load(data_obj)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_time_npygz_download(self):
""" Test uint8 data, using the npygz interface with time series support
"""
test_mat = np.random.randint(1, 254, (3, 17, 300, 500))
test_mat = test_mat.astype(np.uint8)
bb = blosc.pack_array(test_mat)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/100:103', bb,
content_type='application/blosc-python')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37',
t_range='100:103')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/100:103',
HTTP_ACCEPT='application/npygz')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37',
t_range='100:103').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_bytes = zlib.decompress(response.content)
# Open
data_obj = io.BytesIO(data_bytes)
data_mat = np.load(data_obj)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_notime_npygz_upload(self):
""" Test uint8 data, using the npygz interface while uploading in that format as well
"""
test_mat = np.random.randint(1, 254, (17, 300, 500))
test_mat = test_mat.astype(np.uint8)
# Save Data to npy
npy_file = io.BytesIO()
np.save(npy_file, test_mat, allow_pickle=False)
# Compress npy
npy_gz = zlib.compress(npy_file.getvalue())
# Send file
npy_gz_file = io.BytesIO(npy_gz)
npy_gz_file.seek(0)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/',
npy_gz_file.read(),
content_type='application/npygz')
# log in user
force_authenticate(request, user=self.user)
# Make POST data
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37', t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37',
HTTP_ACCEPT='application/npygz')
# log in user
force_authenticate(request, user=self.user)
# Make request to GET data
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37',
t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_bytes = zlib.decompress(response.content)
# Open
data_obj = io.BytesIO(data_bytes)
data_mat = np.load(data_obj)
# Test for data equality (what you put in is what you got back!)
np.testing.assert_array_equal(data_mat, test_mat)
def test_channel_uint8_time_npygz_upload(self):
""" Test uint8 data, using the npygz interface with time series support while uploading in that format as well
"""
test_mat = np.random.randint(1, 254, (3, 17, 300, 500))
test_mat = test_mat.astype(np.uint8)
# Save Data to npy
npy_file = io.BytesIO()
np.save(npy_file, test_mat, allow_pickle=False)
# Compress npy
npy_gz = zlib.compress(npy_file.getvalue())
# Send file
npy_gz_file = io.BytesIO(npy_gz)
npy_gz_file.seek(0)
# Create request
factory = APIRequestFactory()
request = factory.post('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/150:153',
npy_gz_file.read(),
content_type='application/npygz')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37',
t_range='150:153')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Create Request to get data you posted
request = factory.get('/' + version + '/cutout/col1/exp1/channel1/0/100:600/450:750/20:37/150:153',
HTTP_ACCEPT='application/npygz')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request, collection='col1', experiment='exp1', channel='channel1',
resolution='0', x_range='100:600', y_range='450:750', z_range='20:37',
t_range='150:153').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Decompress
data_bytes = zlib.decompress(response.content)
# Open
data_obj = io.BytesIO(data_bytes)
data_mat = np.load(data_obj)
# Test for data equality (what you put in is what you got back!)
| np.testing.assert_array_equal(data_mat, test_mat) | numpy.testing.assert_array_equal |
from typing import Callable
from xarray_multiscale.reducers import mode
import dask.array as da
from scipy.stats import mode as scipy_mode
from typing import Any
import numpy as np
def modefunc(v):
return scipy_mode(v).mode
def coarsened_comparator(
func: Callable, source_array: Any, coarsened_array: Any
) -> Any:
"""
Take a reducer function and two arrays; reduce the first array,
and check that the result is identical to the second array.
"""
result = | np.array([True]) | numpy.array |
"""
E-Divisive related tests.
"""
import numpy as np
from miscutils.testing import relative_patch_maker
from signal_processing_algorithms.e_divisive import default_implementation
from signal_processing_algorithms.e_divisive.calculators import __name__ as patchable
patch = relative_patch_maker(patchable)
class OldEDivisive(object):
"""
This is the original O(n^2) E-Divisive implementation as described in the whitepaper.
It is here for comparison purposes only and to allow the q values to
be generated if further tests are added.
NOTE: This is why I have disabled some pylint checks.
NOTE: This implementation is purely to provide a 'canonical' implementation for
test purposes. It is not efficient and will not be optimized.
"""
# Implementing change-point detection algorithm from https://arxiv.org/pdf/1306.4933.pdf
def qs(self, series: np.ndarray):
"""
Find Q-Hat values for all candidate change points
:param series: the points to process
:return:
"""
length = len(series)
qs = np.zeros(length, dtype=np.float)
if length < 5:
return qs
diffs = [[abs(series[i] - series[j]) for i in range(length)] for j in range(length)]
for n in range(2, length - 2):
m = length - n
term1 = sum(diffs[i][j] for i in range(n) for j in range(n, length))
term2 = sum(diffs[i][k] for i in range(n) for k in range(i + 1, n))
term3 = sum(diffs[j][k] for j in range(n, length) for k in range(j + 1, length))
term1_reg = term1 * (2.0 / (m * n))
term2_reg = term2 * (2.0 / (n * (n - 1)))
term3_reg = term3 * (2.0 / (m * (m - 1)))
newq = (m * n // (m + n)) * (term1_reg - term2_reg - term3_reg)
qs[n] = newq
return qs
class TestAlgorithmContinuity(object):
"""
Test Algorithm Continuity is correct.
"""
series = np.array([1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3], dtype=np.float)
expected = np.array(
[
0,
0,
1.3777777777777778,
3.4444444444444438,
4.428571428571429,
2.971428571428571,
3.599999999999999,
2.342857142857143,
2.857142857142857,
4.666666666666666,
0,
0,
],
dtype=np.float,
)
expected_proper_division = np.array(
[
0,
1.03333333,
2.2962963,
3.875,
5.9047619,
4.33333333,
3.6,
3.41666667,
3.80952381,
5.25,
3.11111111,
1.4,
]
)
def test_old_algorithm(self):
"""
Test to double check slow O(n^2) algorithm. Small data set so this is ok.
"""
algorithm = OldEDivisive()
q_values = algorithm.qs(self.series)
assert all(np.isclose(self.expected, q_values))
def test_fixed(self):
"""
Test that the current algorithm generates the same q values as the original.
"""
algorithm = default_implementation()
q_values = algorithm._calculator.calculate_qhat_values(
algorithm._calculator.calculate_diffs(self.series)
)
assert all( | np.isclose(self.expected, q_values) | numpy.isclose |
import sys
import argparse
import gc
import os
import random
from typing import AnyStr
from typing import List
import ipdb
import krippendorff
from collections import defaultdict
from pathlib import Path
import math
import pickle
from datetime import datetime
from gurobipy import *
import numpy as np
import torch
from torch.optim.lr_scheduler import LambdaLR
from torch.utils.data import DataLoader
from torch.utils.data import Subset
from torch.utils.data import random_split
from torch.optim import Adam
from tqdm import tqdm
from transformers import AdamW
from transformers import DistilBertConfig
from transformers import DistilBertTokenizer
from transformers import DistilBertForSequenceClassification
from transformers import get_linear_schedule_with_warmup
from datareader import MultiDomainEntityMatchingDataset
from datareader import collate_batch_transformer
from metrics import MultiDatasetClassificationEvaluator
from metrics import ClassificationEvaluator
from metrics import acc_f1
from metrics import plot_label_distribution
from model import MultiTransformerClassifier
from model import VanillaBert
from model import *
import pandas as pd
import copy
from sklearn.cluster import KMeans
def extract_embs(model, dataloader, device):
model.eval()
with torch.no_grad():
all_embs = []
for batch in tqdm(dataloader, desc="Evaluation"):
batch = tuple(t.to(device) for t in batch)
input_ids = batch[0]
masks = batch[1]
embs = model.return_embedding(input_ids, attention_mask=masks)
all_embs.append(embs)
all_embs = torch.cat(all_embs)
return all_embs
def extract_confidences(model, dataloader, device):
model.eval()
with torch.no_grad():
all_confs = []
for batch in tqdm(dataloader, desc="Evaluation"):
batch = tuple(t.to(device) for t in batch)
input_ids = batch[0]
masks = batch[1]
confs = model.return_confidence(input_ids, attention_mask=masks)
all_confs.append(confs)
all_confs = torch.cat(all_confs)
return all_confs
def extract_probs_dropout(model,dataloader,device,n_drop):
model.train()
dropout_confs=[]
with torch.no_grad():
for i in range(n_drop):
all_embs=[]
for batch in tqdm(dataloader, desc="Evaluation"):
batch = tuple(t.to(device) for t in batch)
input_ids = batch[0]
masks = batch[1]
confs = model.return_confidence(input_ids, attention_mask=masks)
all_embs.append(confs)
all_embs=torch.cat(all_embs)
dropout_confs.append(all_embs)
dropout_confs=torch.stack(dropout_confs,dim=1)
dropout_confs=torch.sum(dropout_confs,dim=1)
dropout_confs/=n_drop
return dropout_confs
def least_confidence(model, dataloader_target, train_data, nb_samples, device):
confs_target = extract_confidences(model, dataloader_target, device)
U = confs_target.max(1)[0]
idxs_unlabeled = np.arange(len(train_data))
samples_to_query = idxs_unlabeled[U.sort()[1].cpu()[:nb_samples]]
query_data = [train_data[jj] for jj in samples_to_query]
return query_data
def random_samples(train_data,nb_samples):
random.shuffle(train_data)
query_data=train_data[:nb_samples]
return query_data
def kmeans_sampling(model,dataloader_target,train_data,nb_samples,device):
idxs_unlabeled = np.arange(len(train_data))
embss_target = extract_embs(model, dataloader_target, device)
embedding = embss_target.cpu().numpy()
cluster_learner = KMeans(n_clusters=nb_samples)
cluster_learner.fit(embedding)
cluster_idxs = cluster_learner.predict(embedding)
centers = cluster_learner.cluster_centers_[cluster_idxs]
dis = (embedding - centers) ** 2
dis = dis.sum(axis=1)
q_idxs = np.array([np.arange(embedding.shape[0])[cluster_idxs == i][dis[cluster_idxs == i].argmin()] for i in range(nb_samples)])
samples_to_query=idxs_unlabeled[q_idxs]
query_data = [train_data[jj] for jj in samples_to_query]
return query_data
def entropy_sampling(model,dataloader_target,train_data,nb_samples,device):
confs_target = extract_confidences(model, dataloader_target, device)
log_probs = torch.log(confs_target)
U = (confs_target * log_probs).sum(1)
idxs_unlabeled = np.arange(len(train_data))
samples_to_query = idxs_unlabeled[U.sort()[1].cpu()[:nb_samples]]
query_data = [train_data[jj] for jj in samples_to_query]
return query_data
def kcenters_sampling1(model,dataloader_target,train_data,nb_samples,device):
NUM_INIT_LB=int(nb_samples/2)
#NUM_INIT_LB = nb_samples
nb_unlabeled=nb_samples-NUM_INIT_LB
idxs_lb = np.zeros(len(train_data), dtype=bool)
confs_target = extract_confidences(model, dataloader_target, device)
U = confs_target.max(1)[0]
idxs_unlabeled = np.arange(len(train_data))
samples_to_query = idxs_unlabeled[U.sort(descending=False)[1].cpu()[:NUM_INIT_LB]]
idxs_lb[samples_to_query] = True
lb_flag = idxs_lb.copy()
embss_target = extract_embs(model, dataloader_target, device)
embedding = embss_target.cpu().numpy()
from datetime import datetime
#print('calculate distance matrix')
t_start = datetime.now()
dist_mat = np.matmul(embedding, embedding.transpose())
sq = np.array(dist_mat.diagonal()).reshape(len(train_data), 1)
dist_mat *= -2
dist_mat += sq
dist_mat += sq.transpose()
dist_mat = np.sqrt(dist_mat)
#print(datetime.now() - t_start)
mat = dist_mat[~lb_flag, :][:, lb_flag]
for i in range(nb_unlabeled):
#if i % 10 == 0:
# print('greedy solution {}/{}'.format(i, nb_samples))
mat_min = mat.min(axis=1)
q_idx_ = mat_min.argmax()
q_idx = np.arange(len(train_data))[~lb_flag][q_idx_]
lb_flag[q_idx] = True
mat = np.delete(mat, q_idx_, 0)
mat = np.append(mat, dist_mat[~lb_flag, q_idx][:, None], axis=1)
samples_to_query=np.arange(len(train_data))[(idxs_lb | lb_flag)]
query_data = [train_data[jj] for jj in samples_to_query]
return query_data
def kcenters_sampling(model,dataloader_target,train_data,test_dset_supervised_training,optimizer,args,evaluator_valid,n_epochs,domain,test_dset,nb_samples,device):
NUM_INIT_LB=int(nb_samples/2)
#NUM_INIT_LB = nb_samples
nb_unlabeled=nb_samples-NUM_INIT_LB
idxs_lb = np.zeros(len(train_data), dtype=bool)
# confs_target = extract_confidences(model, dataloader_target, device)
# U = confs_target.max(1)[0]
# idxs_unlabeled = np.arange(len(train_data))
# samples_to_query = idxs_unlabeled[U.sort()[1].cpu()[:NUM_INIT_LB]]
# idxs_lb[samples_to_query] = True
indices=np.arange(len(train_data))
np.random.shuffle(indices)
samples_to_query=indices[:NUM_INIT_LB]
idxs_lb[samples_to_query] = True
query_data = [train_data[jj] for jj in samples_to_query]
test_dset_supervised_training.dataset = pd.DataFrame(query_data)
test_dset_supervised_training.set_domain_id(0)
test_dset.set_domain_id(1)
train_sizes = [int(len(test_dset_supervised_training) * args.train_pct)]
val_sizes = [len(test_dset_supervised_training) - train_sizes[0]]
subsets = [random_split(test_dset_supervised_training, [train_sizes[0], val_sizes[0]])]
train_dls = [DataLoader(
subset[0],
batch_size=batch_size,
shuffle=True,
collate_fn=collate_batch_transformer
) for subset in subsets]
scheduler = get_linear_schedule_with_warmup(
optimizer,
args.warmup_steps,
n_epochs * sum([len(train_dl) for train_dl in train_dls])
)
opt = [optimizer]
# Train
train(
model,
train_dls,
opt,
scheduler,
evaluator_valid,
n_epochs,
device,
args.log_interval,
model_dir=args.model_dir,
gradient_accumulation=args.gradient_accumulation,
domain_name=domain
)
model.load_state_dict(torch.load(f'{args.model_dir}/files/model_{domain}.pth'))
evaluator = ClassificationEvaluator(test_dset, device, use_domain=False)
(loss, acc, P, R, F1), plots, (labels, logits), votes = evaluator.evaluate(
model,
plot_callbacks=[],
return_labels_logits=True,
return_votes=True
)
print('{} samples for {}'.format(NUM_INIT_LB, domain))
print(f"{domain} F1: {F1}")
print(f"{domain} Accuracy: {acc}")
print()
test_dset_supervised_training.dataset = pd.DataFrame(train_data)
lb_flag = idxs_lb.copy()
embss_target = extract_embs(model, dataloader_target, device)
embedding = embss_target.cpu().numpy()
from datetime import datetime
#print('calculate distance matrix')
t_start = datetime.now()
dist_mat = np.matmul(embedding, embedding.transpose())
sq = np.array(dist_mat.diagonal()).reshape(len(train_data), 1)
dist_mat *= -2
dist_mat += sq
dist_mat += sq.transpose()
dist_mat = np.sqrt(dist_mat)
#print(datetime.now() - t_start)
mat = dist_mat[~lb_flag, :][:, lb_flag]
for i in range(nb_unlabeled):
#if i % 10 == 0:
# print('greedy solution {}/{}'.format(i, nb_unlabeled))
mat_min = mat.min(axis=1)
q_idx_ = mat_min.argmax()
q_idx = np.arange(len(train_data))[~lb_flag][q_idx_]
lb_flag[q_idx] = True
mat = np.delete(mat, q_idx_, 0)
mat = np.append(mat, dist_mat[~lb_flag, q_idx][:, None], axis=1)
samples_to_query=np.arange(len(train_data))[(idxs_lb | lb_flag)]
query_data = [train_data[jj] for jj in samples_to_query]
return model,query_data
def solve_fac_loc(xx, yy, subset, n, budget):
t_start = datetime.now()
model = Model("k-center")
x = {}
y = {}
z = {}
print('gen z', datetime.now() - t_start)
for i in range(n):
# z_i: is a loss
z[i] = model.addVar(obj=1, ub=0.0, vtype="B", name="z_{}".format(i))
print('gen x y', datetime.now() - t_start)
m = len(xx)
for i in range(m):
if i % 1000000 == 0:
print('gen x y {}/{}'.format(i, m), datetime.now() - t_start)
_x = xx[i]
_y = yy[i]
# y_i = 1 means i is facility, 0 means it is not
if _y not in y:
if _y in subset:
y[_y] = model.addVar(obj=0, ub=1.0, lb=1.0, vtype="B", name="y_{}".format(_y))
else:
y[_y] = model.addVar(obj=0, vtype="B", name="y_{}".format(_y))
# if not _x == _y:
x[_x, _y] = model.addVar(obj=0, vtype="B", name="x_{},{}".format(_x, _y))
model.update()
print('gen sum q', datetime.now() - t_start)
coef = [1 for j in range(n)]
var = [y[j] for j in range(n)]
model.addConstr(LinExpr(coef, var), "=", rhs=budget + len(subset), name="k_center")
print('gen <=', datetime.now() - t_start)
for i in range(m):
if i % 1000000 == 0:
print('gen <= {}/{}'.format(i, m), datetime.now() - t_start)
_x = xx[i]
_y = yy[i]
# if not _x == _y:
model.addConstr(x[_x, _y], "<=", y[_y], name="Strong_{},{}".format(_x, _y))
print('gen sum 1', datetime.now() - t_start)
yyy = {}
for v in range(m):
if i % 1000000 == 0:
print('gen sum 1 {}/{}'.format(i, m), datetime.now() - t_start)
_x = xx[v]
_y = yy[v]
if _x not in yyy:
yyy[_x] = []
if _y not in yyy[_x]:
yyy[_x].append(_y)
for _x in yyy:
coef = []
var = []
for _y in yyy[_x]:
# if not _x==_y:
coef.append(1)
var.append(x[_x, _y])
coef.append(1)
var.append(z[_x])
model.addConstr(LinExpr(coef, var), "=", 1, name="Assign{}".format(_x))
print('ok', datetime.now() - t_start)
model.__data = x, y, z
return model
def core_set(model,dataloader_target,train_data,test_dset_supervised_training,optimizer,args,evaluator_valid,n_epochs,domain,test_dset,nb_samples,device):
NUM_INIT_LB=int(nb_samples/2)
#NUM_INIT_LB = nb_samples
nb_unlabeled=nb_samples-NUM_INIT_LB
idxs_lb = np.zeros(len(train_data), dtype=bool)
# confs_target = extract_confidences(model, dataloader_target, device)
# U = confs_target.max(1)[0]
# idxs_unlabeled = np.arange(len(train_data))
# samples_to_query = idxs_unlabeled[U.sort()[1].cpu()[:NUM_INIT_LB]]
# idxs_lb[samples_to_query] = True
indices=np.arange(len(train_data))
np.random.shuffle(indices)
samples_to_query=indices[:NUM_INIT_LB]
idxs_lb[samples_to_query] = True
query_data = [train_data[jj] for jj in samples_to_query]
test_dset_supervised_training.dataset = pd.DataFrame(query_data)
test_dset_supervised_training.set_domain_id(0)
test_dset.set_domain_id(1)
train_sizes = [int(len(test_dset_supervised_training) * args.train_pct)]
val_sizes = [len(test_dset_supervised_training) - train_sizes[0]]
subsets = [random_split(test_dset_supervised_training, [train_sizes[0], val_sizes[0]])]
train_dls = [DataLoader(
subset[0],
batch_size=batch_size,
shuffle=True,
collate_fn=collate_batch_transformer
) for subset in subsets]
scheduler = get_linear_schedule_with_warmup(
optimizer,
args.warmup_steps,
n_epochs * sum([len(train_dl) for train_dl in train_dls])
)
opt = [optimizer]
# Train
train(
model,
train_dls,
opt,
scheduler,
evaluator_valid,
n_epochs,
device,
args.log_interval,
model_dir=args.model_dir,
gradient_accumulation=args.gradient_accumulation,
domain_name=domain
)
model.load_state_dict(torch.load(f'{args.model_dir}/files/model_{domain}.pth'))
evaluator = ClassificationEvaluator(test_dset, device, use_domain=False)
(loss, acc, P, R, F1), plots, (labels, logits), votes = evaluator.evaluate(
model,
plot_callbacks=[],
return_labels_logits=True,
return_votes=True
)
print('{} samples for {}'.format(NUM_INIT_LB, domain))
print(f"{domain} F1: {F1}")
print(f"{domain} Accuracy: {acc}")
print()
test_dset_supervised_training.dataset = pd.DataFrame(train_data)
lb_flag = idxs_lb.copy()
embss_target = extract_embs(model, dataloader_target, device)
embedding = embss_target.cpu().numpy()
from datetime import datetime
#print('calculate distance matrix')
t_start = datetime.now()
dist_mat = np.matmul(embedding, embedding.transpose())
sq = np.array(dist_mat.diagonal()).reshape(len(train_data), 1)
dist_mat *= -2
dist_mat += sq
dist_mat += sq.transpose()
dist_mat = np.sqrt(dist_mat)
#print(datetime.now() - t_start)
mat = dist_mat[~lb_flag, :][:, lb_flag]
for i in range(nb_unlabeled):
if i % 10 == 0:
print('greedy solution {}/{}'.format(i, nb_unlabeled))
mat_min = mat.min(axis=1)
q_idx_ = mat_min.argmax()
q_idx = np.arange(len(train_data))[~lb_flag][q_idx_]
lb_flag[q_idx] = True
mat = np.delete(mat, q_idx_, 0)
mat = np.append(mat, dist_mat[~lb_flag, q_idx][:, None], axis=1)
print(datetime.now() - t_start)
opt = mat.min(axis=1).max()
bound_u = opt
bound_l = opt / 2.0
delta = opt
xx, yy = np.where(dist_mat <= opt)
dd = dist_mat[xx, yy]
lb_flag_ = idxs_lb.copy()
subset = np.where(lb_flag_ == True)[0].tolist()
SEED = 5
pickle.dump((xx.tolist(), yy.tolist(), dd.tolist(), subset, float(opt), nb_unlabeled, len(train_data)),
open('mip{}.pkl'.format(SEED), 'wb'), 2)
#ipdb.set_trace()
r_name = 'mip{}.pkl'.format(SEED)
w_name = 'sols{}.pkl'.format(SEED)
print('load pickle {}'.format(r_name))
xx, yy, dd, subset, max_dist, budget, n = pickle.load(open(r_name, 'rb'))
print(len(subset), budget, n)
t_start = datetime.now()
print('start')
ub = max_dist
lb = ub / 2.0
model_coreset = solve_fac_loc(xx, yy, subset, n, budget)
# model.setParam( 'OutputFlag', False )
x, y, z = model_coreset.__data
tor = 1e-3
sols = None
while ub - lb > tor:
cur_r = (ub + lb) / 2.0
print("======[State]======", ub, lb, cur_r, ub - lb)
# viol = numpy.where(_d>cur_r)
viol = [i for i in range(len(dd)) if dd[i] > cur_r]
# new_max_d = numpy.min(_d[_d>=cur_r])
new_max_d = min([d for d in dd if d >= cur_r])
# new_min_d = numpy.max(_d[_d<=cur_r])
new_min_d = max([d for d in dd if d <= cur_r])
print("If it succeeds, new max is:", new_max_d, new_min_d)
for v in viol:
x[xx[v], yy[v]].UB = 0
model_coreset.update()
r = model_coreset.optimize()
if model_coreset.getAttr(GRB.Attr.Status) == GRB.INFEASIBLE:
failed = True
print("======[Infeasible]======")
elif sum([z[i].X for i in range(len(z))]) > 0:
failed = True
print("======[Failed]======Failed")
else:
failed = False
if failed:
lb = max(cur_r, new_max_d)
# failed so put edges back
for v in viol:
x[xx[v], yy[v]].UB = 1
else:
print("======[Solution Founded]======", ub, lb, cur_r)
ub = min(cur_r, new_min_d)
sols = [v.varName for v in model_coreset.getVars() if v.varName.startswith('y') and v.x > 0]
#break
print('end', datetime.now() - t_start, ub, lb, max_dist)
if sols is not None:
sols = [int(v.split('_')[-1]) for v in sols]
print('save pickle {}'.format(w_name))
pickle.dump(sols, open(w_name, 'wb'), 2)
sols = pickle.load(open('sols{}.pkl'.format(SEED), 'rb'))
if sols is None:
q_idxs = lb_flag
else:
lb_flag_[sols] = True
q_idxs = lb_flag_
print('sum q_idxs = {}'.format(q_idxs.sum()))
samples_to_query = np.arange(len(train_data))[(idxs_lb | q_idxs)]
query_data = [train_data[jj] for jj in samples_to_query]
print('nb samples={}'.format(len(query_data)))
return model,query_data
def USDE(model,dataloader_target,train_data,nb_samples,n_drop,device):
confs_target = extract_probs_dropout(model, dataloader_target, device, n_drop)
log_probs = torch.log(confs_target)
U = (confs_target * log_probs).sum(1)
idxs_unlabeled = np.arange(len(train_data))
samples_to_query = idxs_unlabeled[U.sort()[1].cpu()[:nb_samples]]
query_data = [train_data[jj] for jj in samples_to_query]
return query_data
def extract_probs_split(model,dataloader,device,n_drop):
model.train()
dropout_confs=[]
with torch.no_grad():
for i in range(n_drop):
all_embs=[]
for batch in tqdm(dataloader, desc="Evaluation"):
batch = tuple(t.to(device) for t in batch)
input_ids = batch[0]
masks = batch[1]
confs = model.return_confidence(input_ids, attention_mask=masks)
all_embs.append(confs)
all_embs=torch.cat(all_embs)
dropout_confs.append(all_embs)
dropout_confs=torch.stack(dropout_confs,dim=0)
return dropout_confs
def BALD(model,dataloader_target,train_data,nb_samples,n_drop,device):
confs_target = extract_probs_split(model, dataloader_target, device, n_drop)
pb = confs_target.mean(0)
entropy1 = (-pb * torch.log(pb)).sum(1)
entropy2 = (-confs_target * torch.log(confs_target)).sum(2).mean(0)
U = entropy2 - entropy1
idxs_unlabeled = np.arange(len(train_data))
samples_to_query = idxs_unlabeled[U.sort()[1].cpu()[:nb_samples]]
query_data = [train_data[jj] for jj in samples_to_query]
return query_data
def USDE_BALD(model,dataloader_target,train_data,nb_samples,n_drop,device):
confs_target = extract_probs_dropout(model, dataloader_target, device, n_drop)
log_probs = torch.log(confs_target)
U1 = (confs_target * log_probs).sum(1)
confs_target = extract_probs_split(model, dataloader_target, device, n_drop)
pb = confs_target.mean(0)
entropy1 = (-pb * torch.log(pb)).sum(1)
entropy2 = (-confs_target * torch.log(confs_target)).sum(2).mean(0)
U = entropy2 - entropy1
U=U+U1
idxs_unlabeled = np.arange(len(train_data))
samples_to_query = idxs_unlabeled[U.sort()[1].cpu()[:nb_samples]]
query_data = [train_data[jj] for jj in samples_to_query]
return query_data
def train(
model: torch.nn.Module,
train_dls: List[DataLoader],
optimizer: [torch.optim.Optimizer,torch.optim.Optimizer],
scheduler: LambdaLR,
validation_evaluator: ClassificationEvaluator,
n_epochs: int,
device: AnyStr,
log_interval: int = 1,
patience: int = 10,
model_dir: str = "wandb_local",
gradient_accumulation: int = 1,
domain_name: str = ''
):
#best_loss = float('inf')
best_F1 = 0.0
epoch_counter = 0
total = sum(len(dl) for dl in train_dls)
optG = optimizer[0]
sotmax = nn.Softmax(dim=1)
# Main loop
while epoch_counter < n_epochs:
dl_iters = [iter(dl) for dl in train_dls]
dl_idx = list(range(len(dl_iters)))
finished = [0] * len(dl_iters)
i = 0
with tqdm(total=total, desc="Training") as pbar:
while sum(finished) < len(dl_iters):
random.shuffle(dl_idx)
for d in dl_idx:
domain_dl = dl_iters[d]
batches = []
try:
for j in range(gradient_accumulation):
batches.append(next(domain_dl))
except StopIteration:
finished[d] = 1
if len(batches) == 0:
continue
optG.zero_grad()
for batch in batches:
model.train()
batch = tuple(t.to(device) for t in batch)
input_ids = batch[0]
masks = batch[1]
labels = batch[2]
domains = batch[3]
loss, logits, alpha = model.forward_test(input_ids, attention_mask=masks, domains=domains, labels=labels, ret_alpha = True)
loss = loss.mean() / gradient_accumulation
loss.backward()
i += 1
pbar.update(1)
optG.step()
if scheduler is not None:
scheduler.step()
gc.collect()
(loss, acc, P, R, F1), plots, (labels, logits), votes = validation_evaluator.evaluate(
model,
plot_callbacks=[],
return_labels_logits=True,
return_votes=True
)
print('valid F1={}'.format(F1))
if F1 > best_F1:
best_F1 = F1
torch.save(model.state_dict(), f'{model_dir}/files/model_{domain_name}.pth')
gc.collect()
epoch_counter += 1
if __name__ == "__main__":
# Define arguments
parser = argparse.ArgumentParser()
parser.add_argument("--dataset_loc", help="Root directory of the dataset", required=False, type=str,
default='entity-matching-dataset')
parser.add_argument("--train_pct", help="Percentage of data to use for training", type=float, default=0.8)
parser.add_argument("--n_gpu", help="The number of GPUs to use", type=int, default=0)
parser.add_argument("--log_interval", help="Number of steps to take between logging steps", type=int, default=1)
parser.add_argument("--warmup_steps", help="Number of steps to warm up Adam", type=int, default=200)
parser.add_argument("--n_epochs", help="Number of epochs", type=int, default=3)
parser.add_argument("--pretrained_bert", help="Directory with weights to initialize the shared model with",
type=str, default=None)
parser.add_argument("--domains", nargs='+', help='A list of domains to use for training',
default=['Walmart-Amazon', 'Abt-Buy', 'Beer', 'DBLP-GoogleScholar', 'Amazon-Google', 'cameras_',
'DBLP-ACM', 'Fodors-Zagats', 'iTunes-Amazon', 'shoes_', 'computers_', 'watches_'])
parser.add_argument("--seed", type=int, help="Random seed", default=1000)
parser.add_argument("--model_dir", help="Where to store the saved model", default="moe_dame", type=str)
parser.add_argument("--tags", nargs='+', help='A list of tags for this run', default=[])
parser.add_argument("--batch_size", help="The batch size", type=int, default=16)
parser.add_argument("--lr", help="Learning rate", type=float, default=1e-5)
parser.add_argument("--weight_decay", help="l2 reg", type=float, default=0.01)
parser.add_argument("--n_heads", help="Number of transformer heads", default=6, type=int)
parser.add_argument("--n_layers", help="Number of transformer layers", default=6, type=int)
parser.add_argument("--d_model", help="Transformer model size", default=768, type=int)
parser.add_argument("--ff_dim", help="Intermediate feedforward size", default=2048, type=int)
parser.add_argument("--gradient_accumulation", help="Number of gradient accumulation steps", default=1, type=int)
parser.add_argument("--model", help="Name of the model to run", default="VanillaBert")
parser.add_argument("--supervision_layer", help="The layer at which to use domain adversarial supervision",
default=6, type=int)
parser.add_argument("--indices_dir", help="If standard splits are being used", type=str, default=None)
parser.add_argument("--active_learning", help="active learning strategies", default="random sampling", type=str)
args = parser.parse_args()
active_learning_strategy = args.active_learning
valid_als=['random sampling','least confidence', 'entropy sampling', 'usde', 'bald', 'k-centers', 'k-means', 'core-set']
if active_learning_strategy not in valid_als:
print('choose AL strategy from the list {}'.format(valid_als))
exit()
# Set all the seeds
seed = args.seed
random.seed(seed)
| np.random.seed(seed) | numpy.random.seed |
# Copyright (c) 2018 <NAME>
#
# Licensed under the MIT License;
# you may not use this file except in compliance with the License.
#
# 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.
# ==============================================================================
# Adapted from the original implementation by <NAME>.
# Source: https://github.com/brucechou1983/CheXNet-Keras
import numpy as np
import os
import pandas as pd
from PIL import Image
from configparser import ConfigParser
from keras.applications.densenet import DenseNet121
import importlib
from keras.layers import Input
from utility import get_class_names
from keras.layers.core import Dense
from keras.models import Model
import h5py
import sys
import argparse
import shutil
from keras.backend.tensorflow_backend import set_session
import tensorflow as tf
from tensorflow.python.keras.losses import categorical_crossentropy
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
#----------------------------------------------------------------------------
# Convenience func that normalizes labels.
def normalize_labels(lab):
labels_sum = np.sum(lab,axis=1).reshape(-1,1)
lab_new = np.divide(lab,labels_sum)
return lab_new
#----------------------------------------------------------------------------
# Mask input by numpy multiplication.
def mask_input(x,i,j,BS,C,H,W,ds):
mask = np.ones([H,W,C])
mask[i*ds:(i+1)*ds,j*ds:(j+1)*ds,:] = np.zeros([ds,ds,C])
return np.multiply(x,mask)
#----------------------------------------------------------------------------
# Upscale cxplain attention map
# x = [BS,H,W,C]
def upscale2d(x, factor=2):
x = np.transpose(x,[0,3,1,2]) #[BS,H,W,C]->[BS,C,H,W]
assert isinstance(factor, int) and factor >= 1
if factor == 1: return x
s = x.shape
x = np.reshape(x, [-1, s[1], s[2], 1, s[3], 1])
x = np.repeat(x,factor,axis=3)
x = np.repeat(x,factor,axis=5)
x = np.reshape(x,[-1,s[1],s[2] * factor, s[3] * factor])
x = np.transpose(x,[0,2,3,1])
return x
#----------------------------------------------------------------------------
# BCE loss in numpy
def binary_crossentropy(output,target,epsilon=1e-07):
output = np.clip(output, epsilon, 1. - epsilon)
bce = target * np.log(output+epsilon)
bce += (1 - target) * np.log(1 - output+epsilon)
return np.mean(-bce,axis=1)
#----------------------------------------------------------------------------
# Computes delta maps as new input for discrimiantor
# x = [BS,H,W,C]
# labels = [BS,Y]
def get_delta_map(x, model, labels,
downsample_factor=2,
log_transform=False,
normalize=False):
BS, H, W, C = x.shape[0], x.shape[1], x.shape[2], x.shape[3]
H_new = (H//downsample_factor)
W_new = (W//downsample_factor)
num_masks = H_new*W_new
# Tile and replicate
x_tiled = np.reshape(x,[1,BS,H,W,C])
x_rep = np.repeat(x_tiled,num_masks,axis=0)
#Get masked tensors and compute delta_errors
base_loss = binary_crossentropy(output=model.predict(x), target=labels)
idx = 0
delta_errors = []
for i in range(0,H_new):
for j in range(0,W_new):
x_mask = mask_input(x_rep[idx],i,j,BS=BS,C=C,H=H,W=W,ds=downsample_factor)
loss = binary_crossentropy(output=model.predict(x_mask), target=labels)
delta = np.maximum(loss-base_loss,1e-07)
if log_transform:
delta = np.log(1.0 + delta)
delta_errors.append(delta)
idx += 1
delta_errors = np.asarray(delta_errors) #[num_masks,BS,1]
delta_errors = np.transpose(delta_errors,[1,0]) #[BS,num_masks]
delta_map = np.reshape(delta_errors, [BS,H_new,W_new,1]) #[BS,H_new,W_new,1]
delta_map = upscale2d(delta_map,factor=downsample_factor) #[BS,H,W,1]
if normalize:
delta_map_sum = np.sum(delta_map,axis=(1,2,3)).reshape(-1,1,1,1)
delta_map = delta_map / delta_map_sum
return delta_map
def cxpl(model_dir, results_dir, resolution):
# parser config
config_file = model_dir+ "/config.ini"
print("Config File Path:", config_file,flush=True)
assert os.path.isfile(config_file)
cp = ConfigParser()
cp.read(config_file)
# default config
image_dimension = cp["TRAIN"].getint("image_dimension")
batch_size = cp["TEST"].getint("batch_size")
use_best_weights = cp["TEST"].getboolean("use_best_weights")
batchsize_cxpl = cp["CXPL"].getint("batchsize_cxpl")
print("** DenseNet input resolution:", image_dimension, flush=True)
print("** GAN image resolution:", resolution, flush=True)
log2_record = int(np.log2(resolution))
record_file_ending = "*"+ np.str(log2_record)+ ".tfrecords"
print("** Resolution ", resolution, " corresponds to ", record_file_ending, " TFRecord file.", flush=True)
output_dir = os.path.join(results_dir, "classification_results_res_"+np.str(2**log2_record)+"/test")
print("Output Directory:", output_dir,flush=True)
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
if use_best_weights:
print("** Using BEST weights",flush=True)
model_weights_path = os.path.join(results_dir, "classification_results_res_"+np.str(2**log2_record)+"/train/best_weights.h5")
else:
print("** Using LAST weights",flush=True)
model_weights_path = os.path.join(results_dir, "classification_results_res_"+np.str(2**log2_record)+"/train/weights.h5")
# get test sample count
class_names = get_class_names(output_dir,"test")
# Get Model
# ------------------------------------
input_shape=(image_dimension, image_dimension, 3)
img_input = Input(shape=input_shape)
base_model = DenseNet121(
include_top = False,
weights = None,
input_tensor = img_input,
input_shape = input_shape,
pooling = "avg")
x = base_model.output
predictions = Dense(len(class_names), activation="sigmoid", name="predictions")(x)
model = Model(inputs=img_input, outputs = predictions)
print(" ** load model from:", model_weights_path, flush=True)
model.load_weights(model_weights_path)
# ------------------------------------
# Load Paths & Labels
print(" ** load .csv and images.", flush=True)
paths=[]
labels=[]
df_nn = pd.read_csv(output_dir+"/nn_files/nn_path_and_labels.csv")
for row in df_nn.iterrows():
labels.append(row[1][1:].astype(np.float32))
paths.append(row[1][0])
y_cx = np.asarray(labels)
all_paths = np.asarray(paths)
# Load Images
imagenet_mean = np.array([0.485, 0.456, 0.406])
imagenet_std = np.array([0.229, 0.224, 0.225])
imgs = []
for path in paths:
img = Image.open(output_dir+"/nn_files/"+path)
img = np.asarray(img.convert("L"))
img = img / 255.
img = | np.reshape(img,[img.shape[0],img.shape[1],1]) | numpy.reshape |
import numpy as np
import pandas as pd
import pytest
from glum._util import _align_df_categories
@pytest.fixture()
def df():
return pd.DataFrame(
{
"x1": np.array([0, 1], dtype="int64"),
"x2": np.array([0, 1], dtype="bool"),
"x3": np.array([0, 1], dtype="float64"),
"x4": ["0", "1"],
"x5": ["a", "b"],
"x6": pd.Categorical(["a", "b"]),
"x7": pd.Categorical(["a", "b"], categories=["b", "a"]),
}
)
def test_align_df_categories_numeric(df):
dtypes = {column: np.float64 for column in df}
expected = pd.DataFrame(
{
"x1": np.array([0, 1], dtype="int64"),
"x2": np.array([0, 1], dtype="bool"),
"x3": np.array([0, 1], dtype="float64"),
"x4": ["0", "1"],
"x5": ["a", "b"],
"x6": pd.Categorical(["a", "b"]),
"x7": pd.Categorical(["a", "b"], categories=["b", "a"]),
}
)
pd.testing.assert_frame_equal(_align_df_categories(df, dtypes), expected)
def test_align_df_categories_categorical(df):
dtypes = {column: pd.CategoricalDtype(["a", "b"]) for column in df}
expected = pd.DataFrame(
{
"x1": [np.nan, np.nan],
"x2": [np.nan, np.nan],
"x3": [np.nan, np.nan],
"x4": [np.nan, np.nan],
"x5": pd.Categorical(["a", "b"]),
"x6": pd.Categorical(["a", "b"]),
"x7": pd.Categorical(["a", "b"]),
},
dtype=pd.CategoricalDtype(["a", "b"]),
)
pd.testing.assert_frame_equal(_align_df_categories(df, dtypes), expected)
def test_align_df_categories_excess_columns(df):
dtypes = {"x1": np.float64}
expected = pd.DataFrame(
{
"x1": np.array([0, 1], dtype="int64"),
"x2": | np.array([0, 1], dtype="bool") | numpy.array |
"""
Author: <NAME>
Created in: September 19, 2019
Python version: 3.6
"""
from Least_SRMTL import Least_SRMTL
import libmr
from matplotlib import pyplot, cm
from matplotlib.patches import Circle
from mpl_toolkits.mplot3d import Axes3D, art3d
import numpy as np
import numpy.matlib
import sklearn.metrics
class EVeP(object):
"""
evolving Extreme Value Machine
Ruled-based predictor with EVM at the definition of the antecedent of the rules.
1. Create a new instance and provide the model parameters;
2. Call the predict(x) method to make predictions based on the given input;
3. Call the train(x, y) method to evolve the model based on the new input-output pair.
"""
# Model initialization
def __init__(self, sigma=0.5, delta=50, N=np.Inf, rho=None, columns_ts=None):
# Setting EVM algorithm parameters
self.sigma = sigma
self.tau = 99999
self.delta = delta
self.N = N
self.rho = rho
self.columns_ts = columns_ts
if self.rho is not None:
self.init_theta = 2
self.srmtl = Least_SRMTL(rho)
self.R = None
self.mr_x = list()
self.mr_y = list()
self.x0 = list()
self.y0 = list()
self.X = list()
self.y = list()
self.step = list()
self.last_update = list()
self.theta = list()
self.c = 0
# Initialization of a new instance of EV.
def add_EV(self, x0, y0, step):
self.mr_x.append(libmr.MR())
self.mr_y.append(libmr.MR())
self.x0.append(x0)
self.y0.append(y0)
self.X.append(x0)
self.y.append(y0)
self.step.append(step)
self.last_update.append(np.max(step))
self.theta.append(np.zeros_like(x0))
self.c = self.c + 1
if self.rho is None:
# coefficients of the consequent part
self.theta[-1] = np.insert(self.theta[-1], 0, y0, axis=1).T
else:
self.init_theta = 2
# coefficients of the consequent part
self.theta[-1] = np.insert(self.theta[-1], 0, y0, axis=1)
# Add the sample(s) (X, y) as covered by the extreme vector. Remove repeated points.
def add_sample_to_EV(self, index, X, y, step):
self.X[index] = np.concatenate((self.X[index], X))
self.y[index] = np.concatenate((self.y[index], y))
self.step[index] = np.concatenate((self.step[index], step))
if self.X[index].shape[0] > self.N:
indexes = np.argsort(-self.step[index].reshape(-1))
self.X[index] = self.X[index][indexes[: self.N], :]
self.y[index] = self.y[index][indexes[: self.N]]
self.step[index] = self.step[index][indexes[: self.N]]
self.x0[index] = np.average(self.X[index], axis=0).reshape(1, -1)
self.y0[index] = np.average(self.y[index], axis=0).reshape(1, -1)
self.last_update[index] = np.max(self.step[index])
if self.rho is None:
self.theta[index] = np.linalg.lstsq(np.insert(self.X[index], 0, 1, axis=1), self.y[index], rcond=None)[0]
def delete_from_list(self, list_, indexes):
for i in sorted(indexes, reverse=True):
del list_[i]
return list_
# Calculate the firing degree of the sample to the psi curve
def firing_degree(self, index, x=None, y=None):
if y is None:
return self.mr_x[index].w_score_vector(sklearn.metrics.pairwise.pairwise_distances(self.x0[index], x).reshape(-1))
elif x is None:
return self.mr_y[index].w_score_vector(sklearn.metrics.pairwise.pairwise_distances(self.y0[index], y).reshape(-1))
else:
return np.minimum(self.mr_x[index].w_score_vector(sklearn.metrics.pairwise.pairwise_distances(self.x0[index], x).reshape(-1)), self.mr_y[index].w_score_vector(sklearn.metrics.pairwise.pairwise_distances(self.y0[index], y).reshape(-1)))
# Fit the psi curve of the EVs according to the external samples
def fit(self, index, X_ext, y_ext):
self.fit_x(index, sklearn.metrics.pairwise.pairwise_distances(self.x0[index], X_ext)[0])
self.fit_y(index, sklearn.metrics.pairwise.pairwise_distances(self.y0[index], y_ext)[0])
# Fit the psi curve to the extreme values with distance D to the center of the EV
def fit_x(self, index, D):
self.mr_x[index].fit_low(1/2 * D, min(D.shape[0], self.tau))
# Fit the psi curve to the extreme values with distance D to the center of the EV
def fit_y(self, index, D):
self.mr_y[index].fit_low(1/2 * D, min(D.shape[0], self.tau))
# Get the distance from the origin of the input EV which has the given probability to belong to the curve
def get_distance_input(self, percentage, index=None):
if index is None:
return [self.mr_x[i].inv(percentage) for i in range(self.c)]
else:
return self.mr_x[index].inv(percentage)
# Get the distance from the origin of the output EV which has the given probability to belong to the curve
def get_distance_output(self, percentage, index=None):
if index is None:
return [self.mr_y[i].inv(percentage) for i in range(self.c)]
else:
return self.mr_y[index].inv(percentage)
# Obtain the samples that do not belong to the given EV
def get_external_samples(self, index=None):
if index is None:
X = np.concatenate(self.X)
y = np.concatenate(self.y)
else:
if self.c > 1:
X = np.concatenate(self.X[:index] + self.X[index + 1 :])
y = np.concatenate(self.y[:index] + self.y[index + 1 :])
else:
X = np.array([])
y = np.array([])
return (X, y)
# Merge two EVs of different clusters whenever the origin of one is inside the sigma probability of inclusion of the psi curve of the other
def merge(self):
self.sort_EVs()
index = 0
while index < self.c:
if index + 1 < self.c:
x0 = np.concatenate(self.x0[index + 1 : ])
y0 = np.concatenate(self.y0[index + 1 : ])
S_index = self.firing_degree(index, x0, y0)
index_to_merge = np.where(S_index > self.sigma)[0] + index + 1
if index_to_merge.size > 0:
self.init_theta = 2
for i in reversed(range(len(index_to_merge))):
self.add_sample_to_EV(index, self.X[index_to_merge[i]], self.y[index_to_merge[i]], self.step[index_to_merge[i]])
self.remove_EV([index_to_merge[i]])
index = index + 1
# Plot the granules that form the antecedent part of the rules
def plot(self, name_figure_input, name_figure_output, step):
# Input fuzzy granules plot
fig = pyplot.figure()
ax = fig.add_subplot(111, projection='3d')
ax.axes.set_xlim3d(left=-2, right=2)
ax.axes.set_ylim3d(bottom=-2, top=2)
z_bottom = -0.3
ax.set_zticklabels("")
colors = cm.get_cmap('Dark2', self.c)
for i in range(self.c):
self.plot_EV_input(i, ax, '.', colors(i), z_bottom)
legend.append('$\lambda$ = ' + str(round(self.mr_x[new_order[i]].get_params()[0], 1)) + ' $\kappa$ = ' + str(round(self.mr_x[new_order[i]].get_params()[1], 1)))
# Plot axis' labels
ax.set_xlabel('u(t)', fontsize=15)
ax.set_ylabel('y(t)', fontsize=15)
ax.set_zlabel('$\mu_x$', fontsize=15)
ax.legend(legend, fontsize=10, loc=2)
# Save figure
fig.savefig(name_figure_input)
# Close plot
pyplot.close(fig)
# Output fuzzy granules plot
fig = pyplot.figure()
ax = fig.add_subplot(111)
ax.axes.set_xlim(left=-2, right=2)
for i in range(self.c):
self.plot_EV_output(i, ax, '.', colors(i), z_bottom)
# Plot axis' labels
ax.set_xlabel('y(t + 1)', fontsize=15)
ax.set_ylabel('$\mu_y$', fontsize=15)
ax.legend(legend, fontsize=10, loc=2)
# Save figure
fig.savefig(name_figure_output)
# Close plot
pyplot.close(fig)
# Plot the probability of sample inclusion (psi-model) together with the samples associated with the EV for the input fuzzy granules
def plot_EV_input(self, index, ax, marker, color, z_bottom):
# Plot the input samples in the XY plan
ax.scatter(self.X[index][:, 0], self.X[index][:, 1], z_bottom * np.ones((self.X[index].shape[0], 1)), marker=marker, color=color)
# Plot the radius for which there is a probability sigma to belong to the EV
radius = self.get_distance_input(self.sigma, index)
p = Circle((self.x0[index][0, 0], self.x0[index][0, 1]), radius, fill=False, color=color)
ax.add_patch(p)
art3d.pathpatch_2d_to_3d(p, z=z_bottom, zdir="z")
# Plot the psi curve of the EV
r = np.linspace(0, self.get_distance_input(0.05, index), 100)
theta = np.linspace(0, 2 * np.pi, 145)
radius_matrix, theta_matrix = np.meshgrid(r,theta)
X = self.x0[index][0, 0] + radius_matrix * np.cos(theta_matrix)
Y = self.x0[index][0, 1] + radius_matrix * np.sin(theta_matrix)
points = np.array([np.array([X, Y])[0, :, :].reshape(-1), np.array([X, Y])[1, :, :].reshape(-1)]).T
Z = self.firing_degree(index, points)
ax.plot_surface(X, Y, Z.reshape((X.shape[0], X.shape[1])), antialiased=False, cmap=cm.coolwarm, alpha=0.1)
# Plot the probability of sample inclusion (psi-model) together with the samples associated with the EV for the output fuzzy granules
def plot_EV_output(self, index, ax, marker, color, z_bottom):
# Plot the output data points in the X axis
ax.scatter(self.y[index], np.zeros_like(self.y[index]), marker=marker, color=color)
# Plot the psi curve of the EV
r = np.linspace(0, self.get_distance_output(0.01, index), 100)
points = np.concatenate((np.flip((self.y0[index] - r).T, axis=0), (self.y0[index] + r).T), axis=0)
Z = self.firing_degree(index, y=points)
#ax.plot(points, Z, antialiased=False, cmap=cm.coolwarm, alpha=0.1)
ax.plot(points, Z, color=color)
# Predict the output given the input sample x
def predict(self, x):
num = 0
den = 0
for i in range(self.c):
p = self.predict_EV(i, x)
num = num + self.firing_degree(i, x, p) * p
den = den + self.firing_degree(i, x, p)
if den == 0:
if self.columns_ts is None:
return np.mean(x)
return np.mean(x[:, self.columns_ts])
return num / den
# Predict the local output of x based on the linear regression of the samples stored at the EV
def predict_EV(self, index, x):
if self.rho is None:
return np.insert(x, 0, 1).reshape(1, -1) @ self.theta[index]
return np.insert(x, 0, 1).reshape(1, -1) @ self.theta[index].T
# Calculate the degree of relationship of all the rules to the rule of index informed as parameter
def relationship_rules(self, index):
distance_x = sklearn.metrics.pairwise.pairwise_distances(self.x0[index], np.concatenate(self.x0)).reshape(-1)
distance_y = sklearn.metrics.pairwise.pairwise_distances(self.y0[index], np.concatenate(self.y0)).reshape(-1)
relationship_x_center = self.mr_x[index].w_score_vector(distance_x)
relationship_y_center = self.mr_y[index].w_score_vector(distance_y)
relationship_x_radius = self.mr_x[index].w_score_vector(distance_x - self.get_distance_input(self.sigma))
relationship_y_radius = self.mr_y[index].w_score_vector(distance_y - self.get_distance_output(self.sigma))
return np.maximum(np.maximum(relationship_x_center, relationship_x_radius), np.maximum(relationship_y_center, relationship_y_radius))
# Remove the EV whose index was informed by parameter
def remove_EV(self, index):
self.mr_x = self.delete_from_list(self.mr_x, index)
self.mr_y = self.delete_from_list(self.mr_y, index)
self.x0 = self.delete_from_list(self.x0, index)
self.y0 = self.delete_from_list(self.y0, index)
self.X = self.delete_from_list(self.X, index)
self.y = self.delete_from_list(self.y, index)
self.step = self.delete_from_list(self.step, index)
self.last_update = self.delete_from_list(self.last_update, index)
self.theta = self.delete_from_list(self.theta, index)
self.c = len(self.mr_x)
# Remove the EVs that didn't have any update in the last threshold steps
def remove_outdated_EVs(self, threshold):
indexes_to_remove = list()
for index in range(self.c):
if self.last_update[index] <= threshold:
indexes_to_remove.append(index)
if len(indexes_to_remove) > 0:
self.remove_EV(indexes_to_remove)
if self.rho is not None:
self.update_R()
self.init_theta = 2
# Sort the EVs according to the last update
def sort_EVs(self):
new_order = (-np.array(self.last_update)).argsort()
self.mr_x = list(np.array(self.mr_x)[new_order])
self.mr_y = list(np.array(self.mr_y)[new_order])
self.x0 = list(np.array(self.x0)[new_order])
self.y0 = list(np.array(self.y0)[new_order])
self.X = list(np.array(self.X)[new_order])
self.y = list(np.array(self.y)[new_order])
self.step = list(np.array(self.step)[new_order])
self.last_update = list(np.array(self.last_update)[new_order])
# Evolves the model (main method)
def train(self, x, y, step):
best_EV = None
best_EV_value = 0
# check if it is possible to insert the sample in an existing model
for index in range(self.c):
tau = self.firing_degree(index, x, y)
if tau > best_EV_value and tau > self.sigma:
best_EV = index
best_EV_value = tau
update = False
# Add the sample to an existing EV
if best_EV is not None:
self.add_sample_to_EV(best_EV, x, y, step)
# Create a new EV
else:
self.add_EV(x, y, step)
update = True
self.update_EVs()
if step != 0 and (step % self.delta) == 0:
self.remove_outdated_EVs(step[0, 0] - self.delta)
self.merge()
update = True
if self.rho is not None:
if update:
self.update_R()
self.theta = self.srmtl.train(self.X, self.y, self.init_theta)
self.init_theta = 1
# Update the psi curve of the EVs
def update_EVs(self):
for i in range(self.c):
(X_ext, y_ext) = self.get_external_samples(i)
if X_ext.shape[0] > 0:
self.fit(i, X_ext, y_ext)
def update_R(self):
S = np.zeros((self.c, self.c))
for i in range(self.c):
S[i, :] = self.relationship_rules(i)
self.R = None
for i in range(self.c):
for j in range(i + 1, self.c):
if S[i, j] > 0 or S[j, i] > 0:
edge = | np.zeros((self.c, 1)) | numpy.zeros |
from pycode.tinyflow import autodiff as ad
import numpy as np
from pycode.tinyflow import ndarray
from pycode.tinyflow import TrainExecute
from pycode.tinyflow import train
def test_identity():
x2 = ad.Variable(name="x2")
y = x2
grad_x2, = ad.gradients(y, [x2])
executor = ad.Executor([y, grad_x2])
x2_val = 2 * np.ones(3)
y_val, grad_x2_val = executor.run(feed_dict={x2: x2_val})
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, x2_val)
assert np.array_equal(grad_x2_val, np.ones_like(x2_val))
def test_add_by_const():
x2 = ad.Variable(name="x2")
y = 5 + x2
grad_x2, = ad.gradients(y, [x2])
executor = ad.Executor([y, grad_x2])
x2_val = 2 * np.ones(3)
y_val, grad_x2_val = executor.run(feed_dict={x2: x2_val})
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, x2_val + 5)
assert np.array_equal(grad_x2_val, np.ones_like(x2_val))
def test_mul_by_const():
x2 = ad.Variable(name="x2")
y = 5 * x2
grad_x2, = ad.gradients(y, [x2])
executor = ad.Executor([y, grad_x2])
x2_val = 2 * np.ones(3)
y_val, grad_x2_val = executor.run(feed_dict={x2: x2_val})
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, x2_val * 5)
assert np.array_equal(grad_x2_val, np.ones_like(x2_val) * 5)
def test_add_two_vars():
x2 = ad.Variable(name="x2")
x3 = ad.Variable(name="x3")
y = x2 + x3
grad_x2, grad_x3 = ad.gradients(y, [x2, x3])
executor = ad.Executor([y, grad_x2, grad_x3])
x2_val = 2 * np.ones(3)
x3_val = 3 * np.ones(3)
y_val, grad_x2_val, grad_x3_val = executor.run(feed_dict={x2: x2_val, x3: x3_val})
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, x2_val + x3_val)
assert np.array_equal(grad_x2_val, np.ones_like(x2_val))
assert np.array_equal(grad_x3_val, np.ones_like(x3_val))
def test_mul_two_vars():
x2 = ad.Variable(name="x2")
x3 = ad.Variable(name="x3")
y = x2 * x3
grad_x2, grad_x3 = ad.gradients(y, [x2, x3])
executor = ad.Executor([y, grad_x2, grad_x3])
x2_val = 2 * np.ones(3)
x3_val = 3 * np.ones(3)
y_val, grad_x2_val, grad_x3_val = executor.run(feed_dict={x2: x2_val, x3: x3_val})
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, x2_val * x3_val)
assert np.array_equal(grad_x2_val, x3_val)
assert np.array_equal(grad_x3_val, x2_val)
def test_add_mul_mix_1():
x1 = ad.Variable(name="x1")
x2 = ad.Variable(name="x2")
x3 = ad.Variable(name="x3")
y = x1 + x2 * x3 * x1
grad_x1, grad_x2, grad_x3 = ad.gradients(y, [x1, x2, x3])
executor = ad.Executor([y, grad_x1, grad_x2, grad_x3])
x1_val = 1 * np.ones(3)
x2_val = 2 * np.ones(3)
x3_val = 3 * np.ones(3)
y_val, grad_x1_val, grad_x2_val, grad_x3_val = executor.run(feed_dict={x1: x1_val, x2: x2_val, x3: x3_val})
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, x1_val + x2_val * x3_val)
assert np.array_equal(grad_x1_val, np.ones_like(x1_val) + x2_val * x3_val)
assert np.array_equal(grad_x2_val, x3_val * x1_val)
assert np.array_equal(grad_x3_val, x2_val * x1_val)
def test_add_mul_mix_2():
x1 = ad.Variable(name="x1")
x2 = ad.Variable(name="x2")
x3 = ad.Variable(name="x3")
x4 = ad.Variable(name="x4")
y = x1 + x2 * x3 * x4
grad_x1, grad_x2, grad_x3, grad_x4 = ad.gradients(y, [x1, x2, x3, x4])
executor = ad.Executor([y, grad_x1, grad_x2, grad_x3, grad_x4])
x1_val = 1 * np.ones(3)
x2_val = 2 * np.ones(3)
x3_val = 3 * np.ones(3)
x4_val = 4 * np.ones(3)
y_val, grad_x1_val, grad_x2_val, grad_x3_val, grad_x4_val = executor.run(
feed_dict={x1: x1_val, x2: x2_val, x3: x3_val, x4: x4_val}
)
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, x1_val + x2_val * x3_val * x4_val)
assert np.array_equal(grad_x1_val, np.ones_like(x1_val))
assert np.array_equal(grad_x2_val, x3_val * x4_val)
assert np.array_equal(grad_x3_val, x2_val * x4_val)
assert np.array_equal(grad_x4_val, x2_val * x3_val)
def test_add_mul_mix_3():
x2 = ad.Variable(name="x2")
x3 = ad.Variable(name="x3")
z = x2 * x2 + x2 + x3 + 3
y = z * z + x3
grad_x2, grad_x3 = ad.gradients(y, [x2, x3])
executor = ad.Executor([y, grad_x2, grad_x3])
x2_val = 2 * np.ones(3)
x3_val = 3 * np.ones(3)
y_val, grad_x2_val, grad_x3_val = executor.run(feed_dict={x2: x2_val, x3: x3_val})
z_val = x2_val * x2_val + x2_val + x3_val + 3
expected_yval = z_val * z_val + x3_val
expected_grad_x2_val = 2 * (x2_val * x2_val + x2_val + x3_val + 3) * (2 * x2_val + 1)
expected_grad_x3_val = 2 * (x2_val * x2_val + x2_val + x3_val + 3) + 1
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, expected_yval)
assert np.array_equal(grad_x2_val, expected_grad_x2_val)
assert np.array_equal(grad_x3_val, expected_grad_x3_val)
def test_grad_of_grad():
x2 = ad.Variable(name="x2")
x3 = ad.Variable(name="x3")
y = x2 * x2 + x2 * x3
grad_x2, grad_x3 = ad.gradients(y, [x2, x3])
grad_x2_x2, grad_x2_x3 = ad.gradients(grad_x2, [x2, x3])
executor = ad.Executor([y, grad_x2, grad_x3, grad_x2_x2, grad_x2_x3])
x2_val = 2 * np.ones(3)
x3_val = 3 * np.ones(3)
y_val, grad_x2_val, grad_x3_val, grad_x2_x2_val, grad_x2_x3_val = executor.run(
feed_dict={x2: x2_val, x3: x3_val}
)
expected_yval = x2_val * x2_val + x2_val * x3_val
expected_grad_x2_val = 2 * x2_val + x3_val
expected_grad_x3_val = x2_val
expected_grad_x2_x2_val = 2 * np.ones_like(x2_val)
expected_grad_x2_x3_val = 1 * np.ones_like(x2_val)
assert isinstance(y, ad.Node)
assert np.array_equal(y_val, expected_yval)
assert np.array_equal(grad_x2_val, expected_grad_x2_val)
assert np.array_equal(grad_x3_val, expected_grad_x3_val)
assert np.array_equal(grad_x2_x2_val, expected_grad_x2_x2_val)
assert np.array_equal(grad_x2_x3_val, expected_grad_x2_x3_val)
def test_matmul_two_vars():
x2 = ad.Variable(name="x2")
x3 = ad.Variable(name="x3")
y = ad.matmul_op(x2, x3)
grad_x2, grad_x3 = ad.gradients(y, [x2, x3])
executor = ad.Executor([y, grad_x2, grad_x3])
x2_val = np.array([[1, 2], [3, 4], [5, 6]]) # 3x2
x3_val = np.array([[7, 8, 9], [10, 11, 12]]) # 2x3
y_val, grad_x2_val, grad_x3_val = executor.run(feed_dict={x2: x2_val, x3: x3_val})
expected_yval = np.matmul(x2_val, x3_val)
expected_grad_x2_val = np.matmul(np.ones_like(expected_yval), np.transpose(x3_val))
expected_grad_x3_val = np.matmul(np.transpose(x2_val), np.ones_like(expected_yval))
assert isinstance(y, ad.Node)
assert | np.array_equal(y_val, expected_yval) | numpy.array_equal |
import math
import numpy
import pytest
from stl.mesh import Mesh
from . import utils
def test_rotation():
# Create 6 faces of a cube
data = numpy.zeros(6, dtype=Mesh.dtype)
# Top of the cube
data['vectors'][0] = numpy.array([[0, 1, 1],
[1, 0, 1],
[0, 0, 1]])
data['vectors'][1] = numpy.array([[1, 0, 1],
[0, 1, 1],
[1, 1, 1]])
# Right face
data['vectors'][2] = numpy.array([[1, 0, 0],
[1, 0, 1],
[1, 1, 0]])
data['vectors'][3] = numpy.array([[1, 1, 1],
[1, 0, 1],
[1, 1, 0]])
# Left face
data['vectors'][4] = numpy.array([[0, 0, 0],
[1, 0, 0],
[1, 0, 1]])
data['vectors'][5] = numpy.array([[0, 0, 0],
[0, 0, 1],
[1, 0, 1]])
mesh = Mesh(data, remove_empty_areas=False)
# Since the cube faces are from 0 to 1 we can move it to the middle by
# substracting .5
data['vectors'] -= .5
# Rotate 90 degrees over the X axis followed by the Y axis followed by the
# X axis
mesh.rotate([0.5, 0.0, 0.0], math.radians(90))
mesh.rotate([0.0, 0.5, 0.0], math.radians(90))
mesh.rotate([0.5, 0.0, 0.0], math.radians(90))
# Since the cube faces are from 0 to 1 we can move it to the middle by
# substracting .5
data['vectors'] += .5
# We use a slightly higher absolute tolerance here, for ppc64le
# https://github.com/WoLpH/numpy-stl/issues/78
assert numpy.allclose(mesh.vectors, numpy.array([
[[1, 0, 0], [0, 1, 0], [0, 0, 0]],
[[0, 1, 0], [1, 0, 0], [1, 1, 0]],
[[0, 1, 1], [0, 1, 0], [1, 1, 1]],
[[1, 1, 0], [0, 1, 0], [1, 1, 1]],
[[0, 0, 1], [0, 1, 1], [0, 1, 0]],
[[0, 0, 1], [0, 0, 0], [0, 1, 0]],
]), atol=1e-07)
def test_rotation_over_point():
# Create a single face
data = numpy.zeros(1, dtype=Mesh.dtype)
data['vectors'][0] = numpy.array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
mesh = Mesh(data, remove_empty_areas=False)
mesh.rotate([1, 0, 0], math.radians(180), point=[1, 2, 3])
utils.array_equals(
mesh.vectors,
numpy.array([[[1., 4., 6.],
[0., 3., 6.],
[0., 4., 5.]]]))
mesh.rotate([1, 0, 0], math.radians(-180), point=[1, 2, 3])
utils.array_equals(
mesh.vectors,
numpy.array([[[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]]))
mesh.rotate([1, 0, 0], math.radians(180), point=0.0)
utils.array_equals(
mesh.vectors,
numpy.array([[[1., 0., -0.],
[0., -1., -0.],
[0., 0., -1.]]]))
with pytest.raises(TypeError):
mesh.rotate([1, 0, 0], math.radians(180), point='x')
def test_double_rotation():
# Create a single face
data = numpy.zeros(1, dtype=Mesh.dtype)
data['vectors'][0] = numpy.array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
mesh = Mesh(data, remove_empty_areas=False)
rotation_matrix = mesh.rotation_matrix([1, 0, 0], math.radians(180))
combined_rotation_matrix = numpy.dot(rotation_matrix, rotation_matrix)
mesh.rotate_using_matrix(combined_rotation_matrix)
utils.array_equals(
mesh.vectors,
numpy.array([[[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]]]))
def test_no_rotation():
# Create a single face
data = numpy.zeros(1, dtype=Mesh.dtype)
data['vectors'][0] = numpy.array([[0, 1, 1],
[1, 0, 1],
[0, 0, 1]])
mesh = Mesh(data, remove_empty_areas=False)
# Rotate by 0 degrees
mesh.rotate([0.5, 0.0, 0.0], math.radians(0))
assert numpy.allclose(mesh.vectors, numpy.array([
[[0, 1, 1], [1, 0, 1], [0, 0, 1]]]))
# Use a zero rotation matrix
mesh.rotate([0.0, 0.0, 0.0], math.radians(90))
assert numpy.allclose(mesh.vectors, numpy.array([
[[0, 1, 1], [1, 0, 1], [0, 0, 1]]]))
def test_no_translation():
# Create a single face
data = numpy.zeros(1, dtype=Mesh.dtype)
data['vectors'][0] = numpy.array([[0, 1, 1],
[1, 0, 1],
[0, 0, 1]])
mesh = Mesh(data, remove_empty_areas=False)
assert numpy.allclose(mesh.vectors, numpy.array([
[[0, 1, 1], [1, 0, 1], [0, 0, 1]]]))
# Translate mesh with a zero vector
mesh.translate([0.0, 0.0, 0.0])
assert numpy.allclose(mesh.vectors, numpy.array([
[[0, 1, 1], [1, 0, 1], [0, 0, 1]]]))
def test_translation():
# Create a single face
data = | numpy.zeros(1, dtype=Mesh.dtype) | numpy.zeros |
"""
Core
====
This module offer inclosed kernels' function for the construction of a Generalised Linear Model. The kernels
are organized into six categories:
1. Fire Probability
2. Internal Distribution
3. Rate Constant
4. Refractory
5. Response
6. Survivor
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import matplotlib.cm as cm
import inspect
import math
import scipy.special as ss
import sys
__all__=['negative_refractory','iaf_refractory','threshold_refractory','mean_lifetime','delay_response','normal_delay_response', 'gamma_response',\
'moto_response', 'alpha_response','linear','senoidal','exponential','rate_constant','fire_probability','survivor','interval_dist']
def negative_refractory(s,eta_0,delta,tau):
"""
.. py::function:
This is the Negative Refractory Kernel defined by:
.. math::
Kernel(s) = \Biggl \lbrace
{
1/\\Delta t, \\text{ if } 0 \leq s \leq \\Delta t
\\atop
-\\eta_{0}e^{(-s/\\tau)}, s \gt \\Delta t
}
:param s: The time difference :math:`s` between the actual (`t`) and the last fire time of the :math:`i^{th}` neuron (:math:`t_{i}^{f}`). Which is :math:`s=(t-t_{i}^{f})`
:type s: numpy.ndarray
:param eta_0: The hyperpolarization parameter :math:`\\eta_{0}`.
:type eta_0: int, float or numpy.ndarray
:param delta: The delay time constant :math:`\\Delta t`
:type delta: int, float or numpy.ndarray
:param tau: The membrane time constant :math:`\\tau`.
:type tau: int, float or numpy.ndarray
"""
heavside_1 = np.where((time>=0)&(time<=delta),1,0)
heavside_2 = np.where(time>delta,-eta_0,0)
value = heavside_2*np.exp(-s/tau) + heavside_1/delta
return value
def iaf_refractory(s,tau,r,i0):
"""
.. py::function:
This is the Integrate and Fire Refractory Kernel defined by:
.. math::
Kernel(s) = RI_{0}\left[1 - e^{-s/\\tau}\\right]
:param s: The time difference :math:`s` between the actual (`t`) and the last fire time of the :math:`i^{th}` neuron (:math:`t_{i}^{f}`). Which is :math:`s=(t-t_{i}^{f})`
:type s: numpy.ndarray
:param tau: The membrane time constant :math:`\\tau`.
:type tau: int, float or numpy.ndarray
:param r: The input resistance :math:`R`
:type r: int, float or numpy.ndarray
:param i0: The input constant current.
:type i0: int, float or numpy.ndarray
"""
def threshold_refractory(s, V_l, a, V_r,tau,r,h):
"""
.. py::function:
This is the Threshold Refractory Kernel defined by:
.. math::
Kernel(s) = \Biggl \lbrace
{
A(V_{l}-V_{r})e^{- \\frac { (s-\\tau) } { 2 } + s^{r}}, \\text{ if } 0 \lt s \lt \\tau
\\atop
- \\frac { 1 } { h } e^{- \\frac { (s-\\tau) } { 2 } + s^{r}}, \\text{ if } s \gt \\tau
}
:param s: The time difference :math:`s` between the actual (`t`) and the last fire time of the :math:`i^{th}` neuron (:math:`t_{i}^{f}`). Which is :math:`s=(t-t_{i}^{f})`
:type s: numpy.ndarray
:param V_l: This is the theshold potential :math:`V_{l}`
:type V_l: int, float or numpy.ndarray
:param a: This is the action potential amplitude :math:`A`
:type a: int, float or numpy.ndarray
:param V_r: This is the rest potential :math:`V_{r}`
:type V_r: int, float or nupy.ndarray
:param tau: The membrane time constant :math:`\\tau`.
:type tau: int, float or numpy.ndarray
:param r: This is the refractory control parameter
:type r: int, float or numpy.ndarray
:param h: This is the hyperpolarization control parameter
:type h: int, float or numpy.narray
"""
heavside = np.where((s>0)&(s<tau),-a,0)
heavside = np.where(s>tau,1/h*(V_l-V_r),heavside)
val = -heavside*(V_l-V_r)*np.exp(-(s-tau)/2 + s**r)
return val
def mean_lifetime(s,tau):
"""
.. py::function:
This is the Mean Lifetime Kernel defined by:
.. math::
Kernel(s) = \\theta(s)e^{(-s/\\tau)}
Where:
.. math::
\\theta(s) = \Biggl \lbrace
{
1,\\text{ if }s\geq0
\\atop
0,\\text{ otherwise}
}
:param s: The time difference :math:`s` between the actual (`t`) and the last fire time of the :math:`i^{th}` neuron (:math:`t_{i}^{f}`). Which is :math:`s=(t-t_{i}^{f})`
:type s: numpy.ndarray
:param tau: The membrane time constant :math:`\\tau`.
:type tau: int, float or numpy.ndarray
"""
heavside = np.where(s>=0,1,0)
return heavside*np.exp(-s/tau)
def delay_response(s,delta,tau):
"""
.. py::function:
This is the Delay Response Kernel defined by:
.. math::
Kernel(s) = \\theta(s)e^{(-(s-\\Delta t)/\\tau)}
Where:
.. math::
\\theta(s) = \Biggl \lbrace
{
1,\\text{ if }s\geq\\Delta t
\\atop
0,\\text{ otherwise}
}
:param s: The time difference :math:`s` between the actual (`t`) and the last fire time of the :math:`i^{th}` neuron (:math:`t_{i}^{f}`). Which is :math:`s=(t-t_{i}^{f})`
:type s: numpy.ndarray
:param delta: The transmissision time delay :math:`\\Delta t`
:type delta: int, float or numpy.ndarray
:param tau: The membrane time constant :math:`\\tau`.
:type tau: int, float or numpy.ndarray
"""
heavside = np.where(s>delta,1,0)
#print(heavside)
return heavside*np.exp(-(s-delta)/tau)
def normal_delay_response(s,delta,tau):
"""
.. py::function:
This is the Normal Delay Response Kernel defined by:
.. math::
Kernel(s) = \\theta(s)e^{(-(s-\\Delta t)/\\tau)}
Where:
.. math::
\\theta(s) = \Biggl \lbrace
{
1,\\text{ if }s\geq\\Delta t
\\atop
N(0,0.1),\\text{ otherwise}
}
:param s: The time difference :math:`s` between the actual (`t`) and the last fire time of the :math:`i^{th}` neuron (:math:`t_{i}^{f}`). Which is :math:`s=(t-t_{i}^{f})`
:type s: numpy.ndarray
:param delta: The transmissision time delay :math:`\\Delta t`
:type delta: int, float or numpy.ndarray
:param tau: The membrane time constant :math:`\\tau`.
:type tau: int, float or numpy.ndarray
"""
heavside = np.where(s>delta,1,np.random.normal(0.5,0.1))
return heavside* | np.exp(-(s-delta)/tau) | numpy.exp |
""" Module to correct pulsar and FRB DMs for the MW ISM """
from ne2001 import ne_io, density #ne2001 ism model
import pygedm #ymw ism model
import numpy as np
import pandas as pd
from astropy import units as u
from astropy.coordinates import SkyCoord, Galactic
import logging
logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.INFO)
ne = density.ElectronDensity()
def find_delta_dm(transient_type,transient_data,ism_model,b_val,mc_deg=5,save_df=True):
"""
Find pulsar/FRB DMs corrected for by the MW ISM DM and remove observations in complex DM regions.
Returns array of DMs
FRB data is available as a csv in the FRBs/FRB/frb/data/FRBs repo (FRB catalogue [Petroff et al. 2017])
Pulsar data is avaiable as a csv in the FRBs/pulsars/pulsars/data/atnf_cat repo (v1.61 ATNF pulsar catalogue [Manchester et al. 2005])
Arguments:
transient_type (str):
Accepts 'frb' or 'pulsar'.
transient_data (str):
Path to data (in .csv format).
ism_model (str):
Model used to calculated the MW halo DM.
Accepts 'ymw16' [Yao et al. 2017] or 'ne2001' [Cordes & Lazio 2003].
b_val (int):
Galactic latitude considered (b>b_val, b<-b_val).
mc_deg (int):
Number of degrees from Magellanic clouds within which transients are removed.
save_df (str, optional):
Save transient DMs and coords to csv.
Outputs:
"""
# Sort data and get coords
if transient_type=='frb':
transcat_df = pd.read_csv(transient_data, skiprows=1, usecols= [0,5,6,7], names=['Name','l','b','dm'])
transcat_df['dm'] = transcat_df['dm'].str.split('&').str[0].astype(float).values
coords = SkyCoord(l=transcat_df['l'], b=transcat_df['b'], unit=(u.degree),frame=Galactic)
elif transient_type=='pulsar':
transcat_df = pd.read_csv(transient_data, skiprows=2, usecols = [1,2,3,9,10], names=['Name','Pref','dm','RAJD','DECJD'])
transcat_df = transcat_df[~transcat_df['dm'].str.contains('*', regex=False)].reset_index(drop=True)
transcat_df['dm'] = transcat_df['dm'].astype(float)
c_icrs = SkyCoord(ra=transcat_df['RAJD'], dec=transcat_df['DECJD'], unit=(u.degree), frame='icrs')
transcat_df['l'] = pd.DataFrame(c_icrs.galactic.l.value)
transcat_df['b'] = pd.DataFrame(c_icrs.galactic.b.value)
coords = SkyCoord(l=transcat_df['l'], b=transcat_df['b'], unit=(u.degree),frame=Galactic)
# Find transients in line of sight of MCs
logging.info('Removing transients near Magellanic clouds...')
# LMC
lmc_distance = 50*u.kpc
lmc_coord = SkyCoord('J052334.6-694522',unit=(u.hourangle, u.deg),distance=lmc_distance)
close_to_lmc = lmc_coord.separation(coords) < mc_deg*u.deg
lmc_trans = list(transcat_df[close_to_lmc]['Name'])
# SMC
smc_distance = 61*u.kpc
smc_coord = SkyCoord('J005238.0-724801',unit=(u.hourangle, u.deg),distance=smc_distance)
close_to_smc = smc_coord.separation(coords) < mc_deg*u.deg
smc_trans = list(transcat_df[close_to_smc]['Name'])
transcat_df = transcat_df[~transcat_df['Name'].isin(lmc_trans)].reset_index(drop=True)
transcat_df = transcat_df[~transcat_df['Name'].isin(smc_trans)].reset_index(drop=True)
if transient_type=='pulsar':
transcat_df = transcat_df[~transcat_df['Pref'].str.contains('mfl+06', regex=False)].reset_index(drop=True)
elif transient_type=='frb':
pass
# Remove transients with low Galactic lattitudes
logging.info('Removing transients with low Galactic lattitudes...')
transcat_df = pd.concat([transcat_df[transcat_df.b > b_val], transcat_df[transcat_df.b < -b_val]], ignore_index=True)
# ISM model
logging.info('Correcting transient DMs for ISM...')
trans_ism = []
if ism_model=='ymw16':
for i in range(len(transcat_df['dm'])):
trans_ism_ = pygedm.dist_to_dm(transcat_df['l'].iloc[i], transcat_df['b'].iloc[i], 100000)[0].value
trans_ism = np.append(trans_ism,trans_ism_)
elif ism_model=='ne2001':
for i in range(len(transcat_df['dm'])):
trans_ism_ = ne.DM(transcat_df['l'].iloc[i], transcat_df['b'].iloc[i], 100.).value
trans_ism = np.append(trans_ism,trans_ism_)
transcat_df['trans_ism'] = pd.DataFrame(trans_ism)
transcat_df['deltaDM'] = pd.DataFrame(transcat_df['dm']-transcat_df['trans_ism'])
if save_df==True:
transcat_df.to_csv('transient_data/'+transient_type+'cat_df_'+ism_model+'_'+str(int(b_val))+'.csv')
logging.info('Transient data saved to csv.')
else:
pass
return | np.array(transcat_df['deltaDM']) | numpy.array |
"""Rangeland Production Model."""
import os
import logging
import tempfile
import shutil
from builtins import range
import re
import math
import pickle
import numpy
import pandas
from osgeo import ogr
from osgeo import osr
from osgeo import gdal
import pygeoprocessing
from rangeland_production import utils
from rangeland_production import validation
LOGGER = logging.getLogger('rangeland_production.forage')
# we only have these types of soils
SOIL_TYPE_LIST = ['clay', 'silt', 'sand']
# temporary directory to store intermediate files
PROCESSING_DIR = None
# user-supplied crude protein of vegetation
CRUDE_PROTEIN = None
# state variables and parameters take their names from Century
# _SITE_STATE_VARIABLE_FILES contains state variables that are a
# property of the site, including:
# carbon in each soil compartment
# (structural, metabolic, som1, som2, som3) and layer (1=surface, 2=soil)
# e.g., som2c_2 = carbon in soil som2;
# N and P in each soil layer and compartment (1=N, 2=P)
# e.g., som2e_1_1 = N in surface som2, som2e_1_2 = P in surface som2;
# water in each soil layer, asmos_<layer>
# state variables fully described in this table:
# https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
_SITE_STATE_VARIABLE_FILES = {
'metabc_1_path': 'metabc_1.tif',
'metabc_2_path': 'metabc_2.tif',
'som1c_1_path': 'som1c_1.tif',
'som1c_2_path': 'som1c_2.tif',
'som2c_1_path': 'som2c_1.tif',
'som2c_2_path': 'som2c_2.tif',
'som3c_path': 'som3c.tif',
'strucc_1_path': 'strucc_1.tif',
'strucc_2_path': 'strucc_2.tif',
'strlig_1_path': 'strlig_1.tif',
'strlig_2_path': 'strlig_2.tif',
'metabe_1_1_path': 'metabe_1_1.tif',
'metabe_2_1_path': 'metabe_2_1.tif',
'som1e_1_1_path': 'som1e_1_1.tif',
'som1e_2_1_path': 'som1e_2_1.tif',
'som2e_1_1_path': 'som2e_1_1.tif',
'som2e_2_1_path': 'som2e_2_1.tif',
'som3e_1_path': 'som3e_1.tif',
'struce_1_1_path': 'struce_1_1.tif',
'struce_2_1_path': 'struce_2_1.tif',
'metabe_1_2_path': 'metabe_1_2.tif',
'metabe_2_2_path': 'metabe_2_2.tif',
'plabil_path': 'plabil.tif',
'secndy_2_path': 'secndy_2.tif',
'parent_2_path': 'parent_2.tif',
'occlud_path': 'occlud.tif',
'som1e_1_2_path': 'som1e_1_2.tif',
'som1e_2_2_path': 'som1e_2_2.tif',
'som2e_1_2_path': 'som2e_1_2.tif',
'som2e_2_2_path': 'som2e_2_2.tif',
'som3e_2_path': 'som3e_2.tif',
'struce_1_2_path': 'struce_1_2.tif',
'struce_2_2_path': 'struce_2_2.tif',
'asmos_1_path': 'asmos_1.tif',
'asmos_2_path': 'asmos_2.tif',
'asmos_3_path': 'asmos_3.tif',
'asmos_4_path': 'asmos_4.tif',
'asmos_5_path': 'asmos_5.tif',
'asmos_6_path': 'asmos_6.tif',
'asmos_7_path': 'asmos_7.tif',
'asmos_8_path': 'asmos_8.tif',
'asmos_9_path': 'asmos_9.tif',
'avh2o_3_path': 'avh2o_3.tif',
'minerl_1_1_path': 'minerl_1_1.tif',
'minerl_2_1_path': 'minerl_2_1.tif',
'minerl_3_1_path': 'minerl_3_1.tif',
'minerl_4_1_path': 'minerl_4_1.tif',
'minerl_5_1_path': 'minerl_5_1.tif',
'minerl_6_1_path': 'minerl_6_1.tif',
'minerl_7_1_path': 'minerl_7_1.tif',
'minerl_8_1_path': 'minerl_8_1.tif',
'minerl_9_1_path': 'minerl_9_1.tif',
'minerl_10_1_path': 'minerl_10_1.tif',
'minerl_1_2_path': 'minerl_1_2.tif',
'minerl_2_2_path': 'minerl_2_2.tif',
'minerl_3_2_path': 'minerl_3_2.tif',
'minerl_4_2_path': 'minerl_4_2.tif',
'minerl_5_2_path': 'minerl_5_2.tif',
'minerl_6_2_path': 'minerl_6_2.tif',
'minerl_7_2_path': 'minerl_7_2.tif',
'minerl_8_2_path': 'minerl_8_2.tif',
'minerl_9_2_path': 'minerl_9_2.tif',
'minerl_10_2_path': 'minerl_10_2.tif',
'snow_path': 'snow.tif',
'snlq_path': 'snlq.tif',
}
# _PFT_STATE_VARIABLES contains state variables that are a
# property of a PFT, including:
# carbon, nitrogen, and phosphorous in aboveground biomass
# where 1=N, 2=P
# e.g. aglivc = C in aboveground live biomass,
# aglive_1 = N in aboveground live biomass;
# carbon, nitrogen, and phosphorous in aboveground standing dead
# biomass, stdedc and stdede;
# carbon, nitrogen and phosphorous in belowground live biomass,
# aglivc and aglive
# state variables fully described in this table:
# https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
_PFT_STATE_VARIABLES = [
'aglivc', 'bglivc', 'stdedc', 'aglive_1', 'bglive_1',
'stdede_1', 'aglive_2', 'bglive_2', 'stdede_2', 'avh2o_1',
'crpstg_1', 'crpstg_2',
]
# intermediate parameters that do not change between timesteps,
# including field capacity and wilting point of each soil layer,
# coefficients describing effect of soil texture on decomposition
# rates
_PERSISTENT_PARAMS_FILES = {
'afiel_1_path': 'afiel_1.tif',
'afiel_2_path': 'afiel_2.tif',
'afiel_3_path': 'afiel_3.tif',
'afiel_4_path': 'afiel_4.tif',
'afiel_5_path': 'afiel_5.tif',
'afiel_6_path': 'afiel_6.tif',
'afiel_7_path': 'afiel_7.tif',
'afiel_8_path': 'afiel_8.tif',
'afiel_9_path': 'afiel_9.tif',
'awilt_1_path': 'awilt_1.tif',
'awilt_2_path': 'awilt_2.tif',
'awilt_3_path': 'awilt_3.tif',
'awilt_4_path': 'awilt_4.tif',
'awilt_5_path': 'awilt_5.tif',
'awilt_6_path': 'awilt_6.tif',
'awilt_7_path': 'awilt_7.tif',
'awilt_8_path': 'awilt_8.tif',
'awilt_9_path': 'awilt_9.tif',
'wc_path': 'wc.tif',
'eftext_path': 'eftext.tif',
'p1co2_2_path': 'p1co2_2.tif',
'fps1s3_path': 'fps1s3.tif',
'orglch_path': 'orglch.tif',
'fps2s3_path': 'fps2s3.tif',
'rnewas_1_1_path': 'rnewas_1_1.tif',
'rnewas_2_1_path': 'rnewas_2_1.tif',
'rnewas_1_2_path': 'rnewas_1_2.tif',
'rnewas_2_2_path': 'rnewas_2_2.tif',
'rnewbs_1_1_path': 'rnewbs_1_1.tif',
'rnewbs_1_2_path': 'rnewbs_1_2.tif',
'rnewbs_2_1_path': 'rnewbs_2_1.tif',
'rnewbs_2_2_path': 'rnewbs_2_2.tif',
'vlossg_path': 'vlossg.tif',
}
# site-level values that are updated once per year
_YEARLY_FILES = {
'annual_precip_path': 'annual_precip.tif',
'baseNdep_path': 'baseNdep.tif',
}
# pft-level values that are updated once per year
_YEARLY_PFT_FILES = ['pltlig_above', 'pltlig_below']
# intermediate values for each plant functional type that are shared
# between submodels, but do not need to be saved as output
_PFT_INTERMEDIATE_VALUES = [
'h2ogef_1', 'tgprod_pot_prod',
'cercrp_min_above_1', 'cercrp_min_above_2',
'cercrp_max_above_1', 'cercrp_max_above_2',
'cercrp_min_below_1', 'cercrp_min_below_2',
'cercrp_max_below_1', 'cercrp_max_below_2',
'tgprod', 'rtsh', 'flgrem', 'fdgrem']
# intermediate site-level values that are shared between submodels,
# but do not need to be saved as output
_SITE_INTERMEDIATE_VALUES = [
'amov_1', 'amov_2', 'amov_3', 'amov_4', 'amov_5', 'amov_6', 'amov_7',
'amov_8', 'amov_9', 'amov_10', 'snowmelt', 'bgwfunc', 'diet_sufficiency']
# fixed parameters for each grazing animal type are adapted from the GRAZPLAN
# model as described by Freer et al. 2012, "The GRAZPLAN animal biology model
# for sheep and cattle and the GrazFeed decision support tool"
_FREER_PARAM_DICT = {
'b_indicus': {
'CN1': 0.0115,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.025,
'CI2': 1.7,
'CI8': 62,
'CI9': 1.7,
'CI15': 0.5,
'CI19': 0.416,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00078,
'CR5': 0.6,
'CR6': 0.00074,
'CR7': 0.5,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.375,
'CL1': 4,
'CL2': 30,
'CL3': 0.6,
'CL5': 0.94,
'CL6': 3.1,
'CL15': 0.032,
'CM1': 0.09,
'CM2': 0.31,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.0025,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CP1': 285,
'CP4': 0.33,
'CP5': 1.8,
'CP6': 2.42,
'CP7': 1.16,
'CP8': 4.11,
'CP9': 343.5,
'CP10': 0.0164,
'CP15': 0.07,
},
'b_taurus': {
'CN1': 0.0115,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.025,
'CI2': 1.7,
'CI8': 62,
'CI9': 1.7,
'CI15': 0.5,
'CI19': 0.416,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00078,
'CR5': 0.6,
'CR6': 0.00074,
'CR7': 0.5,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.375,
'CL1': 4,
'CL2': 30,
'CL3': 0.6,
'CL5': 0.94,
'CL6': 3.1,
'CL15': 0.032,
'CM1': 0.09,
'CM2': 0.36,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.0025,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CP1': 285,
'CP4': 0.33,
'CP5': 1.8,
'CP6': 2.42,
'CP7': 1.16,
'CP8': 4.11,
'CP9': 343.5,
'CP10': 0.0164,
'CP15': 0.07,
},
'indicus_x_taurus': {
'CN1': 0.0115,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.025,
'CI2': 1.7,
'CI8': 62,
'CI9': 1.7,
'CI15': 0.5,
'CI19': 0.416,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00078,
'CR5': 0.6,
'CR6': 0.00074,
'CR7': 0.5,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.375,
'CL1': 4,
'CL2': 30,
'CL3': 0.6,
'CL5': 0.94,
'CL6': 3.1,
'CL15': 0.032,
'CM1': 0.09,
'CM2': 0.335,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.0025,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CP1': 285,
'CP4': 0.33,
'CP5': 1.8,
'CP6': 2.42,
'CP7': 1.16,
'CP8': 4.11,
'CP9': 343.5,
'CP10': 0.0164,
'CP15': 0.07,
},
'sheep': {
'CN1': 0.0157,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.04,
'CI2': 1.7,
'CI8': 28,
'CI9': 1.4,
'CI12': 0.15,
'CI13': 0.02,
'CI14': 0.002,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00112,
'CR5': 0.6,
'CR6': 0.00112,
'CR7': 0,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.486,
'CL1': 2,
'CL2': 22,
'CL3': 1,
'CL5': 0.94,
'CL6': 4.7,
'CL15': 0.045,
'CM1': 0.09,
'CM2': 0.26,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.02,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CW1': 24,
'CW2': 0.004,
'CW3': 0.7,
'CW5': 0.25,
'CW6': 0.072,
'CW7': 1.35,
'CW8': 0.016,
'CW9': 1,
'CW12': 0.025,
'CP1': 150,
'CP4': 0.33,
'CP5': 1.43,
'CP6': 3.38,
'CP7': 0.91,
'CP8': 4.33,
'CP9': 4.37,
'CP10': 0.965,
'CP15': 0.1,
},
}
# Target nodata is for general rasters that are positive, and _IC_NODATA are
# for rasters that are any range
_TARGET_NODATA = -1.0
_IC_NODATA = float(numpy.finfo('float32').min)
# SV_NODATA is for state variables
_SV_NODATA = -1.0
def execute(args):
"""InVEST Forage Model.
[model description]
Parameters:
args['workspace_dir'] (string): path to target output workspace.
args['results_suffix'] (string): (optional) string to append to any
output file names
args['starting_month'] (int): what month to start reporting where
the range 1..12 is equivalent to Jan..Dec.
args['starting_year'] (int): what year to start runs. this value is
used to notate outputs in the form [month_int]_[year]
args['n_months'] (int): number of months to run model, the model run
will start reporting in `args['starting_month']`.
args['aoi_path'] (string): path to polygon vector indicating the
desired spatial extent of the model. This has the effect of
clipping the computational area of the input datasets to be the
area intersected by this polygon.
args['management_threshold'] (float): biomass in kg/ha required to be
left standing at each model step after offtake by grazing animals
args['proportion_legume_path'] (string): path to raster containing
fraction of pasture that is legume, by weight
args['bulk_density_path'] (string): path to bulk density raster.
args['ph_path'] (string): path to soil pH raster.
args['clay_proportion_path'] (string): path to raster representing
per-pixel proportion of soil component that is clay
args['silt_proportion_path'] (string): path to raster representing
per-pixel proportion of soil component that is silt
args['sand_proportion_path'] (string): path to raster representing
per-pixel proportion of soil component that is sand
args['precip_dir'] (string): path to a directory containing monthly
precipitation rasters. The model requires at least 12 months of
precipitation and expects to find a precipitation file input for
every month of the simulation, so the number of precipitation
files should be the maximum of 12 and `n_months`. The file name of
each precipitation raster must end with the year, followed by an
underscore, followed by the month number. E.g., Precip_2016_1.tif
for January of 2016.
args['min_temp_dir'] (string): path to a directory containing monthly
minimum temperature rasters. The model requires one minimum
temperature raster for each month of the year, or each month that
the model is run, whichever is smaller. The file name of each
minimum temperature raster must end with the month number. E.g.,
Min_temperature_1.tif for January.
args['max_temp_dir'] (string): path to a directory containing monthly
maximum temperature rasters. The model requires one maximum
temperature raster for each month of the year, or each month that
the model is run, whichever is smaller. The file name of each
maximum temperature raster must end with the month number. E.g.,
Max_temperature_1.tif for January.
args['site_param_table'] (string): path to csv file giving site
parameters. This file must contain a column named "site" that
contains unique integers. These integer values correspond to site
type identifiers which are values in the site parameter spatial
index raster. Other required fields for this table are site and
"fixed" parameters from the Century model, i.e., the parameters
in the Century input files site.100 and fix.100.
args['site_param_spatial_index_path'] (string): path to a raster file
that indexes site parameters, indicating which set of site
parameter values should apply at each pixel in the raster. The
raster should be composed of integers that correspond to values in
the field "site" in `site_param_table`.
args['veg_trait_path'] (string): path to csv file giving vegetation
traits for each plant functional type available for grazing. This
file must contain a column named "PFT" that contains unique
integers. These integer values correspond to PFT identifiers of
veg spatial composition rasters. Other required fields for this
table are vegetation input parameters from the Century model, for
example maximum intrinsic growth rate, optimum temperature for
production, minimum C/N ratio, etc.
args['veg_spatial_composition_path_pattern'] (string): path to
vegetation rasters, one per plant functional type available for
grazing, where <PFT> can be replaced with an integer that is
indexed in the veg trait csv.
Example: if this value is given as `./vegetation/pft_<PFT>.tif`
and the directory `./vegetation/` contains these files:
"pft_1.tif"
"pft_12.tif"
"pft_50.tif",
then the "PFT" field in the vegetation trait table must contain
the values 1, 12, and 50.
args['animal_trait_path'] (string): path to csv file giving animal
traits for each animal type - number - duration combination. This
table must contain a column named "animal_id" that contains unique
integers. These integer values correspond to features in the
animal management layer.
Other required fields in this table are:
type (allowable values: b_indicus, b_taurus,
indicus_x_taurus, sheep, camelid, hindgut_fermenter)
sex (allowable values: entire_m, castrate, breeding_female,
NA)
age (days)
weight (kg)
SRW (standard reference weight, kg; the weight of a mature
female in median condition)
SFW (standard fleece weight, kg; the average weight of fleece
of a mature adult; for sheep only)
birth_weight (kg)
grz_months (a string of integers, separated by ','; months of
the simulation when animals are present,
relative to `starting_month`. For example, if `n_months`
is 3, and animals are present during the entire simulation
period, `grz_months` should be "1,2,3")
args['animal_grazing_areas_path'] (string): path to animal vector
inputs giving the location of grazing animals. Must have a field
named "animal_id", containing unique integers that correspond to
the values in the "animal_id" column of the animal trait csv, and
a field named "num_animal" giving the number of animals grazing
inside each polygon feature.
args['initial_conditions_dir'] (string): optional input, path to
directory containing initial conditions. If this directory is not
supplied, a site_initial_table and pft_initial_table must be
supplied. If supplied, this directory must contain a series of
rasters with initial values for each PFT and for the site.
Required rasters for each PFT:
initial variables that are a property of PFT in the table
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
e.g., aglivc_<PFT>.tif
Required for the site:
initial variables that are a property of site in the table
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
args['site_initial_table'] (string): optional input, path to table
containing initial conditions for each site state variable. If an
initial conditions directory is not supplied, this table must be
supplied. This table must contain a value for each site code and
each state variable listed in the following table:
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
args['pft_initial_table'] (string): optional input, path to table
containing initial conditions for each plant functional type state
variable. If an initial conditions directory is not supplied, this
table must be supplied. This table must contain a value for each
plant functional type index and each state variable listed in the
following table:
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
args['save_sv_rasters'] (boolean): optional input, default false.
Should rasters containing all state variables be saved for each
model time step?
args['animal_density'] (string): optional input, density of grazing
animals in animals per hectare.
args['crude_protein'] (float): optional input, crude protein
concentration of forage for the purposes of animal diet selection.
Should be a value between 0-1. If included, this value is
substituted for N content of forage when calculating digestibility
and "ingestibility" of forage, and protein content of the diet, for
grazing animals.
Returns:
None.
"""
LOGGER.info("model execute: %s", args)
starting_month = int(args['starting_month'])
starting_year = int(args['starting_year'])
n_months = int(args['n_months'])
try:
delete_sv_folders = not args['save_sv_rasters']
except KeyError:
delete_sv_folders = True
try:
global CRUDE_PROTEIN
CRUDE_PROTEIN = args['crude_protein']
except KeyError:
pass
try:
animal_density_path = args['animal_density']
except KeyError:
args['animal_density'] = None
# this set will build up the integer months that are used so we can index
# them with temperature later
temperature_month_set = set()
# this dict will be used to build the set of input rasters associated with
# a reasonable lookup ID so we can have a nice dataset to align for raster
# stack operations
base_align_raster_path_id_map = {}
precip_dir_list = [
os.path.join(args['precip_dir'], f) for f in
os.listdir(args['precip_dir'])]
for month_index in range(n_months):
month_i = (starting_month + month_index - 1) % 12 + 1
temperature_month_set.add(month_i)
year = starting_year + (starting_month + month_index - 1) // 12
year_month_match = re.compile(
r'.*[^\d]%d_%d\.[^.]+$' % (year, month_i))
file_list = [
month_file_path for month_file_path in precip_dir_list if
year_month_match.match(month_file_path)]
if len(file_list) == 0:
raise ValueError(
"No precipitation data found for year %d, month %d" %
(year, month_i))
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for year %d, month %d: %s" %
(year, month_i, file_list))
base_align_raster_path_id_map[
'precip_{}'.format(month_index)] = file_list[0]
# the model requires 12 months of precipitation data to calculate
# atmospheric N deposition and potential production from annual precip
n_precip_months = int(args['n_months'])
if n_precip_months < 12:
m_index = int(args['n_months'])
while n_precip_months < 12:
month_i = (starting_month + m_index - 1) % 12 + 1
year = starting_year + (starting_month + m_index - 1) // 12
year_month_match = re.compile(
r'.*[^\d]%d_%d\.[^.]+$' % (year, month_i))
file_list = [
month_file_path for month_file_path in precip_dir_list if
year_month_match.match(month_file_path)]
if len(file_list) == 0:
break
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for year %d, month %d: %s" %
(year, month_i, file_list))
base_align_raster_path_id_map[
'precip_%d' % m_index] = file_list[0]
n_precip_months = n_precip_months + 1
m_index = m_index + 1
if n_precip_months < 12:
raise ValueError("At least 12 months of precipitation data required")
# collect monthly temperature data
min_temp_dir_list = [
os.path.join(args['min_temp_dir'], f) for f in
os.listdir(args['min_temp_dir'])]
for month_i in temperature_month_set:
month_file_match = re.compile(r'.*[^\d]%d\.[^.]+$' % month_i)
file_list = [
month_file_path for month_file_path in min_temp_dir_list if
month_file_match.match(month_file_path)]
if len(file_list) == 0:
raise ValueError(
"No minimum temperature data found for month %d" % month_i)
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for month %d: %s" %
(month_i, file_list))
base_align_raster_path_id_map[
'min_temp_%d' % month_i] = file_list[0]
max_temp_dir_list = [
os.path.join(args['max_temp_dir'], f) for f in
os.listdir(args['max_temp_dir'])]
for month_i in temperature_month_set:
month_file_match = re.compile(r'.*[^\d]%d\.[^.]+$' % month_i)
file_list = [
month_file_path for month_file_path in max_temp_dir_list if
month_file_match.match(month_file_path)]
if len(file_list) == 0:
raise ValueError(
"No maximum temperature data found for month %d" % month_i)
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for month %d: %s" %
(month_i, file_list))
base_align_raster_path_id_map[
'max_temp_%d' % month_i] = file_list[0]
# lookup to provide path to soil percent given soil type
for soil_type in SOIL_TYPE_LIST:
base_align_raster_path_id_map[soil_type] = (
args['%s_proportion_path' % soil_type])
if not os.path.exists(base_align_raster_path_id_map[soil_type]):
raise ValueError(
"Couldn't find %s for %s" % (
base_align_raster_path_id_map[soil_type], soil_type))
base_align_raster_path_id_map['bulk_d_path'] = args['bulk_density_path']
base_align_raster_path_id_map['ph_path'] = args['ph_path']
# make sure site initial conditions and parameters exist for each site
# identifier
base_align_raster_path_id_map['site_index'] = (
args['site_param_spatial_index_path'])
n_bands = pygeoprocessing.get_raster_info(
args['site_param_spatial_index_path'])['n_bands']
if n_bands > 1:
raise ValueError(
'Site spatial index raster must contain only one band')
site_datatype = pygeoprocessing.get_raster_info(
args['site_param_spatial_index_path'])['datatype']
if site_datatype not in [1, 2, 3, 4, 5]:
raise ValueError('Site spatial index raster must be integer type')
# get unique values in site param raster
site_index_set = set()
for offset_map, raster_block in pygeoprocessing.iterblocks(
(args['site_param_spatial_index_path'], 1)):
site_index_set.update(numpy.unique(raster_block))
site_nodata = pygeoprocessing.get_raster_info(
args['site_param_spatial_index_path'])['nodata'][0]
if site_nodata in site_index_set:
site_index_set.remove(site_nodata)
site_param_table = utils.build_lookup_from_csv(
args['site_param_table'], 'site')
missing_site_index_list = list(
site_index_set.difference(site_param_table.keys()))
if missing_site_index_list:
raise ValueError(
"Couldn't find parameter values for the following site " +
"indices: %s\n\t" + ", ".join(missing_site_index_list))
# make sure plant functional type parameters exist for each pft raster
pft_dir = os.path.dirname(args['veg_spatial_composition_path_pattern'])
pft_basename = os.path.basename(
args['veg_spatial_composition_path_pattern'])
files = [
f for f in os.listdir(pft_dir) if os.path.isfile(
os.path.join(pft_dir, f))]
pft_regex = re.compile(pft_basename.replace('<PFT>', r'(\d+)'))
pft_matches = [
m for m in [pft_regex.search(f) for f in files] if m is not None]
pft_id_set = set([int(m.group(1)) for m in pft_matches])
for pft_i in pft_id_set:
pft_path = args['veg_spatial_composition_path_pattern'].replace(
'<PFT>', '%d' % pft_i)
base_align_raster_path_id_map['pft_%d' % pft_i] = pft_path
veg_trait_table = utils.build_lookup_from_csv(
args['veg_trait_path'], 'PFT')
missing_pft_trait_list = pft_id_set.difference(veg_trait_table.keys())
if missing_pft_trait_list:
raise ValueError(
"Couldn't find trait values for the following plant functional " +
"types: %s\n\t" + ", ".join(missing_pft_trait_list))
frtcindx_set = set([
pft_i['frtcindx'] for pft_i in veg_trait_table.values()])
if frtcindx_set.difference(set([0, 1])):
raise ValueError("frtcindx parameter contains invalid values")
base_align_raster_path_id_map['proportion_legume_path'] = args[
'proportion_legume_path']
# track separate state variable files for each PFT
pft_sv_dict = {}
for pft_i in pft_id_set:
for sv in _PFT_STATE_VARIABLES:
pft_sv_dict['{}_{}_path'.format(
sv, pft_i)] = '{}_{}.tif'.format(sv, pft_i)
# make sure animal traits exist for each feature in animal management
# layer
anim_id_list = []
driver = ogr.GetDriverByName('ESRI Shapefile')
datasource = driver.Open(args['animal_grazing_areas_path'], 0)
layer = datasource.GetLayer()
for feature in layer:
anim_id_list.append(feature.GetField('animal_id'))
input_animal_trait_table = utils.build_lookup_from_csv(
args['animal_trait_path'], 'animal_id')
missing_animal_trait_list = set(
anim_id_list).difference(input_animal_trait_table.keys())
if missing_animal_trait_list:
raise ValueError(
"Couldn't find trait values for the following animal " +
"ids: %s\n\t" + ", ".join(missing_animal_trait_list))
# if animal density is supplied, align inputs to match its resolution
# otherwise, match resolution of precipitation rasters
if args['animal_density']:
target_pixel_size = pygeoprocessing.get_raster_info(
args['animal_density'])['pixel_size']
base_align_raster_path_id_map['animal_density'] = args[
'animal_density']
else:
target_pixel_size = pygeoprocessing.get_raster_info(
base_align_raster_path_id_map['precip_0'])['pixel_size']
LOGGER.info(
"pixel size of aligned inputs: %s", target_pixel_size)
# temporary directory for intermediate files
global PROCESSING_DIR
PROCESSING_DIR = os.path.join(args['workspace_dir'], "temporary_files")
if not os.path.exists(PROCESSING_DIR):
os.makedirs(PROCESSING_DIR)
# set up a dictionary that uses the same keys as
# 'base_align_raster_path_id_map' to point to the clipped/resampled
# rasters to be used in raster calculations for the model.
aligned_raster_dir = os.path.join(
args['workspace_dir'], 'aligned_inputs')
if os.path.exists(aligned_raster_dir):
shutil.rmtree(aligned_raster_dir)
os.makedirs(aligned_raster_dir)
aligned_inputs = dict([(key, os.path.join(
aligned_raster_dir, 'aligned_%s' % os.path.basename(path)))
for key, path in base_align_raster_path_id_map.items()])
# align all the base inputs to be the minimum known pixel size and to
# only extend over their combined intersections
source_input_path_list = [
base_align_raster_path_id_map[k] for k in sorted(
base_align_raster_path_id_map.keys())]
aligned_input_path_list = [
aligned_inputs[k] for k in sorted(aligned_inputs.keys())]
pygeoprocessing.align_and_resize_raster_stack(
source_input_path_list, aligned_input_path_list,
['near'] * len(source_input_path_list),
target_pixel_size, 'intersection',
base_vector_path_list=[args['aoi_path']],
vector_mask_options={'mask_vector_path': args['aoi_path']})
_check_pft_fractional_cover_sum(aligned_inputs, pft_id_set)
file_suffix = utils.make_suffix_string(args, 'results_suffix')
# create animal trait spatial index raster from management polygon
aligned_inputs['animal_index'] = os.path.join(
aligned_raster_dir, 'animal_spatial_index.tif')
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], aligned_inputs['animal_index'],
gdal.GDT_Int32, [_TARGET_NODATA], fill_value_list=[_TARGET_NODATA])
pygeoprocessing.rasterize(
args['animal_grazing_areas_path'], aligned_inputs['animal_index'],
option_list=["ATTRIBUTE=animal_id"])
# create uniform animal density raster, if not supplied as input
if not args['animal_density']:
aligned_inputs['animal_density'] = os.path.join(
aligned_raster_dir, 'animal_density.tif')
_animal_density(aligned_inputs, args['animal_grazing_areas_path'])
# Initialization
sv_dir = os.path.join(args['workspace_dir'], 'state_variables_m-1')
os.makedirs(sv_dir)
initial_conditions_dir = None
try:
initial_conditions_dir = args['initial_conditions_dir']
except KeyError:
pass
if initial_conditions_dir:
# check that a raster for each required state variable is supplied
missing_initial_values = []
# set _SV_NODATA from initial rasters
state_var_nodata = set([])
# align initial state variables to resampled inputs
resample_initial_path_map = {}
for sv in _SITE_STATE_VARIABLE_FILES:
sv_path = os.path.join(
initial_conditions_dir, _SITE_STATE_VARIABLE_FILES[sv])
state_var_nodata.update(
set([pygeoprocessing.get_raster_info(sv_path)['nodata'][0]]))
resample_initial_path_map[sv] = sv_path
if not os.path.exists(sv_path):
missing_initial_values.append(sv_path)
for pft_i in pft_id_set:
for sv in _PFT_STATE_VARIABLES:
sv_key = '{}_{}_path'.format(sv, pft_i)
sv_path = os.path.join(
initial_conditions_dir, '{}_{}.tif'.format(sv, pft_i))
state_var_nodata.update(
set([pygeoprocessing.get_raster_info(sv_path)['nodata']
[0]]))
resample_initial_path_map[sv_key] = sv_path
if not os.path.exists(sv_path):
missing_initial_values.append(sv_path)
if missing_initial_values:
raise ValueError(
"Couldn't find the following required initial values: " +
"\n\t".join(missing_initial_values))
if len(state_var_nodata) > 1:
raise ValueError(
"Initial state variable rasters contain >1 nodata value")
global _SV_NODATA
_SV_NODATA = list(state_var_nodata)[0]
# align initial values with inputs
initial_path_list = (
[aligned_inputs['precip_0']] +
[resample_initial_path_map[key] for key in sorted(
resample_initial_path_map.keys())])
aligned_initial_path_list = (
[os.path.join(PROCESSING_DIR, 'aligned_input_template.tif')] +
[os.path.join(
sv_dir, os.path.basename(resample_initial_path_map[key])) for
key in sorted(resample_initial_path_map.keys())])
pygeoprocessing.align_and_resize_raster_stack(
initial_path_list, aligned_initial_path_list,
['near'] * len(initial_path_list),
target_pixel_size, 'intersection',
base_vector_path_list=[args['aoi_path']], raster_align_index=0,
vector_mask_options={'mask_vector_path': args['aoi_path']})
sv_reg = dict(
[(key, os.path.join(sv_dir, os.path.basename(path)))
for key, path in resample_initial_path_map.items()])
else:
# create initialization rasters from tables
try:
site_initial_conditions_table = utils.build_lookup_from_csv(
args['site_initial_table'], 'site')
except KeyError:
raise ValueError(
"If initial conditions rasters are not supplied, initial " +
"conditions tables must be supplied")
missing_site_index_list = list(
site_index_set.difference(site_initial_conditions_table.keys()))
if missing_site_index_list:
raise ValueError(
"Couldn't find initial conditions values for the following " +
"site indices: %s\n\t" + ", ".join(missing_site_index_list))
try:
pft_initial_conditions_table = utils.build_lookup_from_csv(
args['pft_initial_table'], 'PFT')
except KeyError:
raise ValueError(
"If initial conditions rasters are not supplied, initial " +
"conditions tables must be supplied")
missing_pft_index_list = pft_id_set.difference(
pft_initial_conditions_table.keys())
if missing_pft_index_list:
raise ValueError(
"Couldn't find initial condition values for the following "
"plant functional types: %s\n\t" + ", ".join(
missing_pft_index_list))
sv_reg = initial_conditions_from_tables(
aligned_inputs, sv_dir, pft_id_set, site_initial_conditions_table,
pft_initial_conditions_table)
# calculate persistent intermediate parameters that do not change during
# the simulation
persist_param_dir = os.path.join(
args['workspace_dir'], 'intermediate_parameters')
utils.make_directories([persist_param_dir])
pp_reg = utils.build_file_registry(
[(_PERSISTENT_PARAMS_FILES, persist_param_dir)], file_suffix)
# calculate derived animal traits that do not change during the simulation
freer_parameter_df = pandas.DataFrame.from_dict(
_FREER_PARAM_DICT, orient='index')
freer_parameter_df['type'] = freer_parameter_df.index
animal_trait_table = calc_derived_animal_traits(
input_animal_trait_table, freer_parameter_df)
# calculate maximum potential intake of each animal type
for animal_id in animal_trait_table.keys():
revised_animal_trait_dict = calc_max_intake(
animal_trait_table[animal_id])
animal_trait_table[animal_id] = revised_animal_trait_dict
# calculate field capacity and wilting point
LOGGER.info("Calculating field capacity and wilting point")
_afiel_awilt(
aligned_inputs['site_index'], site_param_table,
sv_reg['som1c_2_path'], sv_reg['som2c_2_path'], sv_reg['som3c_path'],
aligned_inputs['sand'], aligned_inputs['silt'],
aligned_inputs['clay'], aligned_inputs['bulk_d_path'], pp_reg)
# calculate other persistent parameters
LOGGER.info("Calculating persistent parameters")
_persistent_params(
aligned_inputs['site_index'], site_param_table,
aligned_inputs['sand'], aligned_inputs['clay'], pp_reg)
# calculate required ratios for decomposition of structural material
LOGGER.info("Calculating required ratios for structural decomposition")
_structural_ratios(
aligned_inputs['site_index'], site_param_table, sv_reg, pp_reg)
# make yearly directory for values that are updated every twelve months
year_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
year_reg = dict(
[(key, os.path.join(year_dir, path)) for key, path in
_YEARLY_FILES.items()])
for pft_i in pft_id_set:
for file in _YEARLY_PFT_FILES:
year_reg['{}_{}'.format(file, pft_i)] = os.path.join(
year_dir, '{}_{}.tif'.format(file, pft_i))
# make monthly directory for monthly intermediate parameters that are
# shared between submodels, but do not need to be saved as output
month_temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
month_reg = {}
for pft_i in pft_id_set:
for val in _PFT_INTERMEDIATE_VALUES:
month_reg['{}_{}'.format(
val, pft_i)] = os.path.join(
month_temp_dir, '{}_{}.tif'.format(val, pft_i))
for val in _SITE_INTERMEDIATE_VALUES:
month_reg[val] = os.path.join(month_temp_dir, '{}.tif'.format(val))
output_dir = os.path.join(args['workspace_dir'], "output")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# provisional state variable registry contains provisional biomass in
# absence of grazing
provisional_sv_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
provisional_sv_reg = utils.build_file_registry(
[(_SITE_STATE_VARIABLE_FILES, provisional_sv_dir),
(pft_sv_dict, provisional_sv_dir)], file_suffix)
intermediate_sv_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
# Main simulation loop
# for each step in the simulation
for month_index in range(n_months):
if (month_index % 12) == 0:
# Update yearly quantities
_yearly_tasks(
aligned_inputs, site_param_table, veg_trait_table, month_index,
pft_id_set, year_reg)
current_month = (starting_month + month_index - 1) % 12 + 1
current_year = starting_year + (starting_month + month_index - 1) // 12
# track state variables from previous step
prev_sv_reg = sv_reg
for animal_id in animal_trait_table.keys():
if animal_trait_table[animal_id]['sex'] == 'breeding_female':
revised_animal_trait_dict = update_breeding_female_status(
animal_trait_table[animal_id], month_index)
animal_trait_table[animal_id] = revised_animal_trait_dict
revised_animal_trait_dict = calc_max_intake(
animal_trait_table[animal_id])
animal_trait_table[animal_id] = revised_animal_trait_dict
# enforce absence of grazing as zero biomass removed
for pft_i in pft_id_set:
pygeoprocessing.new_raster_from_base(
aligned_inputs['pft_{}'.format(pft_i)],
month_reg['flgrem_{}'.format(pft_i)], gdal.GDT_Float32,
[_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['pft_{}'.format(pft_i)],
month_reg['fdgrem_{}'.format(pft_i)], gdal.GDT_Float32,
[_TARGET_NODATA], fill_value_list=[0])
# populate provisional_sv_reg with provisional biomass in absence of
# grazing
_potential_production(
aligned_inputs, site_param_table, current_month, month_index,
pft_id_set, veg_trait_table, prev_sv_reg, pp_reg, month_reg)
_root_shoot_ratio(
aligned_inputs, site_param_table, current_month, pft_id_set,
veg_trait_table, prev_sv_reg, year_reg, month_reg)
_soil_water(
aligned_inputs, site_param_table, veg_trait_table, current_month,
month_index, prev_sv_reg, pp_reg, pft_id_set, month_reg,
provisional_sv_reg)
_decomposition(
aligned_inputs, current_month, month_index, pft_id_set,
site_param_table, year_reg, month_reg, prev_sv_reg, pp_reg,
provisional_sv_reg)
_death_and_partition(
'stded', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg,
provisional_sv_reg)
_death_and_partition(
'bgliv', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg,
provisional_sv_reg)
_shoot_senescence(
pft_id_set, veg_trait_table, prev_sv_reg, month_reg, current_month,
provisional_sv_reg)
intermediate_sv_reg = copy_intermediate_sv(
pft_id_set, provisional_sv_reg, intermediate_sv_dir)
delta_agliv_dict = _new_growth(
pft_id_set, aligned_inputs, site_param_table, veg_trait_table,
month_reg, current_month, provisional_sv_reg)
_apply_new_growth(delta_agliv_dict, pft_id_set, provisional_sv_reg)
# estimate grazing offtake by animals relative to provisional biomass
# at an intermediate step, after senescence but before new growth
_calc_grazing_offtake(
aligned_inputs, args['aoi_path'], args['management_threshold'],
intermediate_sv_reg, pft_id_set, aligned_inputs['animal_index'],
animal_trait_table, veg_trait_table, current_month, month_reg)
# estimate actual biomass production for this step, integrating impacts
# of grazing
sv_dir = os.path.join(
args['workspace_dir'], 'state_variables_m%d' % month_index)
utils.make_directories([sv_dir])
sv_reg = utils.build_file_registry(
[(_SITE_STATE_VARIABLE_FILES, sv_dir),
(pft_sv_dict, sv_dir)], file_suffix)
_potential_production(
aligned_inputs, site_param_table, current_month, month_index,
pft_id_set, veg_trait_table, prev_sv_reg, pp_reg, month_reg)
_root_shoot_ratio(
aligned_inputs, site_param_table, current_month, pft_id_set,
veg_trait_table, prev_sv_reg, year_reg, month_reg)
_soil_water(
aligned_inputs, site_param_table, veg_trait_table, current_month,
month_index, prev_sv_reg, pp_reg, pft_id_set, month_reg, sv_reg)
_decomposition(
aligned_inputs, current_month, month_index, pft_id_set,
site_param_table, year_reg, month_reg, prev_sv_reg, pp_reg, sv_reg)
_death_and_partition(
'stded', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg, sv_reg)
_death_and_partition(
'bgliv', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg, sv_reg)
_shoot_senescence(
pft_id_set, veg_trait_table, prev_sv_reg, month_reg, current_month,
sv_reg)
delta_agliv_dict = _new_growth(
pft_id_set, aligned_inputs, site_param_table, veg_trait_table,
month_reg, current_month, sv_reg)
_animal_diet_sufficiency(
sv_reg, pft_id_set, aligned_inputs, animal_trait_table,
veg_trait_table, current_month, month_reg)
_grazing(
aligned_inputs, site_param_table, month_reg, animal_trait_table,
pft_id_set, sv_reg)
_apply_new_growth(delta_agliv_dict, pft_id_set, sv_reg)
_leach(aligned_inputs, site_param_table, month_reg, sv_reg)
_write_monthly_outputs(
aligned_inputs, provisional_sv_reg, sv_reg, month_reg, pft_id_set,
current_year, current_month, output_dir, file_suffix)
# summary results
summary_output_dir = os.path.join(output_dir, 'summary_results')
os.makedirs(summary_output_dir)
summary_shp_path = os.path.join(
summary_output_dir,
'grazing_areas_results_rpm{}.shp'.format(file_suffix))
create_vector_copy(
args['animal_grazing_areas_path'], summary_shp_path)
field_pickle_map, field_header_order_list = aggregate_and_pickle_results(
output_dir, summary_shp_path)
_add_fields_to_shapefile(
field_pickle_map, field_header_order_list, summary_shp_path)
# clean up
shutil.rmtree(persist_param_dir)
shutil.rmtree(PROCESSING_DIR)
if delete_sv_folders:
for month_index in range(-1, n_months):
shutil.rmtree(
os.path.join(
args['workspace_dir'],
'state_variables_m%d' % month_index))
def raster_multiplication(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_path_nodata):
"""Multiply raster1 by raster2.
Multiply raster1 by raster2 element-wise. In any pixel where raster1 or
raster2 is nodata, the result is nodata. The result is always of float
datatype.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_multiply_op(raster1, raster2):
"""Multiply two rasters."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_path_nodata
result[valid_mask] = raster1[valid_mask] * raster2[valid_mask]
return result
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_multiply_op, target_path, gdal.GDT_Float32,
target_path_nodata)
def raster_division(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_path_nodata):
"""Divide raster1 by raster2.
Divide raster1 by raster2 element-wise. In any pixel where raster1 or
raster2 is nodata, the result is nodata. The result is always of float
datatype.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_divide_op(raster1, raster2):
"""Divide raster1 by raster2."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
raster1 = raster1.astype(numpy.float32)
raster2 = raster2.astype(numpy.float32)
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_path_nodata
error_mask = ((raster1 != 0) & (raster2 == 0.) & valid_mask)
zero_mask = ((raster1 == 0.) & (raster2 == 0.) & valid_mask)
nonzero_mask = ((raster2 != 0.) & valid_mask)
result[error_mask] = target_path_nodata
result[zero_mask] = 0.
result[nonzero_mask] = raster1[nonzero_mask] / raster2[nonzero_mask]
return result
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_divide_op, target_path, gdal.GDT_Float32,
target_path_nodata)
def raster_list_sum(
raster_list, input_nodata, target_path, target_nodata,
nodata_remove=False):
"""Calculate the sum per pixel across rasters in a list.
Sum the rasters in `raster_list` element-wise, allowing nodata values
in the rasters to propagate to the result or treating nodata as zero. If
nodata is treated as zero, areas where all inputs are nodata will be nodata
in the output.
Parameters:
raster_list (list): list of paths to rasters to sum
input_nodata (float or int): nodata value in the input rasters
target_path (string): path to location to store the result
target_nodata (float or int): nodata value for the result raster
nodata_remove (bool): if true, treat nodata values in input
rasters as zero. If false, the sum in a pixel where any input
raster is nodata is nodata.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_sum_op(*raster_list):
"""Add the rasters in raster_list without removing nodata values."""
invalid_mask = numpy.any(
numpy.isclose(numpy.array(raster_list), input_nodata), axis=0)
for r in raster_list:
numpy.place(r, numpy.isclose(r, input_nodata), [0])
sum_of_rasters = numpy.sum(raster_list, axis=0)
sum_of_rasters[invalid_mask] = target_nodata
return sum_of_rasters
def raster_sum_op_nodata_remove(*raster_list):
"""Add the rasters in raster_list, treating nodata as zero."""
invalid_mask = numpy.all(
numpy.isclose(numpy.array(raster_list), input_nodata), axis=0)
for r in raster_list:
numpy.place(r, numpy.isclose(r, input_nodata), [0])
sum_of_rasters = numpy.sum(raster_list, axis=0)
sum_of_rasters[invalid_mask] = target_nodata
return sum_of_rasters
if nodata_remove:
pygeoprocessing.raster_calculator(
[(path, 1) for path in raster_list], raster_sum_op_nodata_remove,
target_path, gdal.GDT_Float32, target_nodata)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in raster_list], raster_sum_op,
target_path, gdal.GDT_Float32, target_nodata)
def raster_sum(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_nodata, nodata_remove=False):
"""Add raster 1 and raster2.
Add raster1 and raster2, allowing nodata values in the rasters to
propagate to the result or treating nodata as zero.
Parameters:
raster1 (string): path to one raster operand
raster1_nodata (float or int): nodata value in raster1
raster2 (string): path to second raster operand
raster2_nodata (float or int): nodata value in raster2
target_path (string): path to location to store the sum
target_nodata (float or int): nodata value for the result raster
nodata_remove (bool): if true, treat nodata values in input
rasters as zero. If false, the sum in a pixel where any
input raster is nodata is nodata.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_sum_op(raster1, raster2):
"""Add raster1 and raster2 without removing nodata values."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_nodata
result[valid_mask] = raster1[valid_mask] + raster2[valid_mask]
return result
def raster_sum_op_nodata_remove(raster1, raster2):
"""Add raster1 and raster2, treating nodata as zero."""
numpy.place(raster1, numpy.isclose(raster1, raster1_nodata), [0])
numpy.place(raster2, numpy.isclose(raster2, raster2_nodata), [0])
result = raster1 + raster2
return result
if nodata_remove:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_sum_op_nodata_remove, target_path, gdal.GDT_Float32,
target_nodata)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_sum_op, target_path, gdal.GDT_Float32,
target_nodata)
def raster_difference(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_nodata, nodata_remove=False):
"""Subtract raster2 from raster1.
Subtract raster2 from raster1 element-wise, allowing nodata values in the
rasters to propagate to the result or treating nodata as zero.
Parameters:
raster1 (string): path to raster from which to subtract raster2
raster1_nodata (float or int): nodata value in raster1
raster2 (string): path to raster which should be subtracted from
raster1
raster2_nodata (float or int): nodata value in raster2
target_path (string): path to location to store the difference
target_nodata (float or int): nodata value for the result raster
nodata_remove (bool): if true, treat nodata values in input
rasters as zero. If false, the difference in a pixel where any
input raster is nodata is nodata.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_difference_op(raster1, raster2):
"""Subtract raster2 from raster1 without removing nodata values."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_nodata
result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]
return result
def raster_difference_op_nodata_remove(raster1, raster2):
"""Subtract raster2 from raster1, treating nodata as zero."""
numpy.place(raster1, numpy.isclose(raster1, raster1_nodata), [0])
numpy.place(raster2, numpy.isclose(raster2, raster2_nodata), [0])
result = raster1 - raster2
return result
if nodata_remove:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_difference_op_nodata_remove, target_path, gdal.GDT_Float32,
target_nodata)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_difference_op, target_path, gdal.GDT_Float32,
target_nodata)
def reclassify_nodata(target_path, new_nodata_value):
"""Reclassify the nodata value of a raster to a new value.
Convert all areas of nodata in the target raster to the new nodata
value, which must be an integer.
Parameters:
target_path (string): path to target raster
new_nodata_value (integer): new value to set as nodata
Side effects:
modifies the raster indicated by `target_path`
Returns:
None
"""
def reclassify_op(target_raster):
reclassified_raster = numpy.copy(target_raster)
reclassify_mask = (target_raster == previous_nodata_value)
reclassified_raster[reclassify_mask] = new_nodata_value
return reclassified_raster
fd, temp_path = tempfile.mkstemp(dir=PROCESSING_DIR)
shutil.copyfile(target_path, temp_path)
previous_nodata_value = pygeoprocessing.get_raster_info(
target_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(temp_path, 1)], reclassify_op, target_path, gdal.GDT_Float32,
new_nodata_value)
# clean up
os.close(fd)
os.remove(temp_path)
def weighted_state_variable_sum(
sv, sv_reg, aligned_inputs, pft_id_set, weighted_sum_path):
"""Calculate weighted sum of state variable across plant functional types.
To sum a state variable across PFTs within a grid cell, the state variable
must be weighted by the fractional cover of each PFT inside the grid cell.
First multiply the state variable by its fractional cover, and then add up
the weighted products.
Parameters:
sv (string): state variable to be summed across plant functional types
sv_reg (dict): map of key, path pairs giving paths to state variables,
including sv, the state variable to be summed
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fractional cover of each plant
functional type
pft_id_set (set): set of integers identifying plant functional types
weighted_sum_path (string): path to raster that should contain the
weighted sum across PFTs
Side effects:
modifies or creates the raster indicated by `weighted_sum_path`
Returns:
None
"""
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for pft_i in pft_id_set:
val = '{}_weighted'.format(sv)
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
weighted_path_list = []
for pft_i in pft_id_set:
target_path = temp_val_dict['{}_weighted_{}'.format(sv, pft_i)]
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
raster_multiplication(
sv_reg['{}_{}_path'.format(sv, pft_i)], _SV_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
target_path, _TARGET_NODATA)
weighted_path_list.append(target_path)
raster_list_sum(
weighted_path_list, _TARGET_NODATA, weighted_sum_path, _TARGET_NODATA,
nodata_remove=True)
# clean up temporary files
shutil.rmtree(temp_dir)
def _check_pft_fractional_cover_sum(aligned_inputs, pft_id_set):
"""Check the sum of fractional cover across plant functional types.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fractional cover of each plant
functional type
pft_id_set (set): set of integers identifying plant functional types
Raises:
ValueError if the pixel-wise sum of fractional cover values across
plant functional types exceeds 1
Returns:
None
"""
with tempfile.NamedTemporaryFile(
prefix='cover_sum', dir=PROCESSING_DIR) as cover_sum_temp_file:
cover_sum_path = cover_sum_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
# initialize sum to zero
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], cover_sum_path, gdal.GDT_Float32,
[_TARGET_NODATA], fill_value_list=[0])
for pft_i in pft_id_set:
shutil.copyfile(cover_sum_path, operand_temp_path)
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
raster_sum(
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
operand_temp_path, _TARGET_NODATA,
cover_sum_path, _TARGET_NODATA)
# get maximum sum of fractional cover
max_cover = 0.
for offset_map, raster_block in pygeoprocessing.iterblocks(
(cover_sum_path, 1)):
valid_mask = (raster_block != _TARGET_NODATA)
if raster_block[valid_mask].size > 0:
max_cover = max(max_cover, numpy.amax(raster_block[valid_mask]))
if max_cover > 1:
raise ValueError(
"Fractional cover across plant functional types exceeds 1")
# clean up
os.remove(cover_sum_path)
def initial_conditions_from_tables(
aligned_inputs, sv_dir, pft_id_set, site_initial_conditions_table,
pft_initial_conditions_table):
"""Generate initial state variable registry from initial conditions tables.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including site spatial index raster and
fractional cover of each plant functional type
sv_dir (string): path to directory where initial state variable rasters
should be stored
pft_id_set (set): set of integers identifying plant functional types
site_initial_conditions_table (dict): map of site spatial index to
dictionaries that contain initial values for site-level state
variables
pft_initial_conditions_table (dict): map of plant functional type index
to dictionaries that contain initial values for plant functional
type-level state variables
Returns:
initial_sv_reg, map of key, path pairs giving paths to initial state
variable rasters
"""
def full_masked(pft_cover, fill_val):
"""Create a constant raster masked by pft fractional cover.
Parameters:
pft_cover (numpy.ndarray): input, fractional cover of the plant
functional type
fill_val (float): constant value with which to fill raster in areas
where fractional cover > 0
Returns:
full_masked, a raster containing `fill_val` in areas where
`pft_cover` > 0
"""
valid_mask = (
(~numpy.isclose(pft_cover, _SV_NODATA)) &
(pft_cover > 0))
full_masked = numpy.empty(pft_cover.shape, dtype=numpy.float32)
full_masked[:] = _SV_NODATA
full_masked[valid_mask] = fill_val
return full_masked
initial_sv_reg = {}
# site-level state variables
# check for missing state variable values
required_site_state_var = set(
[sv_key[:-5] for sv_key in _SITE_STATE_VARIABLE_FILES.keys()])
for site_code in site_initial_conditions_table.keys():
missing_site_state_var = required_site_state_var.difference(
site_initial_conditions_table[site_code].keys())
if missing_site_state_var:
raise ValueError(
"The following state variables were not found in the site " +
"initial conditions table: \n\t" + "\n\t".join(
missing_site_state_var))
for sv_key, basename in _SITE_STATE_VARIABLE_FILES.items():
state_var = sv_key[:-5]
site_to_val = dict(
[(site_code, float(table[state_var])) for (
site_code, table) in
site_initial_conditions_table.items()])
target_path = os.path.join(sv_dir, basename)
initial_sv_reg[sv_key] = target_path
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _SV_NODATA)
# PFT-level state variables
for pft_i in pft_id_set:
# check for missing values
missing_pft_state_var = set(_PFT_STATE_VARIABLES).difference(
pft_initial_conditions_table[pft_i].keys())
if missing_pft_state_var:
raise ValueError(
"The following state variables were not found in the plant " +
"functional type initial conditions table: \n\t" + "\n\t".join(
missing_pft_state_var))
for state_var in _PFT_STATE_VARIABLES:
fill_val = pft_initial_conditions_table[pft_i][state_var]
pft_cover_path = aligned_inputs['pft_{}'.format(pft_i)]
target_path = os.path.join(
sv_dir, '{}_{}.tif'.format(state_var, pft_i))
sv_key = '{}_{}_path'.format(state_var, pft_i)
initial_sv_reg[sv_key] = target_path
pygeoprocessing.raster_calculator(
[(pft_cover_path, 1), (fill_val, 'raw')],
full_masked, target_path, gdal.GDT_Float32, _SV_NODATA)
return initial_sv_reg
def _calc_ompc(
som1c_2_path, som2c_2_path, som3c_path, bulkd_path, edepth_path,
ompc_path):
"""Estimate total soil organic matter.
Total soil organic matter is the sum of soil carbon across
slow, active, and passive compartments, weighted by bulk
density and total modeled soil depth. Lines 220-222, Prelim.f
Parameters:
som1c_2_path (string): path to active organic soil carbon raster
som2c_2_path (string): path to slow organic soil carbon raster
som3c_path (string): path to passive organic soil carbon raster
bulkd_path (string): path to bulk density of soil raster
edepth (string): path to depth of soil raster
ompc_path (string): path to result, total soil organic matter
Side effects:
modifies or creates the raster indicated by `ompc_path`
Returns:
None
"""
def ompc_op(som1c_2, som2c_2, som3c, bulkd, edepth):
"""Estimate total soil organic matter.
Total soil organic matter is the sum of soil carbon across
slow, active, and passive compartments, weighted by bulk
density and total modeled soil depth. Lines 220-222, Prelim.f
Parameters:
som1c_2_path (string): state variable, active organic soil carbon
som2c_2_path (string): state variable, slow organic soil carbon
som3c_path (string): state variable, passive organic soil carbon
bulkd_path (string): input, bulk density of soil
edepth_path (string): parameter, depth of soil for this
calculation
Returns:
ompc, total soil organic matter weighted by bulk
density.
"""
ompc = numpy.empty(som1c_2.shape, dtype=numpy.float32)
ompc[:] = _TARGET_NODATA
valid_mask = (
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som2c_2, _SV_NODATA)) &
(~numpy.isclose(som3c, _SV_NODATA)) &
(~numpy.isclose(bulkd, bulkd_nodata)) &
(edepth != _IC_NODATA))
ompc[valid_mask] = (
(som1c_2[valid_mask] + som2c_2[valid_mask] +
som3c[valid_mask]) * 1.724 /
(10000. * bulkd[valid_mask] * edepth[valid_mask]))
return ompc
bulkd_nodata = pygeoprocessing.get_raster_info(bulkd_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
som1c_2_path, som2c_2_path, som3c_path,
bulkd_path, edepth_path]],
ompc_op, ompc_path, gdal.GDT_Float32, _TARGET_NODATA)
def _calc_afiel(
sand_path, silt_path, clay_path, ompc_path, bulkd_path, afiel_path):
"""Calculate field capacity for one soil layer.
Parameters:
sand_path (string): path to proportion sand in soil raster
silt_path (string): path to proportion silt in soil raster
clay_path (string): path to proportion clay in soil raster
ompc_path (string): path to estimated total soil organic matter raster
bulkd_path (string): path to bulk density of soil raster
afiel_path (string): path to result raster, field capacity for this
soil layer
Side effects:
creates the raster indicated by `afiel_path`
Returns:
None
"""
def afiel_op(sand, silt, clay, ompc, bulkd):
"""Calculate field capacity for one soil layer.
Field capacity, maximum soil moisture retention capacity,
from <NAME> Larson 1979, 'Estimating soil and water
retention characteristics from particle size distribution,
organic matter percent and bulk density'. Water Resources
Research 15:1633.
Parameters:
sand_path (string): input, proportion sand in soil
silt_path (string): input, proportion silt in soil
clay_path (string): input, proportion clay in soil
ompc_path (string): derived, estimated total soil organic matter
bulkd_path (string): input, bulk density of soil
Returns:
afiel, field capacity for this soil layer
"""
afiel = numpy.empty(sand.shape, dtype=numpy.float32)
afiel[:] = _TARGET_NODATA
valid_mask = (
(~numpy.isclose(sand, sand_nodata)) &
(~numpy.isclose(silt, silt_nodata)) &
(~numpy.isclose(clay, clay_nodata)) &
(ompc != _TARGET_NODATA) &
(~numpy.isclose(bulkd, bulkd_nodata)))
afiel[valid_mask] = (
0.3075 * sand[valid_mask] + 0.5886 * silt[valid_mask] +
0.8039 * clay[valid_mask] + 2.208E-03 * ompc[valid_mask] +
-0.1434 * bulkd[valid_mask])
return afiel
sand_nodata = pygeoprocessing.get_raster_info(sand_path)['nodata'][0]
silt_nodata = pygeoprocessing.get_raster_info(silt_path)['nodata'][0]
clay_nodata = pygeoprocessing.get_raster_info(clay_path)['nodata'][0]
bulkd_nodata = pygeoprocessing.get_raster_info(bulkd_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sand_path, silt_path, clay_path, ompc_path, bulkd_path]],
afiel_op, afiel_path, gdal.GDT_Float32, _TARGET_NODATA)
def _calc_awilt(
sand_path, silt_path, clay_path, ompc_path, bulkd_path, awilt_path):
"""Calculate wilting point for one soil layer.
Wilting point, minimum soil water required by plants before
wilting, from Gupta and Larson 1979, 'Estimating soil and
water retention characteristics from particle size distribution,
organic matter percent and bulk density'. Water Resources
Research 15:1633.
Parameters:
sand_path (string): path to proportion sand in soil raster
silt_path (string): path to proportion silt in soil raster
clay_path (string): path to proportion clay in soil raster
ompc_path (string): path to estimated total soil organic matter raster
bulkd_path (string): path to bulk density of soil raster
awilt_path (string): path to result raster, wilting point for this
soil layer
Side effects:
creates the raster indicated by `awilt_path`
Returns:
None
"""
def awilt_op(sand, silt, clay, ompc, bulkd):
"""Calculate wilting point for one soil layer.
Wilting point, minimum soil water required by plants before
wilting, from Gupta and Larson 1979, 'Estimating soil and
water retention characteristics from particle size distribution,
organic matter percent and bulk density'. Water Resources
Research 15:1633.
Parameters:
sand_path (string): input, proportion sand in soil
silt_path (string): input, proportion silt in soil
clay_path (string): input, proportion clay in soil
ompc_path (string): derived, estimated total soil organic matter
bulkd_path (string): input, bulk density of soil
Returns:
awilt, wilting point for this soil layer
"""
awilt = numpy.empty(sand.shape, dtype=numpy.float32)
awilt[:] = _TARGET_NODATA
valid_mask = (
(~numpy.isclose(sand, sand_nodata)) &
(~numpy.isclose(silt, silt_nodata)) &
(~numpy.isclose(clay, clay_nodata)) &
(ompc != _TARGET_NODATA) &
(~numpy.isclose(bulkd, bulkd_nodata)))
awilt[valid_mask] = (
-0.0059 * sand[valid_mask] + 0.1142 * silt[valid_mask] +
0.5766 * clay[valid_mask] + 2.228E-03 * ompc[valid_mask] +
0.02671 * bulkd[valid_mask])
return awilt
sand_nodata = pygeoprocessing.get_raster_info(sand_path)['nodata'][0]
silt_nodata = pygeoprocessing.get_raster_info(silt_path)['nodata'][0]
clay_nodata = pygeoprocessing.get_raster_info(clay_path)['nodata'][0]
bulkd_nodata = pygeoprocessing.get_raster_info(bulkd_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sand_path, silt_path, clay_path, ompc_path, bulkd_path]],
awilt_op, awilt_path, gdal.GDT_Float32, _TARGET_NODATA)
def _afiel_awilt(
site_index_path, site_param_table, som1c_2_path, som2c_2_path,
som3c_path, sand_path, silt_path, clay_path, bulk_d_path, pp_reg):
"""Calculate field capacity and wilting point for each soil layer.
Computations based on Gupta and Larson 1979, 'Estimating soil and water
retention characteristics from particle size distribution, organic
matter percent and bulk density'. Water Resources Research 15:1633.
Field capacity is calculated for -0.33 bar; wilting point is
calculated for water content at -15 bars.
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters including 'edepth' field
som1c_2_path (string): path to the state variable 'som1c_2',
active organic soil carbon
som2c_2_path (string): path to the state variable 'som2c_2',
slow organic soil carbon
som3c_path (string): path to the state variable 'som3c',
passive organic soil carbon
sand_path (string): path to raster containing proportion sand in soil
silt_path (string): path to raster containing proportion silt in soil
clay_path (string): path to raster containing proportion clay in soil
bulk_d_path (string): path to raster containing bulk density of soil
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation
Modifies the rasters pp_reg['afiel_<layer>'] and pp_reg['awilt_<layer>']
for all soil layers.
Returns:
None
"""
def decrement_ompc(ompc_orig_path, ompc_dec_path):
"""Decrease estimated organic matter to 85% of its value.
In each subsequent soil layer, estimated organic matter is decreased
by 15%, to 85% of its previous value.
Parameters:
ompc_orig_path (string): path to estimated soil organic matter
raster
ompc_dec_path (string): path to result raster, estimated soil
organic matter decreased to 85% of its previous value
Side effects:
modifies or creates the raster indicated by `ompc_dec_path`
Returns:
None
"""
def decrement_op(ompc_orig):
"""Reduce organic matter to 85% of its previous value."""
ompc_dec = numpy.empty(ompc_orig.shape, dtype=numpy.float32)
ompc_dec[:] = _TARGET_NODATA
valid_mask = (ompc_orig != _TARGET_NODATA)
ompc_dec[valid_mask] = ompc_orig[valid_mask] * 0.85
return ompc_dec
pygeoprocessing.raster_calculator(
[(ompc_orig_path, 1)], decrement_op, ompc_dec_path,
gdal.GDT_Float32, _TARGET_NODATA)
# temporary intermediate rasters for calculating field capacity and
# wilting point
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
edepth_path = os.path.join(temp_dir, 'edepth.tif')
ompc_path = os.path.join(temp_dir, 'ompc.tif')
site_to_edepth = dict(
[(site_code, float(table['edepth'])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_edepth, edepth_path, gdal.GDT_Float32,
_IC_NODATA)
# estimate total soil organic matter
_calc_ompc(
som1c_2_path, som2c_2_path, som3c_path, bulk_d_path, edepth_path,
ompc_path)
# calculate field capacity and wilting point for each soil layer,
# decreasing organic matter content by 85% with each layer
for lyr in range(1, 10):
afiel_path = pp_reg['afiel_{}_path'.format(lyr)]
awilt_path = pp_reg['awilt_{}_path'.format(lyr)]
_calc_afiel(
sand_path, silt_path, clay_path, ompc_path, bulk_d_path,
afiel_path)
_calc_awilt(
sand_path, silt_path, clay_path, ompc_path, bulk_d_path,
awilt_path)
ompc_dec_path = os.path.join(temp_dir, 'ompc{}.tif'.format(lyr))
decrement_ompc(ompc_path, ompc_dec_path)
ompc_path = ompc_dec_path
# clean up temporary files
shutil.rmtree(temp_dir)
def _persistent_params(
site_index_path, site_param_table, sand_path, clay_path, pp_reg):
"""Calculate persistent parameters.
The calculated values do not change over the course of the simulation.
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
sand_path (string): path to raster containing proportion sand in soil
clay_path (string): path to raster containing proportion clay in soil
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation.
Modifies the persistent parameter rasters indexed by the following
keys:
pp_reg['wc_path']
pp_reg['eftext_path']
pp_reg['p1co2_2_path']
pp_reg['fps1s3_path']
pp_reg['fps2s3_path']
pp_reg['orglch_path']
pp_reg['vlossg_path']
Returns:
None
"""
sand_nodata = pygeoprocessing.get_raster_info(sand_path)['nodata'][0]
clay_nodata = pygeoprocessing.get_raster_info(clay_path)['nodata'][0]
# temporary intermediate rasters for persistent parameters calculation
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for val in[
'peftxa', 'peftxb', 'p1co2a_2', 'p1co2b_2', 'ps1s3_1',
'ps1s3_2', 'ps2s3_1', 'ps2s3_2', 'omlech_1', 'omlech_2', 'vlossg']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for (
site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path, gdal.GDT_Float32,
_IC_NODATA)
def calc_wc(afiel_1, awilt_1):
"""Calculate water content of soil layer 1."""
return afiel_1 - awilt_1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
pp_reg['afiel_1_path'], pp_reg['awilt_1_path']]],
calc_wc, pp_reg['wc_path'], gdal.GDT_Float32, _TARGET_NODATA)
def calc_eftext(peftxa, peftxb, sand):
"""Calculate effect of soil texture on microbial decomposition.
Use an empirical regression to estimate the effect of soil
sand content on the microbe decomposition rate. Line 359 Prelim.f
Parameters:
peftxa (numpy.ndarray): parameter, regression intercept
peftxb (numpy.ndarray): parameter, regression slope
sand (numpy.ndarray): input, proportion sand in soil
Returns:
eftext, coefficient that modifies microbe decomposition rate.
"""
eftext = numpy.empty(sand.shape, dtype=numpy.float32)
eftext[:] = _IC_NODATA
valid_mask = (
(peftxa != _IC_NODATA) &
(peftxb != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)))
eftext[valid_mask] = (
peftxa[valid_mask] + (peftxb[valid_mask] * sand[valid_mask]))
return eftext
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['peftxa'], param_val_dict['peftxb'], sand_path]],
calc_eftext, pp_reg['eftext_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_p1co2_2(p1co2a_2, p1co2b_2, sand):
"""Calculate the fraction of carbon lost to CO2 from som1c_2.
During decomposition from active organic soil carbon, a fraction
of decomposing material is lost to CO2 as the soil respires.
Line 366 Prelim.f
Parameters:
p1co2a_2 (numpy.ndarray): parameter, intercept of regression
predicting loss to CO2 from active organic soil carbon
p1co2b_2 (numpy.ndarray): parameter, slope of regression
predicting loss to CO2 from active organic soil carbon
sand (numpy.ndarray): input, proportion sand in soil
Returns:
p1co2_2, fraction of carbon that flows to CO2 from active
organic soil carbon
"""
p1co2_2 = numpy.empty(sand.shape, dtype=numpy.float32)
p1co2_2[:] = _IC_NODATA
valid_mask = (
(p1co2a_2 != _IC_NODATA) &
(p1co2b_2 != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)))
p1co2_2[valid_mask] = (
p1co2a_2[valid_mask] + (p1co2b_2[valid_mask] * sand[valid_mask]))
return p1co2_2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['p1co2a_2'],
param_val_dict['p1co2b_2'], sand_path]],
calc_p1co2_2, pp_reg['p1co2_2_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_fps1s3(ps1s3_1, ps1s3_2, clay):
"""Calculate effect of clay content on decomposition from som1c_2.
Use an empirical regression to estimate the effect of clay content
of soil on flow from soil organic matter with fast turnover to
soil organic matter with slow turnover. Line 370 Prelim.f
Parameters:
ps1s3_1 (numpy.ndarray): parameter, regression intercept
ps1s3_2 (numpy.ndarray): parameter, regression slope
clay (numpy.ndarray): input, proportion clay in soil
Returns:
fps1s3, coefficient that modifies rate of decomposition
from som1c_2
"""
fps1s3 = numpy.empty(clay.shape, dtype=numpy.float32)
fps1s3[:] = _IC_NODATA
valid_mask = (
(ps1s3_1 != _IC_NODATA) &
(ps1s3_2 != _IC_NODATA) &
(~numpy.isclose(clay, clay_nodata)))
fps1s3[valid_mask] = (
ps1s3_1[valid_mask] + (ps1s3_2[valid_mask] * clay[valid_mask]))
return fps1s3
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['ps1s3_1'], param_val_dict['ps1s3_2'], clay_path]],
calc_fps1s3, pp_reg['fps1s3_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_fps2s3(ps2s3_1, ps2s3_2, clay):
"""Calculate effect of clay content on decomposition from som2c_2.
Use an empirical regression to estimate the effect of clay content
of soil on flow from slow soil organic carbon to soil passive organic
carbon. Line 371 Prelim.f
Parameters:
ps2s3_1 (numpy.ndarray): parameter, regression intercept
ps2s3_2 (numpy.ndarray): parameter, regression slope
clay (numpy.ndarray): input, proportion clay in soil
Returns:
fps2s3, coefficient that modifies rate of decomposition from
som2c_2 to som3c
"""
fps2s3 = numpy.empty(clay.shape, dtype=numpy.float32)
fps2s3[:] = _IC_NODATA
valid_mask = (
(ps2s3_1 != _IC_NODATA) &
(ps2s3_2 != _IC_NODATA) &
(~numpy.isclose(clay, clay_nodata)))
fps2s3[valid_mask] = (
ps2s3_1[valid_mask] + (ps2s3_2[valid_mask] * clay[valid_mask]))
return fps2s3
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['ps2s3_1'], param_val_dict['ps2s3_2'], clay_path]],
calc_fps2s3, pp_reg['fps2s3_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_orglch(omlech_1, omlech_2, sand):
"""Calculate the effect of sand content on leaching from soil.
Use an empirical regression to estimate the effect of sand content
of soil on rate of organic leaching from soil when there is drainage
of soil water from soil layer 1 to soil layer 2. Line 110 Predec.f
Parameters:
omlech_1 (numpy.ndarray): parameter, regression intercept
omlech_2 (numpy.ndarray): parameter, regression slope
sand (numpy.ndarray): input, proportion sand in soil
Returns:
orglch, the fraction of organic compounds leaching from soil
with drainage from soil layer 1 to layer 2
"""
orglch = numpy.empty(sand.shape, dtype=numpy.float32)
orglch[:] = _IC_NODATA
valid_mask = (
(omlech_1 != _IC_NODATA) &
(omlech_2 != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)))
orglch[valid_mask] = (
omlech_1[valid_mask] + (omlech_2[valid_mask] * sand[valid_mask]))
return orglch
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['omlech_1'], param_val_dict['omlech_2'],
sand_path]],
calc_orglch, pp_reg['orglch_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_vlossg(vlossg_param, clay):
"""Calculate proportion of gross mineralized N that is volatized.
During decomposition, some N is lost to volatilization. This is a
function of the gross mineralized N and is calculated according to this
multiplier, which varies with soil clay content.
Parameters:
vlossg (numpy.ndarray): parameter, volatilization loss multiplier
clay (numpy.ndarray): input, proportion clay in soil
Returns:
vlossg, proportion of gross mineralized N that is volatized
"""
valid_mask = (
(vlossg_param != _IC_NODATA) &
(~numpy.isclose(clay, clay_nodata)))
vlossg = numpy.empty(vlossg_param.shape, dtype=numpy.float32)
vlossg[:] = _IC_NODATA
max_mask = ((clay > 0.3) & valid_mask)
min_mask = ((clay < 0.1) & valid_mask)
vlossg[valid_mask] = -0.1 * (clay[valid_mask] - 0.3) + 0.01
vlossg[max_mask] = 0.01
vlossg[min_mask] = 0.03
vlossg[valid_mask] = vlossg[valid_mask] * vlossg_param[valid_mask]
return vlossg
pygeoprocessing.raster_calculator(
[(path, 1) for path in [param_val_dict['vlossg'], clay_path]],
calc_vlossg, pp_reg['vlossg_path'], gdal.GDT_Float32, _IC_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _aboveground_ratio(anps, tca, pcemic_1, pcemic_2, pcemic_3):
"""Calculate C/<iel> ratios of decomposing aboveground material.
This ratio is used to test whether there is sufficient <iel> (N or P)
in aboveground material for the material to decompose. Agdrat.f
Parameters:
anps (numpy.ndarray): state variable, N or P in the donor material
tca (numpy.ndarray): state variable, total C in the donor material
pcemic_1 (numpy.ndarray): parameter, maximum C/<iel> of new material
pcemic_2 (numpy.ndarray): parameter, minimum C/<iel> of new material
pcemic_3 (numpy.ndarray): parameter, minimum <iel> content of
decomposing material that gives minimum C/<iel> of new material
Returns:
agdrat, the C/<iel> ratio of new material
"""
valid_mask = (
(~numpy.isclose(anps, _SV_NODATA)) &
(~numpy.isclose(tca, _SV_NODATA)) &
(pcemic_1 != _IC_NODATA) &
(pcemic_2 != _IC_NODATA) &
(pcemic_3 != _IC_NODATA))
cemicb = numpy.empty(anps.shape, dtype=numpy.float32)
cemicb[:] = _IC_NODATA
cemicb[valid_mask] = (
(pcemic_2[valid_mask] - pcemic_1[valid_mask]) /
pcemic_3[valid_mask])
econt = numpy.empty(anps.shape, dtype=numpy.float32)
econt[:] = _TARGET_NODATA
econt[valid_mask] = 0
decompose_mask = ((tca > 0.) & valid_mask)
econt[decompose_mask] = anps[decompose_mask] / (tca[decompose_mask] * 2.5)
agdrat = numpy.empty(anps.shape, dtype=numpy.float32)
agdrat[:] = _TARGET_NODATA
agdrat[valid_mask] = pcemic_2[valid_mask]
compute_mask = ((econt <= pcemic_3) & valid_mask)
agdrat[compute_mask] = (
pcemic_1[compute_mask] + econt[compute_mask] * cemicb[compute_mask])
return agdrat
def _belowground_ratio(aminrl, varat_1_iel, varat_2_iel, varat_3_iel):
"""Calculate C/<iel> ratios of decomposing belowground material.
This ratio is used to test whether there is sufficient <iel> (N or P)
in soil metabolic material to decompose. Bgdrat.f
Parameters:
aminrl (numpy.ndarray): derived, average surface mineral <iel>
varat_1_iel (numpy.ndarray): parameter, maximum C/<iel> ratio for
newly decomposed material
varat_2_iel (numpy.ndarray): parameter, minimum C/<iel> ratio
varat_3_iel (numpy.ndarray): parameter, amount of <iel> present
when minimum ratio applies
Returns:
bgdrat, the C/<iel> ratio of new material
"""
valid_mask = (
(~numpy.isclose(aminrl, _SV_NODATA)) &
(varat_1_iel != _IC_NODATA) &
(varat_2_iel != _IC_NODATA) &
(varat_3_iel != _IC_NODATA))
bgdrat = numpy.empty(aminrl.shape, dtype=numpy.float32)
bgdrat[:] = _TARGET_NODATA
bgdrat[valid_mask] = (
(1. - aminrl[valid_mask] / varat_3_iel[valid_mask]) *
(varat_1_iel[valid_mask] - varat_2_iel[valid_mask]) +
varat_2_iel[valid_mask])
max_mask = ((aminrl <= 0) & valid_mask)
bgdrat[max_mask] = varat_1_iel[max_mask]
min_mask = ((aminrl > varat_3_iel) & valid_mask)
bgdrat[min_mask] = varat_2_iel[min_mask]
return bgdrat
def _structural_ratios(site_index_path, site_param_table, sv_reg, pp_reg):
"""Calculate maximum C/N and C/P ratios for structural material.
These ratios limit decomposition of structural material (i.e., material
containing lignin). Lines 31-77 Predec.f
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation.
Modifies the persistent parameter rasters indexed by the following
keys:
pp_reg['rnewas_1_1_path']
pp_reg['rnewas_1_2_path']
pp_reg['rnewas_2_1_path']
pp_reg['rnewas_2_2_path']
pp_reg['rnewbs_1_1_path']
pp_reg['rnewbs_1_2_path']
pp_reg['rnewbs_2_1_path']
pp_reg['rnewbs_2_2_path']
Returns:
None
"""
# temporary parameter rasters for structural ratios calculations
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for iel in [1, 2]:
for val in[
'pcemic1_2', 'pcemic1_1', 'pcemic1_3', 'pcemic2_2',
'pcemic2_1', 'pcemic2_3', 'rad1p_1', 'rad1p_2',
'rad1p_3', 'varat1_1', 'varat22_1']:
target_path = os.path.join(temp_dir, '{}_{}.tif'.format(val, iel))
param_val_dict['{}_{}'.format(val, iel)] = target_path
site_to_val = dict(
[(site_code, float(table['{}_{}'.format(val, iel)])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
def calc_rnewas_som2(
pcemic2_2, pcemic2_1, pcemic2_3, struce_1, strucc_1, rad1p_1,
rad1p_2, rad1p_3, pcemic1_2, rnewas1):
"""Calculate C/<iel> ratio for decomposition into som2.
This ratio is calculated separately for each nutrient (i.e., N, P).
When material decomposes into the surface slow organic pool, the
C/<iel> ratio of decomposing material must be smaller than or equal to
this ratio. A portion of the ratio of material entering som1, the
surface active pool, is also added to som2 and calculated here.
Parameters:
pcemic2_2 (numpy.ndarray): parameter, minimum C/<iel> ratio for
surface slow organic pool
pcemic2_1 (numpy.ndarray): parameter, maximum C/<iel> ratio for
surface slow organic pool
pcemic2_3 (numpy.ndarray): parameter, mimimum <iel> content of
decomposing aboveground material, above which the C/<iel>
ratio of the surface slow organic pool equals pcemic1_2
struce_1 (numpy.ndarray): state variable, <iel> in surface
structural material
strucc_1 (numpy.ndarray): state variable, C in surface
structural material
rad1p_1 (numpy.ndarray): parameter, intercept of regression used
to calculate addition of <iel> from surface active pool
rad1p_2 (numpy.ndarray): parameter, slope of regression used
to calculate addition of <iel> from surface active pool
rad1p_3 (numpy.ndarray): parameter, minimum allowable C/<iel>
used to calculate addition term for C/<iel> ratio of som2
formed from surface active pool
pcemic1_2 (numpy.ndarray): parameter, minimum C/<iel> ratio for
surface active organic pool
rnewas1 (numpy.ndarray): derived, C/<iel> ratio for decomposition
into som1
Returns:
rnewas2, required ratio for decomposition of structural material
into som2 for one nutrient
"""
valid_mask = (
(pcemic2_2 != _IC_NODATA) &
(pcemic2_1 != _IC_NODATA) &
(pcemic2_3 != _IC_NODATA) &
(~numpy.isclose(struce_1, _SV_NODATA)) &
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(rad1p_1 != _IC_NODATA) &
(rad1p_2 != _IC_NODATA) &
(rad1p_3 != _IC_NODATA) &
(pcemic1_2 != _IC_NODATA) &
(rnewas1 != _TARGET_NODATA))
rnewas2 = _aboveground_ratio(
struce_1, strucc_1, pcemic2_1, pcemic2_2, pcemic2_3)
radds1 = numpy.empty(strucc_1.shape, dtype=numpy.float32)
radds1[:] = _TARGET_NODATA
radds1[valid_mask] = (
rad1p_1[valid_mask] + rad1p_2[valid_mask] *
(rnewas1[valid_mask] - pcemic1_2[valid_mask]))
rnewas2[valid_mask] = rnewas1[valid_mask] + radds1[valid_mask]
rnewas2[valid_mask] = numpy.maximum(
rnewas2[valid_mask], rad1p_3[valid_mask])
return rnewas2
for iel in [1, 2]:
# calculate rnewas_iel_1 - aboveground material to SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['struce_1_{}_path'.format(iel)],
sv_reg['strucc_1_path'],
param_val_dict['pcemic1_1_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)],
param_val_dict['pcemic1_3_{}'.format(iel)]]],
_aboveground_ratio, pp_reg['rnewas_{}_1_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate rnewas_iel_2 - aboveground material to SOM2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['pcemic2_2_{}'.format(iel)],
param_val_dict['pcemic2_1_{}'.format(iel)],
param_val_dict['pcemic2_3_{}'.format(iel)],
sv_reg['struce_1_{}_path'.format(iel)],
sv_reg['strucc_1_path'],
param_val_dict['rad1p_1_{}'.format(iel)],
param_val_dict['rad1p_2_{}'.format(iel)],
param_val_dict['rad1p_3_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)],
pp_reg['rnewas_{}_1_path'.format(iel)]]],
calc_rnewas_som2, pp_reg['rnewas_{}_2_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate rnewbs_iel_1 - belowground material to SOM1
site_to_varat1_1 = dict([
(site_code, float(table['varat1_1_{}'.format(iel)])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_varat1_1,
pp_reg['rnewbs_{}_1_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate rnewbs_iel_2 - belowground material to SOM2
# rnewbs(iel,2) = varat22(1,iel)
site_to_varat22_1 = dict([
(site_code, float(table['varat22_1_{}'.format(iel)])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_varat22_1,
pp_reg['rnewbs_{}_2_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _yearly_tasks(
aligned_inputs, site_param_table, veg_trait_table, month_index,
pft_id_set, year_reg):
"""Calculate quantities that remain static for 12 months.
These quantities are annual precipitation, annual atmospheric N
deposition, and the fraction of plant residue which is lignin for each pft.
Century also calculates non-symbiotic soil N fixation once yearly, but here
those were moved to monthly tasks. Century uses precipitation in the future
12 months (prcgrw) to predict root:shoot ratios, but here we instead use
the sum of monthly precipitation in 12 months including the current one, if
data for 12 future months are not available.
Lines 79-82, 164 Eachyr.f
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including monthly precipitation and site
spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
month_index (int): current monthly step, relative to 0 so that
month_index=0 at first monthly time step
pft_id_set (set): set of integers identifying plant functional types
year_reg (dict): map of key, path pairs giving paths to the annual
precipitation and N deposition rasters
Side effects:
modifies or creates the rasters indicated by:
year_reg['annual_precip_path']
year_reg['baseNdep_path']
year_reg['pltlig_above_<pft>'] for each pft
year_reg['pltlig_below_<pft>'] for each pft
Returns:
None
Raises:
ValueError if fewer than 12 monthly precipitation rasters can be found
"""
def calc_base_N_dep(epnfa_1, epnfa_2, prcann):
"""Calculate base annual atmospheric N deposition.
Parameters:
epnfa_1 (numpy.ndarray): parameter, intercept of regression
predicting atmospheric N deposition from precipitation
epnfa_2 (numpy.ndarray): parameter, slope of regression predicting
atmospheric N deposition from precipitation
prcann (numpy.ndarray): derived, annual precipitation
Returns:
baseNdep, annual atmospheric N deposition
"""
baseNdep = numpy.empty(prcann.shape, dtype=numpy.float32)
baseNdep[:] = 0.
valid_mask = (
(epnfa_1 != _IC_NODATA) &
(epnfa_2 != _IC_NODATA) &
(prcann != _TARGET_NODATA))
baseNdep[valid_mask] = (
epnfa_1[valid_mask] +
(epnfa_2[valid_mask] * numpy.minimum(prcann[valid_mask], 80.)))
baseNdep[baseNdep < 0] = 0.
return baseNdep
def calc_pltlig(fligni_1_lyr, fligni_2_lyr, prcann):
"""Calculate the fraction of residue that is lignin. Cmplig.f
This fraction is used to calculate the fraction of residue (i.e.,
incoming litter from fall of standing dead or incoming soil from death
of roots) that is partitioned to metabolic vs structural pools. It is
calculated once per year from annual precipitation and fixed
parameters.
Parameters:
fligni_1_lyr (numpy.ndarray): parameter, intercept for regression
predicting lignin content fraction from rainfall
fligni_2_lyr (numpy.ndarray): parameter, slope for regression
predicting lignin content fraction from rainfall
prcann (numpy.ndarray): derived, annual precipitation
Returns:
pltlig_lyr, fraction of residue that is lignin
"""
valid_mask = (
(fligni_1_lyr != _IC_NODATA) &
(fligni_2_lyr != _IC_NODATA) &
(prcann != _TARGET_NODATA))
pltlig = numpy.empty(fligni_1_lyr.shape, dtype=numpy.float32)
pltlig[:] = _TARGET_NODATA
pltlig[valid_mask] = (
fligni_1_lyr[valid_mask] + fligni_2_lyr[valid_mask] *
prcann[valid_mask])
pltlig[valid_mask] = numpy.clip(pltlig[valid_mask], 0.02, 0.5)
return pltlig
offset = -12
annual_precip_rasters = []
while len(annual_precip_rasters) < 12:
offset += 1
if offset == 12:
raise ValueError("Insufficient precipitation rasters were found")
precip_month = month_index + offset
try:
annual_precip_rasters.append(
aligned_inputs['precip_%d' % precip_month])
except KeyError:
continue
precip_nodata = set([])
for precip_raster in annual_precip_rasters:
precip_nodata.update(
set([pygeoprocessing.get_raster_info(precip_raster)['nodata'][0]]))
if len(precip_nodata) > 1:
raise ValueError("Precipitation rasters include >1 nodata value")
precip_nodata = list(precip_nodata)[0]
raster_list_sum(
annual_precip_rasters, precip_nodata, year_reg['annual_precip_path'],
_TARGET_NODATA)
# intermediate parameter rasters for this operation
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for val in['epnfa_1', 'epnfa_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for val in ['fligni_1_1', 'fligni_2_1', 'fligni_1_2', 'fligni_2_2']:
for pft_i in pft_id_set:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
# calculate base N deposition
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['epnfa_1'], param_val_dict['epnfa_2'],
year_reg['annual_precip_path']]],
calc_base_N_dep, year_reg['baseNdep_path'], gdal.GDT_Float32,
_TARGET_NODATA)
for pft_i in pft_id_set:
# fraction of surface residue that is lignin
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['fligni_1_1_{}'.format(pft_i)],
param_val_dict['fligni_2_1_{}'.format(pft_i)],
year_reg['annual_precip_path']]],
calc_pltlig, year_reg['pltlig_above_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# fraction of soil residue that is lignin
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['fligni_1_2_{}'.format(pft_i)],
param_val_dict['fligni_2_2_{}'.format(pft_i)],
year_reg['annual_precip_path']]],
calc_pltlig, year_reg['pltlig_below_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_latitude(template_raster, latitude_raster_path):
"""Calculate latitude at the center of each pixel in a template raster."""
pygeoprocessing.new_raster_from_base(
template_raster, latitude_raster_path, gdal.GDT_Float32,
[_IC_NODATA])
latitude_raster = gdal.OpenEx(
latitude_raster_path, gdal.OF_RASTER | gdal.GA_Update)
target_band = latitude_raster.GetRasterBand(1)
base_raster_info = pygeoprocessing.get_raster_info(template_raster)
geotransform = base_raster_info['geotransform']
for offset_map, raster_block in pygeoprocessing.iterblocks(
(template_raster, 1)):
n_y_block = raster_block.shape[0]
n_x_block = raster_block.shape[1]
# offset by .5 so we're in the center of the pixel
xoff = offset_map['xoff'] + 0.5
yoff = offset_map['yoff'] + 0.5
# calculate the projected x and y coordinate bounds for the block
x_range = numpy.linspace(
geotransform[0] + geotransform[1] * xoff,
geotransform[0] + geotransform[1] * (xoff + n_x_block - 1),
n_x_block)
y_range = numpy.linspace(
geotransform[3] + geotransform[5] * yoff,
geotransform[3] + geotransform[5] * (yoff + n_y_block - 1),
n_y_block)
# we'll use this to avoid generating any nodata points
valid_mask = raster_block != base_raster_info['nodata']
# these indexes correspond to projected coordinates
# y_vector is what we want, an array of latitude coordinates
x_vector, y_vector = numpy.meshgrid(x_range, y_range)
target_band.WriteArray(
y_vector, xoff=offset_map['xoff'], yoff=offset_map['yoff'])
# Making sure the band and dataset is flushed and not in memory
target_band.FlushCache()
target_band.FlushCache()
target_band = None
gdal.Dataset.__swig_destroy__(latitude_raster)
latitude_raster = None
def _calc_daylength(template_raster, month, daylength_path):
"""Calculate estimated hours of daylength. Daylen.c.
Parameters:
template_raster (string): path to a raster in geographic coordinates
that is aligned with model inputs
month (int): current month of the year, such that month=0 indicates
January
daylength_path (string): path to shortwave radiation raster
Side effects:
modifies or creates the raster indicated by `daylength_path`
Returns:
None
"""
def daylength(month):
def _daylength(latitude):
"""Estimate hours of daylength for a given month and latitude."""
# Julian day at beginning of each month
jday_list = [
1, 32, 61, 92, 122, 153, 183, 214, 245, 275, 306, 337]
jday = jday_list[month - 1]
# Convert latitude from degrees to radians
rlatitude = latitude * (numpy.pi / 180.0)
declin = 0.4014 * numpy.sin(6.283185 * (jday - 77.0) / 365)
temp = 1.0 - (-numpy.tan(rlatitude) * numpy.tan(declin))**2
temp[temp < 0] = 0
par1 = numpy.sqrt(temp)
par2 = -numpy.tan(rlatitude) * numpy.tan(declin)
ahou = numpy.arctan2(par1, par2)
hours_of_daylength = (ahou / numpy.pi) * 24
return hours_of_daylength
return _daylength
# calculate an intermediate input, latitude at each pixel center
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
latitude_raster_path = os.path.join(temp_dir, 'latitude.tif')
calc_latitude(template_raster, latitude_raster_path)
pygeoprocessing.raster_calculator(
[(latitude_raster_path, 1)], daylength(month), daylength_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _shortwave_radiation(template_raster, month, shwave_path):
"""Calculate shortwave radiation outside the atmosphere.
Shortwave radiation outside the atmosphere is calculated according to
Penman (1948), "Natural evaporation from open water, bare soil and grass",
Proc. Roy. Soc. London. The latitude of each pixel is required to
calculate radiation and is calculated as an intermediate step from the
input `template_raster`. shwave.f
Parameters:
template_raster (string): path to a raster in geographic coordinates
that is aligned with model inputs
month (int): current month of the year, such that month=0 indicates
January
shwave_path (string): path to shortwave radiation raster
Side effects:
Modifies the raster indicated by `shwave_path`
Returns:
None
"""
def shwave(month):
def _shwave(latitude):
"""Calculate shortwave radiation outside the atmosphere.
Parameters:
latitude (float): latitude of current site in degrees
month (int): current month of the year, such that month=1
indicates January
Returns:
shwave, short wave solar radiation outside the atmosphere
"""
# Julian date in middle of each month of the year
jday_list = [
16, 46, 75, 106, 136, 167, 197, 228, 259, 289, 320, 350]
jday = jday_list[month - 1]
transcof = 0.8
# Convert latitude from degrees to radians
rlatitude = latitude * (numpy.pi / 180.0)
# short wave solar radiation on a clear day
declin = 0.401426 * numpy.sin(6.283185 * (jday - 77.0) / 365.0)
temp = 1.0 - (-numpy.tan(rlatitude) * numpy.tan(declin))**2
temp[temp < 0.] = 0.
par1 = numpy.sqrt(temp)
par2 = (-numpy.tan(rlatitude) * numpy.tan(declin))
ahou = numpy.arctan2(par1, par2)
ahou[ahou < 0.] = 0.
solrad = (
917.0 * transcof * (
ahou * numpy.sin(rlatitude) * numpy.sin(declin) +
numpy.cos(rlatitude) *
numpy.cos(declin) * numpy.sin(ahou)))
# short wave radiation outside the atmosphere
shwave = solrad / transcof
return shwave
return _shwave
# calculate an intermediate input, latitude at each pixel center
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
latitude_raster_path = os.path.join(temp_dir, 'latitude.tif')
calc_latitude(template_raster, latitude_raster_path)
pygeoprocessing.raster_calculator(
[(latitude_raster_path, 1)],
shwave(month), shwave_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _reference_evapotranspiration(
max_temp_path, min_temp_path, shwave_path, fwloss_4_path,
pevap_path):
"""Calculate reference evapotranspiration.
Reference evapotranspiration from the FAO Penman-Monteith equation in
"Guidelines for computing crop water requirements", FAO Irrigation and
drainage paper 56 (http://www.fao.org/docrep/X0490E/x0490e08.htm),
modified by the parameter fwloss(4).
Parameters:
max_temp_path (string): path to maximum monthly temperature
min_temp_path (string): path to minimum monthly temperature
shwave_path (string): path to shortwave radiation outside the
atmosphere
fwloss_4_path (string): path to parameter, scaling factor for
reference evapotranspiration
pevap_path (string): path to result, reference evapotranspiration
raster
Side effects:
modifies or creates the raster indicated by `pevap_path`
Returns:
None
"""
def _calc_pevap(max_temp, min_temp, shwave, fwloss_4):
"""Calculate reference evapotranspiration.
Pevap.f
Parameters:
max_temp (numpy.ndarray): input, maximum monthly temperature
min_temp (numpy.ndarray): input, minimum monthly temperature
shwave (numpy.ndarray): derived, shortwave radiation outside the
atmosphere
fwloss_4 (numpy.ndarray): parameter, scaling factor for reference
evapotranspiration
Returns:
pevap, reference evapotranspiration
"""
const1 = 0.0023
const2 = 17.8
langleys2watts = 54.0
valid_mask = (
(~numpy.isclose(max_temp, maxtmp_nodata)) &
(~numpy.isclose(min_temp, mintmp_nodata)) &
(shwave != _TARGET_NODATA) &
(fwloss_4 != _IC_NODATA))
trange = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
trange[:] = _TARGET_NODATA
trange[valid_mask] = max_temp[valid_mask] - min_temp[valid_mask]
tmean = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
tmean[:] = _IC_NODATA
tmean[valid_mask] = (max_temp[valid_mask] + min_temp[valid_mask]) / 2.0
# daily reference evapotranspiration
daypet = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
daypet[:] = _TARGET_NODATA
in1 = const1 * (tmean[valid_mask] + const2)
in2 = numpy.sqrt(trange[valid_mask])
in3 = (shwave[valid_mask] / langleys2watts)
daypet[valid_mask] = (
const1 * (tmean[valid_mask] + const2) *
numpy.sqrt(trange[valid_mask]) *
(shwave[valid_mask] / langleys2watts))
# monthly reference evapotranspiration, from mm to cm,
# bounded to be at least 0.5
monpet = (daypet * 30.) / 10.
monpet[monpet <= 0.5] = 0.5
pevap = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
pevap[:] = _TARGET_NODATA
pevap[valid_mask] = monpet[valid_mask] * fwloss_4[valid_mask]
return pevap
maxtmp_nodata = pygeoprocessing.get_raster_info(
max_temp_path)['nodata'][0]
mintmp_nodata = pygeoprocessing.get_raster_info(
min_temp_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
max_temp_path, min_temp_path, shwave_path, fwloss_4_path]],
_calc_pevap, pevap_path, gdal.GDT_Float32, _TARGET_NODATA)
def _potential_production(
aligned_inputs, site_param_table, current_month, month_index,
pft_id_set, veg_trait_table, prev_sv_reg, pp_reg, month_reg):
"""Calculate above- and belowground potential production.
Potential production of each plant functional type is calculated
as total potential production given incoming solar radiation,
limited by temperature, soil moisture, and obstruction by biomass and
litter. Further modification of potential production according to
limitation by water and nutrient availability is calculated in the
root:shoot ratio submodel. Lines 57-148 Potcrp.f
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including precipitation, temperature,
plant functional type composition, and site spatial index
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
current_month (int): month of the year, such that current_month=1
indicates January
month_index (int): month of the simulation, such that month_index=13
indicates month 13 of the simulation
pft_id_set (set): set of integers identifying plant functional types
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
Side effects:
creates the raster indicated by `month_reg['h2ogef_1_<PFT>']` for each
plant functional type (PFT) where growth is scheduled to occur in
this month
creates the raster indicated by `month_reg['tgprod_pot_prod_<PFT>']`
for each plant functional type (PFT) where growth is scheduled to
occur in this month
Returns:
None
"""
# if growth does not occur this month for all PFTs,
# skip the rest of the function
do_PFT = []
for pft_i in pft_id_set:
if str(current_month) in veg_trait_table[pft_i]['growth_months']:
do_PFT.append(pft_i)
if not do_PFT:
return
def calc_ctemp(aglivc, pmxbio, maxtmp, pmxtmp, mintmp, pmntmp):
"""Calculate soil temperature relative to its effect on growth.
Soil temperature is calculated from monthly temperature inputs and
modified by total standing live biomass. Lines 69-84 Potcrp.f
Parameters:
aglivc (numpy.ndarray): derived, sum of aglivc (carbon in
aboveground live biomass) across plant functional types
pmxbio (numpy.ndarray): parameter, maximum biomass impact on
temperature
maxtmp (numpy.ndarray): input, average maximum monthly
temperature
pmxtmp (numpy.ndarray): parameter, scaling factor for effect of
biomass on monthly maximum temperature
mintmp (numpy.ndarray): input, average minimum monthly temperature
pmntmp (numpy.ndarray): parameter, scaling factor for effect of
biomass on monthly minimum temperature
Returns:
ctemp, effect of soil temperature on potential production
"""
bio = numpy.empty(aglivc.shape, dtype=numpy.float32)
bio[:] = _IC_NODATA
valid_mask = (
(aglivc >= 0.) &
(pmxbio != _IC_NODATA) &
(~numpy.isclose(maxtmp, maxtmp_nodata)) &
(pmxtmp != _IC_NODATA) &
(~numpy.isclose(mintmp, mintmp_nodata)) &
(pmntmp != _IC_NODATA))
bio[valid_mask] = aglivc[valid_mask] * 2.5
bio[bio > pmxbio] = pmxbio[bio > pmxbio]
bio[pmxbio < 0] = _IC_NODATA
# Maximum temperature
tmxs = numpy.empty(aglivc.shape, dtype=numpy.float32)
tmxs[:] = _IC_NODATA
tmxs[valid_mask] = (
maxtmp[valid_mask] + (
(25.4/(1. + 18. * numpy.exp(-0.20 * maxtmp[valid_mask]))) *
(numpy.exp(pmxtmp[valid_mask] * bio[valid_mask]) - 0.13)))
# Minimum temperature
tmns = numpy.empty(aglivc.shape, dtype=numpy.float32)
tmns[:] = _IC_NODATA
tmns[valid_mask] = (
mintmp[valid_mask] +
(pmntmp[valid_mask] * bio[valid_mask] - 1.78))
# Average temperature
ctemp = numpy.empty(aglivc.shape, dtype=numpy.float32)
ctemp[:] = _IC_NODATA
ctemp[valid_mask] = (tmxs[valid_mask] + tmns[valid_mask])/2.
return ctemp
def calc_potprd(mintmp, maxtmp, ctemp, ppdf_1, ppdf_2, ppdf_3, ppdf_4):
"""Calculate the limiting effect of temperature on growth.
Estimated soil temperature restricts potential production according to
a Poisson Density Function curve described by the plant functional
type-specific parameters ppdf_1-4.. Lines 73-84 Potcrp.f
Parameters:
mintmp (numpy.ndarray): input, average minimum monthly temperature
maxtmp (numpy.ndarray): input, average maximum monthly
temperature
ctemp (numpy.ndarray): derived, soil temperature as calculated from
monthly temperature and modified by standing live biomass
ppdf_1 (numpy.ndarray): parameter, optimum temperature for growth
ppdf_2 (numpy.ndarray): parameter, maximum temperature for growth
ppdf_3 (numpy.ndarray): parameter, left curve shape for Poisson
Density Function curve describing growth as function of
temperature
ppdf_4 (numpy.ndarray): parameter, right curve shape for Poisson
Density Function curve describing growth as function of
temperature
Returns:
potprd, scaling factor describing potential production limited
by temperature
"""
valid_mask = (
(~numpy.isclose(mintmp, mintmp_nodata)) &
(~numpy.isclose(maxtmp, maxtmp_nodata)) &
(ctemp != _IC_NODATA) &
(ppdf_1 != _IC_NODATA) &
(ppdf_2 != _IC_NODATA) &
(ppdf_3 != _IC_NODATA) &
(ppdf_4 != _IC_NODATA))
frac = numpy.empty(ctemp.shape, dtype=numpy.float32)
frac[:] = _TARGET_NODATA
frac[valid_mask] = (
(ppdf_2[valid_mask] - ctemp[valid_mask]) /
(ppdf_2[valid_mask] - ppdf_1[valid_mask]))
avg_tmp = numpy.empty(ctemp.shape, dtype=numpy.float32)
avg_tmp[valid_mask] = (mintmp[valid_mask] + maxtmp[valid_mask]) / 2.
grow_mask = (
(avg_tmp > 0) &
(frac > 0) &
valid_mask)
potprd = numpy.empty(ctemp.shape, dtype=numpy.float32)
potprd[:] = _TARGET_NODATA
potprd[valid_mask] = 0.
potprd[grow_mask] = (numpy.exp(
(ppdf_3[grow_mask]/ppdf_4[grow_mask]) *
(1. - numpy.power(frac[grow_mask], ppdf_4[grow_mask]))) *
numpy.power(frac[grow_mask], ppdf_3[grow_mask]))
return potprd
def calc_h2ogef_1(
pevap, avh2o_1, precip, wc, pprpts_1, pprpts_2, pprpts_3):
"""Calculate the limiting factor of water availability on growth.
Soil moisture restricts potential production according to the ratio
of available water to reference evapotranspiration. The shape of the
linear relationship of this ratio to potential production is
controlled by the site parameters pprpts_1, pprpts_2, and pprpts_3.
Lines 57-64 Potcrp.f
Parameters:
pevap (numpy.ndarray): derived, reference evapotranspiration
avh2o_1 (numpy.ndarray): state variable, water available to this
plant functional type for growth
precip (numpy.ndarray): input, precipitation for the current month
wc (numpy.ndarray): derived, water content in soil layer 1
pprpts_1 (numpy.ndarray): parameter, the minimum ratio of
available water to reference evapotranspiration that limits
production completely
pprpts_2 (numpy.ndarray): parameter, influences the slope of the
line predicting potential production from available water
pprpts_3 (numpy.ndarray): parameter, the ratio of available water
to reference evapotranspiration above which production is
not restricted
Returns:
h2ogef_1, scaling factor describing potential production limited
by soil moisture
"""
valid_mask = (
(pevap != _TARGET_NODATA) &
(~numpy.isclose(avh2o_1, _SV_NODATA)) &
(~numpy.isclose(precip, precip_nodata)) &
(wc != _TARGET_NODATA) &
(pprpts_1 != _IC_NODATA) &
(pprpts_2 != _IC_NODATA) &
(pprpts_3 != _IC_NODATA))
h2ogef_prior = numpy.empty(pevap.shape, dtype=numpy.float32)
h2ogef_prior[:] = _TARGET_NODATA
h2ogef_prior[valid_mask] = numpy.where(
pevap[valid_mask] >= 0.01,
(avh2o_1[valid_mask] + precip[valid_mask])/pevap[valid_mask],
0.01)
intcpt = (
pprpts_1[valid_mask] + (pprpts_2[valid_mask] * wc[valid_mask]))
slope = 1. / (pprpts_3[valid_mask] - intcpt)
h2ogef_1 = numpy.empty(pevap.shape, dtype=numpy.float32)
h2ogef_1[:] = _TARGET_NODATA
h2ogef_1[valid_mask] = (
1.0 + slope *
(h2ogef_prior[valid_mask] - pprpts_3[valid_mask]))
h2ogef_1[valid_mask] = numpy.clip(h2ogef_1[valid_mask], 0.01, 1.)
return h2ogef_1
def calc_biof(sum_stdedc, sum_aglivc, strucc_1, pmxbio, biok5):
"""Calculate the effect of obstruction on growth.
Live biomass, standing dead biomass, and litter reduce potential
production through obstruction. The shape of the relationship between
standing biomass and litter and potential production is controlled by
the site parameter pmxbio and the plant functional type parameter
biok5. Lines 91-120 Potcrp.f
Parameters:
sum_stdedc (numpy.ndarray): derived, total carbon in standing dead
biomass across plant functional types
sum_aglivc (numpy.ndarray): derived, total carbon in aboveground
live biomass across plant functional types
strucc_1 (numpy.ndarray): derived, carbon in surface litter
pmxbio (numpy.ndarray): parameter, maximum biomass impact on
potential production
biok5 (numpy.ndarray): parameter, level of standing dead biomass
and litter
Returns:
biof, scaling factor describing potential production limited
by obstruction
"""
valid_mask = (
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(pmxbio != _IC_NODATA) &
(biok5 != _IC_NODATA))
bioc = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
bioc[:] = _IC_NODATA
bioc[valid_mask] = numpy.where(
((sum_stdedc[valid_mask] + 0.1*strucc_1[valid_mask]) <= 0.), 0.01,
(sum_stdedc[valid_mask] + 0.1*strucc_1[valid_mask]))
bioc[valid_mask] = numpy.where(
(bioc[valid_mask] > pmxbio[valid_mask]), pmxbio[valid_mask],
bioc[valid_mask])
bioprd = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
bioprd[:] = _IC_NODATA
bioprd[valid_mask] = 1. - (
bioc[valid_mask] / (biok5[valid_mask] + bioc[valid_mask]))
temp1 = 1. - bioprd
temp2 = temp1 * 0.75
temp3 = temp1 * 0.25
ratlc = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
ratlc[:] = _IC_NODATA
ratlc[valid_mask] = sum_aglivc[valid_mask] / bioc[valid_mask]
biof = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
biof[:] = _TARGET_NODATA
biof[valid_mask] = numpy.where(
ratlc[valid_mask] <= 1.,
(bioprd[valid_mask] + (temp2[valid_mask] * ratlc[valid_mask])),
numpy.where(
ratlc[valid_mask] <= 2.,
(bioprd[valid_mask] + temp2[valid_mask]) +
temp3[valid_mask] * (ratlc[valid_mask] - 1.),
1.))
return biof
def calc_tgprod_pot_prod(prdx_1, shwave, potprd, h2ogef_1, biof):
"""Calculate total potential production.
Total above- and belowground potential biomass production is calculated
as the total potential production given solar radiation and the
intrinsinc growth capacity of the plant functional type, modified by
limiting factors of temperature, soil moisture, and obstruction by
standing biomass and litter. Line 147 Potcrp.f
Parameters:
prdx_1 (numpy.ndarray): parameter, the intrinsic capacity of the
plant functional type for growth per unit of solar radiation
shwave (numpy.ndarray): derived, shortwave solar radiation outside
the atmosphere
potprd (numpy.ndarray): parameter, scaling factor describing
limiting effect of temperature
h2ogef_1 (numpy.ndarray): derived, scaling factor describing the
limiting effect of soil moisture
biof (numpy.ndarray): derived, scaling factor describing the
limiting effect of obstruction by standing biomass and litter
Returns:
tgprod_pot_prod, total above- and belowground potential biomass
production (g biomass)
"""
valid_mask = (
(prdx_1 != _IC_NODATA) &
(shwave != _TARGET_NODATA) &
(potprd != _TARGET_NODATA) &
(h2ogef_1 != _TARGET_NODATA) &
(biof != _TARGET_NODATA))
tgprod_pot_prod = numpy.empty(prdx_1.shape, dtype=numpy.float32)
tgprod_pot_prod[:] = _TARGET_NODATA
tgprod_pot_prod[valid_mask] = (
prdx_1[valid_mask] * shwave[valid_mask] * potprd[valid_mask] *
h2ogef_1[valid_mask] * biof[valid_mask])
return tgprod_pot_prod
# temporary intermediate rasters for calculating total potential production
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
# site-level temporary calculated values
for val in ['sum_aglivc', 'sum_stdedc', 'ctemp', 'shwave', 'pevap']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
# PFT-level temporary calculated values
for pft_i in pft_id_set:
for val in [
'aglivc_weighted', 'stdedc_weighted', 'potprd', 'biof']:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
# temporary parameter rasters for calculating total potential production
param_val_dict = {}
# site-level parameters
for val in [
'pmxbio', 'pmxtmp', 'pmntmp', 'fwloss_4', 'pprpts_1',
'pprpts_2', 'pprpts_3']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# PFT-level parameters
for val in [
'ppdf_1', 'ppdf_2', 'ppdf_3', 'ppdf_4', 'biok5', 'prdx_1']:
for pft_i in do_PFT:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
maxtmp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
mintmp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
precip_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['precip_{}'.format(month_index)])['nodata'][0]
# calculate intermediate quantities that do not differ between PFTs:
# sum of aglivc (standing live biomass) and stdedc (standing dead biomass)
# across PFTs, weighted by % cover of each PFT
for sv in ['aglivc', 'stdedc']:
weighted_sum_path = temp_val_dict['sum_{}'.format(sv)]
weighted_state_variable_sum(
sv, prev_sv_reg, aligned_inputs, pft_id_set, weighted_sum_path)
# ctemp, soil temperature relative to impacts on growth
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_aglivc'],
param_val_dict['pmxbio'],
aligned_inputs['max_temp_{}'.format(current_month)],
param_val_dict['pmxtmp'],
aligned_inputs['min_temp_{}'.format(current_month)],
param_val_dict['pmntmp']]],
calc_ctemp, temp_val_dict['ctemp'], gdal.GDT_Float32, _IC_NODATA)
# shwave, shortwave radiation outside the atmosphere
_shortwave_radiation(
aligned_inputs['site_index'], current_month, temp_val_dict['shwave'])
# pet, reference evapotranspiration modified by fwloss parameter
_reference_evapotranspiration(
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
temp_val_dict['shwave'],
param_val_dict['fwloss_4'],
temp_val_dict['pevap'])
# calculate quantities that differ between PFTs
for pft_i in do_PFT:
# potprd, the limiting effect of temperature
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['min_temp_{}'.format(current_month)],
aligned_inputs['max_temp_{}'.format(current_month)],
temp_val_dict['ctemp'],
param_val_dict['ppdf_1_{}'.format(pft_i)],
param_val_dict['ppdf_2_{}'.format(pft_i)],
param_val_dict['ppdf_3_{}'.format(pft_i)],
param_val_dict['ppdf_4_{}'.format(pft_i)]]],
calc_potprd, temp_val_dict['potprd_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# h2ogef_1, the limiting effect of soil water availability
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pevap'],
prev_sv_reg['avh2o_1_{}_path'.format(pft_i)],
aligned_inputs['precip_{}'.format(month_index)],
pp_reg['wc_path'],
param_val_dict['pprpts_1'],
param_val_dict['pprpts_2'],
param_val_dict['pprpts_3']]],
calc_h2ogef_1, month_reg['h2ogef_1_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# biof, the limiting effect of obstruction
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_stdedc'],
temp_val_dict['sum_aglivc'],
prev_sv_reg['strucc_1_path'],
param_val_dict['pmxbio'],
param_val_dict['biok5_{}'.format(pft_i)]]],
calc_biof, temp_val_dict['biof_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# total potential production
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['prdx_1_{}'.format(pft_i)],
temp_val_dict['shwave'],
temp_val_dict['potprd_{}'.format(pft_i)],
month_reg['h2ogef_1_{}'.format(pft_i)],
temp_val_dict['biof_{}'.format(pft_i)]]],
calc_tgprod_pot_prod,
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _calc_favail_P(sv_reg, param_val_dict):
"""Calculate the fraction of P in surface layer available to plants.
This must be performed after the sum of mineral N in the surface layer
is calculated because the fraction of labile P available to plants is
impacted by the amount of mineral N in the surface layer.
Parameters:
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month, including minerl_1_1, mineral N in the
surface layer
param_val_dict (dict): map of key, path pairs giving paths to
site-level parameters, including favail_4, favail_5, favail_6,
and favail_2
Side effects:
modifies or creates the raster indicated by
`param_val_dict['favail_2']`
Returns:
None
"""
def favail_P_op(minerl_1_1, favail_4, favail_5, favail_6):
"""Calculate the fraction of P in surface layer available to plants.
The fraction of labile P available to plants depends on mineral N in
the surface layer and site parameters favail_4, favail_5, favail_6.
Line 395 Simsom.f
Parameters:
minerl_1_1 (numpy.ndarray): state variable, mineral N in the
surface layer
favail_4 (numpy.ndarray): parameter, minimum fraction of P
available
favail_5 (numpy.ndarray): parameter, maximum fraction of P
available
favail_6 (numpy.ndarray): parameter, mineral N in surface layer
required to attain maximum fraction of P available
Returns:
favail_P, fraction of mineral P available to plants
"""
valid_mask = (
(~numpy.isclose(minerl_1_1, _SV_NODATA)) &
(favail_4 != _IC_NODATA) &
(favail_5 != _IC_NODATA) &
(favail_6 != _IC_NODATA))
interim = numpy.empty(minerl_1_1.shape, dtype=numpy.float32)
interim[:] = _IC_NODATA
interim[valid_mask] = (
favail_4[valid_mask] + minerl_1_1[valid_mask] *
(favail_5[valid_mask] - favail_4[valid_mask]) /
favail_6[valid_mask])
favail_P = numpy.empty(minerl_1_1.shape, dtype=numpy.float32)
favail_P[:] = _IC_NODATA
favail_P[valid_mask] = numpy.maximum(
favail_4[valid_mask], numpy.minimum(
interim[valid_mask], favail_5[valid_mask]))
return favail_P
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_1_1_path'],
param_val_dict['favail_4'],
param_val_dict['favail_5'],
param_val_dict['favail_6']]],
favail_P_op, param_val_dict['favail_2'],
gdal.GDT_Float32, _IC_NODATA)
def _calc_avail_mineral_nutrient(pft_param_dict, sv_reg, iel, target_path):
"""Calculate one mineral nutrient available to one plant functional type.
The mineral nutrient available to a plant functional type is calculated
from the mineral nutrient content of soil layers accessible by that
plant function type.
Parameters:
pft_param_dict (dict): map of key, value pairs giving the values of
parameters for this plant functional type
(i.e., veg_trait_table[pft_i] for this pft_i)
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
iel (int): integer index for current nutrient (1=N, 2=P)
target_path (string): path to raster to contain available mineral
nutrient for this plant functional type and nutrient
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
nlay = int(pft_param_dict['nlaypg'])
mineral_raster_list = [
sv_reg['minerl_{}_{}_path'.format(lyr, iel)] for lyr in range(
1, nlay + 1)]
raster_list_sum(
mineral_raster_list, _SV_NODATA, target_path, _TARGET_NODATA,
nodata_remove=True)
def _calc_available_nutrient(
pft_i, iel, pft_param_dict, sv_reg, site_param_table, site_index_path,
availm_path, favail_path, tgprod_path, eavail_path):
"""Calculate nutrient available to a plant functional type.
The nutrient available is the sum of mineral nutrient (N or P) in soil
layers accessible by the roots of the plant functional type, modified
by the fraction of nutrient available to plants and the current root
biomass.
Parameters:
pft_i (int): plant functional type index
iel (int): nutrient index (iel=1 indicates N, iel=2 indicates P)
pft_param_dict (dict): map of key, value pairs giving the values of
parameters for this plant functional type
(i.e., veg_trait_table[pft_i] for this pft_i)
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
site_index_path (string): path to site spatial index raster
availm_path (string): path to raster containing available mineral
nutrient for the given plant functional type and nutrient
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
favail_path (string): path to raster containing the appropriate value
of the parameter favail. For nitrogen, this parameter is supplied
directly as user input, but for phosphorus, it must be calculated
from other parameters.
tgprod_path (string): path to raster containing total potential
production (g biomass)
eavail_path (string): path to location to store the result, nutrient
available to the plant functional type
Side effects:
modifies or creates the raster indicated by `eavail_path`
Returns:
None
"""
def calc_eavail(rictrl, bglivc, riint, availm, favail, crpstg):
"""Calculate available nutrient.
Parameters:
rictrl (numpy.ndarray): parameter, scaling factor used to
calculate the impact of root biomass on nutrient availability
bglivc (numpy.ndarray): state variable, carbon in belowground
live biomass
riint (numpy.ndarray): parameter, intercept used to calculate the
impact of root biomass on nutrient availability
availm (numpy.ndarray): derived, the sum of mineral nutrient in
soil layers accessible by this plant functional type
favail (numpy.ndarray): parameter, fraction of the nutrient
available each month to plants
crpstg (numpy.ndarray): state variable, nutrient in
retranslocation storage pool for the plant functional type
Returns:
eavail, the nutrient available to the plant functional type
"""
valid_mask = (
(rictrl != _IC_NODATA) &
(~numpy.isclose(bglivc, _SV_NODATA)) &
(riint != _IC_NODATA) &
(availm != _TARGET_NODATA) &
(favail != _IC_NODATA) &
(~numpy.isclose(crpstg, _SV_NODATA)))
rimpct = numpy.empty(rictrl.shape, dtype=numpy.float32)
rimpct[:] = _TARGET_NODATA
rimpct[valid_mask] = numpy.where(
((rictrl[valid_mask] * bglivc[valid_mask] * 2.5) > 33.),
1., 1. - riint[valid_mask] * numpy.exp(
-rictrl[valid_mask] * bglivc[valid_mask] * 2.5))
eavail = numpy.empty(rictrl.shape, dtype=numpy.float32)
eavail[:] = _TARGET_NODATA
eavail[valid_mask] = (
(availm[valid_mask] * favail[valid_mask] * rimpct[valid_mask]) +
crpstg[valid_mask])
return eavail
def add_symbiotic_fixed_N(eavail_prior, snfxmx, tgprod):
"""Add nitrogen fixed by the plant to nutrient available.
Some nitrogen may be fixed by the plant, and this must be added
to available mineral nitrogen. Nitrogen fixed by the plant is
calculated from total potential production and the maximum
rate of N fixation.
Parameters:
eavail_prior (numpy.ndarray): derived, mineral nitrogen available
to the plant functional type, calculated with calc_eavail()
snfxmx (numpy.ndarray): parameter, maximum rate of symbiotic
nitrogen fixation
tgprod (numpy.ndarray): derived, total above- and belowground
potential production (g biomass)
Returns:
eavail, total N available including N fixed by the plant
"""
valid_mask = (
(eavail_prior != _TARGET_NODATA) &
(snfxmx != _IC_NODATA) &
(tgprod != _TARGET_NODATA))
maxNfix = numpy.empty(eavail_prior.shape, dtype=numpy.float32)
maxNfix[:] = _TARGET_NODATA
maxNfix[valid_mask] = snfxmx[valid_mask] * (tgprod[valid_mask] / 2.5)
eavail = numpy.empty(eavail_prior.shape, dtype=numpy.float32)
eavail[:] = _TARGET_NODATA
eavail[valid_mask] = eavail_prior[valid_mask] + maxNfix[valid_mask]
return eavail
# temporary intermediate rasters for calculating available nutrient
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for val in ['rictrl', 'riint']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for val in ['snfxmx_1']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
fill_val = pft_param_dict[val]
pygeoprocessing.new_raster_from_base(
site_index_path, target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['rictrl'],
sv_reg['bglivc_{}_path'.format(pft_i)],
param_val_dict['riint'],
availm_path, favail_path,
sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)]]],
calc_eavail, eavail_path,
gdal.GDT_Float32, _TARGET_NODATA)
if iel == 1:
eavail_prior_path = os.path.join(temp_dir, 'eavail_prior.tif')
shutil.copyfile(eavail_path, eavail_prior_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
eavail_prior_path,
param_val_dict['snfxmx_1'],
tgprod_path]],
add_symbiotic_fixed_N, eavail_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _calc_nutrient_demand(
biomass_production_path, fraction_allocated_to_roots_path,
cercrp_min_above_path, cercrp_min_below_path, demand_path):
"""Calculate the demand of one nutrient by a plant functional type.
Demand is calculated from total biomass production, the fraction of biomass
production allocated to roots, and the minimum carbon/nutrient ratios of
above- and belowground live biomass. Lines 88-92 CropDynC.f and line
65, Nutrlm.f
Parameters:
biomass_production_path (string): path to raster giving total
biomass production
fraction_allocated_to_roots_path (string): path to raster giving
the fraction fo total biomass production allocated to roots
cercrp_min_above_path (string): path to raster giving the minimum
ratio of carbon to nutrient in aboveground live biomass
cercrp_min_below_path (string): path to raster giving the minimum
ratio of carbon to nutrient in belowground live biomass
Side effects:
modifies or creates the raster indicated by `demand_path`
Returns:
None
"""
def nutrient_demand_op(
biomass_production, root_fraction, cercrp_min_above,
cercrp_min_below):
"""Calculate nutrient demand.
Parameters:
biomass_production (numpy.ndarray): derived, total biomass
production
root_fraction (numpy.ndarray): derived, fraction of biomass
allocated to roots
cercrp_min_above (numpy.ndarray): derived, minimum carbon to
nutrient ratio of new aboveground live material
cercrp_min_below (numpy.ndarray): derived, minimum carbon to
nutrient ratio of new belowground live material
Returns:
demand_e, nutrient demand
"""
valid_mask = (
(biomass_production != _TARGET_NODATA) &
(root_fraction != _TARGET_NODATA) &
(cercrp_min_above != _TARGET_NODATA) &
(cercrp_min_above > 0) &
(cercrp_min_below > 0) &
(cercrp_min_below != _TARGET_NODATA))
demand_above = numpy.empty(root_fraction.shape, dtype=numpy.float32)
demand_above[:] = _TARGET_NODATA
demand_above[valid_mask] = (
((biomass_production[valid_mask] *
(1. - root_fraction[valid_mask])) / 2.5) *
(1. / cercrp_min_above[valid_mask]))
demand_below = numpy.empty(root_fraction.shape, dtype=numpy.float32)
demand_below[:] = _TARGET_NODATA
demand_below[valid_mask] = (
((biomass_production[valid_mask] *
(root_fraction[valid_mask])) / 2.5) *
(1. / cercrp_min_below[valid_mask]))
demand_e = numpy.empty(root_fraction.shape, dtype=numpy.float32)
demand_e[:] = _TARGET_NODATA
demand_e[valid_mask] = (
demand_above[valid_mask] + demand_below[valid_mask])
return demand_e
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
biomass_production_path, fraction_allocated_to_roots_path,
cercrp_min_above_path, cercrp_min_below_path]],
nutrient_demand_op, demand_path,
gdal.GDT_Float32, _TARGET_NODATA)
def calc_provisional_fracrc(
annual_precip, frtcindx, bgppa, bgppb, agppa, agppb,
cfrtcw_1, cfrtcw_2, cfrtcn_1, cfrtcn_2):
"""Calculate provisional fraction of carbon allocated to roots.
A temporary provisional fraction of carbon allocated to roots must be
calculated prior to calculating plant demand for N and P. The value
of this provisional fraction depends on whether the plant functional
type is modeled as a perennial plant or with the "Great Plains"
equation of Parton et al. 1987, "Analysis of factors controlling soil
organic matter levels in Great Plains grasslands", Soil Science
Society of America Journal. Lines 36-47 cropDynC.f
Parameters:
annual_precip (numpy.ndarray): derived, sum of monthly
precipitation over twelve months including the current month
frtcindx (numpy.ndarray): parameter, flag indicating whether
root:shoot allocation follows the Great Plains equation
(frtcindx=0) or as a perennial plant (frtcindx=1)
bgppa (numpy.ndarray): parameter, intercept in regression
estimating belowground production from annual precipitation
if frtcindx=0
bgppb (numpy.ndarray): parameter, slope in regression estimating
belowground production from annual precipitation if
frtcindx=0
agppa (numpy.ndarray): parameter, intercept in regression
estimating aboveground production from annual precipitation
if frtcindx=0
agppb (numpy.ndarray): parameter, slope in regression estimating
aboveground production from annual precipitation if
frtcindx=0
cfrtcw_1 (numpy.ndarray): parameter, maximum fraction of carbon
allocated to roots under maximum water stress if frtcindx=1
cfrtcw_2 (numpy.ndarray): parameter, minimum fraction of carbon
allocated to roots without water stress if frtcindx=1
cfrtcn_1 (numpy.ndarray): parameter, maximum fraction of carbon
allocated to roots under maximum nutrient stress if frtcindx=1
cfrtcn_2 (numpy.ndarray): parameter, minimum fraction of carbon
allocated to roots under no nutrient stress if frtcindx=1
Returns:
fracrc_p, provisional fraction of carbon allocated to roots
"""
valid_mask = (
(annual_precip != _TARGET_NODATA) &
(frtcindx != _IC_NODATA) &
(bgppa != _IC_NODATA))
rtsh = numpy.empty(annual_precip.shape, dtype=numpy.float32)
rtsh[:] = _TARGET_NODATA
rtsh[valid_mask] = (
(bgppa[valid_mask] +
annual_precip[valid_mask] * bgppb[valid_mask]) /
(agppa[valid_mask] + annual_precip[valid_mask] *
agppb[valid_mask]))
fracrc_p = numpy.empty(annual_precip.shape, dtype=numpy.float32)
fracrc_p[:] = _TARGET_NODATA
fracrc_p[valid_mask] = numpy.where(
frtcindx[valid_mask] == 0,
(1.0 / (1.0 / rtsh[valid_mask] + 1.0)),
((cfrtcw_1[valid_mask] + cfrtcw_2[valid_mask] +
cfrtcn_1[valid_mask] + cfrtcn_2[valid_mask]) / 4.0))
return fracrc_p
def calc_ce_ratios(
pramn_1_path, pramn_2_path, aglivc_path, biomax_path,
pramx_1_path, pramx_2_path, prbmn_1_path, prbmn_2_path,
prbmx_1_path, prbmx_2_path, annual_precip_path, pft_i, iel,
month_reg):
"""Calculate minimum and maximum carbon to nutrient ratios.
Minimum and maximum C/E ratios are used to calculate demand for a
nutrient by a plant functional type. This function calculates the
ratios for above- and belowground plant portions, for one plant
functional type and one nutrient. Fltce.f
Parameters:
pramn_1_path (string): path to raster containing the parameter
pramn_<iel>_1, the minimum aboveground ratio with zero biomass
pramn_2_path (string): path to raster containing the parameter
pramn_<iel>_2, the minimum aboveground ratio with biomass greater
than or equal to biomax
aglivc_path (string): path to raster containing carbon in
aboveground live biomass
biomax_path (string): path to raster containing the parameter
biomax, the biomass above which the ratio equals pramn_2
or pramx_2
pramx_1_path (string): path to raster containing the parameter
pramx_<iel>_1, the maximum aboveground ratio with zero biomass
pramx_2_path (string): path to raster containing the parameter
pramx_<iel>_2, the maximum aboveground ratio with biomass greater
than or equal to biomax
prbmn_1_path (string): path to raster containing the parameter
prbmn_<iel>_1, intercept of regression to predict minimum
belowground ratio from annual precipitation
prbmn_2_path (string): path to raster containing the parameter
prbmn_<iel>_2, slope of regression to predict minimum belowground
ratio from annual precipitation
prbmx_1_path (string): path to raster containing the parameter
prbmx_<iel>_1, intercept of regression to predict maximum
belowground ratio from annual precipitation
prbmx_2_path (string): path to raster containing the parameter
prbmx_<iel>_2, slope of regression to predict maximum belowground
ratio from annual precipitation
annual_precip_path (string): path to annual precipitation raster
pft_i (int): plant functional type index
iel (int): nutrient index (iel=1 indicates N, iel=2 indicates P)
month_reg (dict): map of key, path pairs giving paths to
intermediate calculated values that are shared between
submodels
Side effects:
creates the rasters indicated by
`month_reg['cercrp_min_above_<iel>_<pft_i>']`,
`month_reg['cercrp_max_above_<iel>_<pft_i>']`,
`month_reg['cercrp_min_below_<iel>_<pft_i>']`,
`month_reg['cercrp_max_below_<iel>_<pft_i>']`,
Returns:
None
"""
def calc_above_ratio(pra_1, pra_2, aglivc, biomax):
"""Calculate carbon to nutrient ratio for aboveground material.
Parameters:
pra_1 (numpy.ndarray): parameter, minimum or maximum ratio
with zero biomass
pra_2 (numpy.ndarray): parameter, minimum or maximum ratio
with biomass greater than or equal to biomax
aglivc (numpy.ndarray): state variable, carbon in aboveground
live material
biomax (numpy:ndarray): parameter, biomass above which the
ratio equals pra_2
Returns:
cercrp_above, carbon to nutrient ratio for aboveground
material
"""
valid_mask = (
(pra_1 != _IC_NODATA) &
(pra_2 != _IC_NODATA) &
(~numpy.isclose(aglivc, _SV_NODATA)) &
(biomax != _IC_NODATA))
cercrp_above = numpy.empty(pra_1.shape, dtype=numpy.float32)
cercrp_above[:] = _TARGET_NODATA
cercrp_above[valid_mask] = numpy.minimum(
(pra_1[valid_mask] + (pra_2[valid_mask] - pra_1[valid_mask]) *
2.5 * aglivc[valid_mask] / biomax[valid_mask]),
pra_2[valid_mask])
return cercrp_above
def calc_below_ratio(prb_1, prb_2, annual_precip):
"""Calculate carbon to nutrient ratio for belowground material.
Parameters:
prb_1 (numpy.ndarray): parameter, intercept of regression
to predict ratio from annual precipitation
prb_2 (numpy.ndarray): parameter, slope of regression to
predict ratio from annual precipitation
annual_precip (numpy.ndarray): derived, precipitation in twelve
months including the current month
Returns:
cercrp_below, carbon to nutrient ratio for belowground
material
"""
valid_mask = (
(prb_1 != _IC_NODATA) &
(prb_2 != _IC_NODATA) &
(annual_precip != _TARGET_NODATA))
cercrp_below = numpy.empty(prb_1.shape, dtype=numpy.float32)
cercrp_below[:] = _TARGET_NODATA
cercrp_below[valid_mask] = (
prb_1[valid_mask] +
(prb_2[valid_mask] * annual_precip[valid_mask]))
return cercrp_below
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
pramn_1_path, pramn_2_path, aglivc_path, biomax_path]],
calc_above_ratio,
month_reg['cercrp_min_above_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
pramx_1_path, pramx_2_path, aglivc_path, biomax_path]],
calc_above_ratio,
month_reg['cercrp_max_above_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prbmn_1_path, prbmn_2_path, annual_precip_path]],
calc_below_ratio,
month_reg['cercrp_min_below_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prbmx_1_path, prbmx_2_path, annual_precip_path]],
calc_below_ratio,
month_reg['cercrp_max_below_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
def calc_revised_fracrc(
frtcindx_path, fracrc_p_path, totale_1_path, totale_2_path,
demand_1_path, demand_2_path, h2ogef_1_path, cfrtcw_1_path,
cfrtcw_2_path, cfrtcn_1_path, cfrtcn_2_path, fracrc_r_path):
"""
Calculate revised fraction of carbon allocated to roots.
The revised fraction of carbon allocated to roots includes the
impacts of water and nutrient limitation. The method of the
revised calculation depends on whether the plant functional
type is modeled as a perennial plant or with the "Great Plains"
equation of Parton et al. 1987, "Analysis of factors controlling soil
organic matter levels in Great Plains grasslands", Soil Science
Society of America Journal. Lines 96-104, cropDynC.f, froota.f
Parameters:
frtcindx_path (string): path to raster containing the parameter
frtcindx
fracrc_p_path (string): path to raster containing provisional
fraction of carbon allocated to roots
totale_1_path (string): path to raster containing total available
nitrogen
totale_2_path (string): path to raster containing total available
phosphorus
demand_1_path (string): path to raster containing nitrogen demand
demand_2_path (string): path to raster containing phosphorus demand
h2ogef_1_path (string): path to raster containing the limiting
effect of water availability on growth
cfrtcw_1_path (string): path to raster containing the parameter
cfrtcw_1
cfrtcw_2_path (string): path to raster containing the parameter
cfrtcw_2
cfrtcn_1_path (string): path to raster containing the parameter
cfrtcn_1
cfrtcn_2_path (string): path to raster containing the parameter
cfrtcn_2
fracrc_r_path (string): path to raster that should contain the
result, revised fraction of carbon allocated to roots
Side effects:
creates the raster indicated by `fracrc_r_path`
Returns:
None
"""
def calc_a2drat(totale, demand):
"""Calculate the ratio of available nutrient to nutrient demand.
The ratio of nutrient available to demand for the nutrient is
restricted to be between 0 and 1.
Parameters:
totale (numpy.ndarray): derived, nutrient available
demand (numpy.ndarray): derived, demand for the nutrient
Returns:
a2drat, the ratio of available nutrient to demand, restricted
to be between 0 and 1
"""
valid_mask = (
(totale != _TARGET_NODATA) &
(demand != _TARGET_NODATA))
a2drat = numpy.empty(totale.shape, dtype=numpy.float32)
a2drat[:] = _TARGET_NODATA
demand_mask = ((demand > 0) & valid_mask)
a2drat[valid_mask] = 1.
a2drat[demand_mask] = numpy.clip(
totale[demand_mask] / demand[demand_mask], 0., 1.)
return a2drat
def calc_perennial_fracrc(
h2ogef, cfrtcw_1, cfrtcw_2, a2drat_1, a2drat_2, cfrtcn_1,
cfrtcn_2):
"""Calculate fraction C allocated to roots for a perennial plant.
The fraction of carbon allocated to roots is determined by
water availability, described by h2ogef, and nutrient availability,
described by a2drat_1 for nitrogen and a2drat_2 for phosphorus.
Lines 114-125 froota.f
Parameters:
h2ogef (numpy.ndarray): derived, the limiting factor of water
availability on growth
cfrtcw_1 (numpy.ndarray): parameter, the maximum fraction of
carbon allocated to roots with maximum water stress
cfrtcw_2 (numpy.ndarray): parameter, the minimum fraction of
carbon allocated to roots with no water stress
a2drat_1 (numpy.ndarray): derived, the ratio of available
nitrogen to nitrogen demand, restricted to be between 0
and 1
a2drat_2 (numpy.ndarray): derived, the ratio of available
phosphorus to phosphorus demand, restricted to be between
0 and 1
cfrtcn_1 (numpy.ndarray): parameter, maximum fraction of
carbon allocated to roots with maximum nutrient stress
cfrtcn_2 (numpy.ndarray): parameter, minimum fraction of
carbon allocated to roots with no nutrient stress
Returns:
fracrc_perennial, revised fraction of C allocated to roots for
a perennial plant
"""
valid_mask = (
(h2ogef != _TARGET_NODATA) &
(cfrtcw_1 != _IC_NODATA) &
(cfrtcw_2 != _IC_NODATA) &
(a2drat_1 != _TARGET_NODATA) &
(a2drat_2 != _TARGET_NODATA) &
(cfrtcn_1 != _IC_NODATA) &
(cfrtcn_2 != _IC_NODATA))
h2oeff = numpy.empty(h2ogef.shape, dtype=numpy.float32)
h2oeff[:] = _TARGET_NODATA
h2oeff[valid_mask] = (
(cfrtcw_2[valid_mask] - cfrtcw_1[valid_mask]) *
(h2ogef[valid_mask] - 1.) + cfrtcw_2[valid_mask])
ntreff_1 = numpy.empty(h2ogef.shape, dtype=numpy.float32)
ntreff_1[:] = _TARGET_NODATA
ntreff_1[valid_mask] = (
(cfrtcn_2[valid_mask] - cfrtcn_1[valid_mask]) *
(a2drat_1[valid_mask] - 1.0) + cfrtcn_2[valid_mask])
ntreff_2 = numpy.empty(h2ogef.shape, dtype=numpy.float32)
ntreff_2[:] = _TARGET_NODATA
ntreff_1[valid_mask] = (
(cfrtcn_2[valid_mask] - cfrtcn_1[valid_mask]) *
(a2drat_2[valid_mask] - 1.0) + cfrtcn_2[valid_mask])
ntreff = numpy.empty(h2ogef.shape, dtype=numpy.float32)
ntreff[:] = _TARGET_NODATA
ntreff[valid_mask] = numpy.maximum(
ntreff_1[valid_mask], ntreff_2[valid_mask])
fracrc_perennial = numpy.empty(
h2ogef.shape, dtype=numpy.float32)
fracrc_perennial[:] = _TARGET_NODATA
fracrc_perennial[valid_mask] = numpy.minimum(
numpy.maximum(h2oeff[valid_mask], ntreff[valid_mask]), 0.99)
return fracrc_perennial
def revised_fracrc_op(frtcindx, fracrc_p, fracrc_perennial):
"""Calculate revised fraction of carbon allocated to roots.
The revised fraction of carbon allocated to roots is calculated
according to the parameter frtcindx. If frtcindx=0 (use the "Great
Plains equation"), the revised fraction is equal to the provisional
fraction. If frtcindx=1 (a perennial plant), the revised fraction
is calculated from water and nutrient stress.
Parameters:
frtcindx (numpy.ndarray): parameter, indicates whether revised
fraction of carbon allocated to roots should follow the
"Great Plains equation" or the algorithm for a perennial
plant
fracrc_p (numpy.ndarray): derived, provisional fraction of
carbon allocated to roots
fracrc_perennial (numpy.ndarray): derived, fraction of
carbon allocated to roots for a perennial plant
Returns:
fracrc_r, revised fraction of carbon allocated to roots
"""
valid_mask = (
(frtcindx != _IC_NODATA) &
(fracrc_p != _TARGET_NODATA) &
(fracrc_perennial != _TARGET_NODATA))
fracrc_r = numpy.empty(frtcindx.shape, dtype=numpy.float32)
fracrc_r[:] = _TARGET_NODATA
fracrc_r[valid_mask] = numpy.where(
frtcindx[valid_mask] == 0, fracrc_p[valid_mask],
fracrc_perennial[valid_mask])
return fracrc_r
# temporary intermediate rasters for calculating revised fracrc
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in ['a2drat_1', 'a2drat_2', 'fracrc_perennial']:
temp_val_dict[val] = os.path.join(
temp_dir, '{}.tif'.format(val))
pygeoprocessing.raster_calculator(
[(path, 1) for path in [totale_1_path, demand_1_path]],
calc_a2drat, temp_val_dict['a2drat_1'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [totale_2_path, demand_2_path]],
calc_a2drat, temp_val_dict['a2drat_2'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
h2ogef_1_path, cfrtcw_1_path, cfrtcw_2_path,
temp_val_dict['a2drat_1'], temp_val_dict['a2drat_2'],
cfrtcn_1_path, cfrtcn_2_path]],
calc_perennial_fracrc, temp_val_dict['fracrc_perennial'],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
frtcindx_path, fracrc_p_path,
temp_val_dict['fracrc_perennial']]],
revised_fracrc_op, fracrc_r_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def grazing_effect_on_aboveground_production(tgprod, fracrc, flgrem, grzeff):
"""Adjust aboveground production with the impact of grazing.
Removal of biomass by herbivores directly impacts potential
aboveground production according to the amount of biomass removed
and the parameter grzeff, which acts as a switch to determine the
effect. If grzeff=0, 3, or 4, aboveground production is not
changed. If grzeff=1 or 6, production decreases linearly with
biomass removed; if grzeff=2 or 5, biomass removed has a quadratic
impact on production. Grazrst.f
Parameters:
tgprod (numpy.ndarray): derived, total potential biomass
production restricted by water and nutrient availability
fracrc (numpy.ndarray): derived, fraction of carbon allocated
to roots according to water and nutrient availability
flgrem (numpy.ndarray): derived, fraction of live biomass
removed by grazing in previous monthly step
grzeff (numpy.ndarray): parameter, the effect of defoliation on
production and root:shoot ratio
Returns:
agprod, aboveground production impacted by grazing
"""
valid_mask = (
(tgprod != _TARGET_NODATA) &
(fracrc != _TARGET_NODATA) &
(flgrem != _TARGET_NODATA) &
(grzeff != _IC_NODATA))
agprod_prior = numpy.empty(tgprod.shape, dtype=numpy.float32)
agprod_prior[:] = _TARGET_NODATA
agprod_prior[valid_mask] = (
tgprod[valid_mask] * (1. - fracrc[valid_mask]))
linear_effect = numpy.empty(tgprod.shape, dtype=numpy.float32)
linear_effect[:] = _TARGET_NODATA
linear_effect[valid_mask] = numpy.maximum(
(1. - (2.21*flgrem[valid_mask])) * agprod_prior[valid_mask],
0.02)
quadratic_effect = numpy.empty(tgprod.shape, dtype=numpy.float32)
quadratic_effect[:] = _TARGET_NODATA
quadratic_effect[valid_mask] = (
(1. + 2.6*flgrem[valid_mask] -
(5.83*(numpy.power(flgrem[valid_mask], 2)))) *
agprod_prior[valid_mask])
quadratic_effect[valid_mask] = numpy.maximum(
quadratic_effect[valid_mask], 0.02)
no_effect_mask = (valid_mask & numpy.isin(grzeff, [0, 3, 4]))
linear_mask = (valid_mask & numpy.isin(grzeff, [1, 6]))
quadratic_mask = (valid_mask & numpy.isin(grzeff, [2, 5]))
agprod = numpy.empty(tgprod.shape, dtype=numpy.float32)
agprod[:] = _TARGET_NODATA
agprod[no_effect_mask] = agprod_prior[no_effect_mask]
agprod[linear_mask] = linear_effect[linear_mask]
agprod[quadratic_mask] = quadratic_effect[quadratic_mask]
return agprod
def grazing_effect_on_root_shoot(fracrc, flgrem, grzeff, gremb):
"""Adjust root:shoot ratio according to the impact of grazing.
Removal of biomass by herbivores directly impacts the root:shoot
ratio of production according to the amount of biomass removed and
the parameter grzeff, which acts as a switch to determine the
effect. If grzeff=0 or 1, the root:shoot ratio is not changed.
If grzeff=2 or 3, biomass removed has a quadratic impact on the
root:shoot ratio. If grzeff=4, 5, or 6, biomass removed has a
linear effect on the root:shoot ratio. The parameter gremb
multiplies the linear impact of grazing when grzeff=4, 5 or 6.
Grzrst.f
Parameters:
fracrc (numpy.ndarray): derived, fraction of carbon allocated
to roots according to water and nutrient availability
flgrem (numpy.ndarray): derived, fraction of live biomass
removed by grazing in previous monthly step
grzeff (numpy.ndarray): parameter, the effect of defoliation on
production and root:shoot ratio
grzemb (numpy.ndarray): parameter, grazing effect multiplier
Returns:
rtsh, root:shoot ratio impacted by grazing
"""
valid_mask = (
(fracrc != _TARGET_NODATA) &
(flgrem != _TARGET_NODATA) &
(grzeff != _IC_NODATA) &
(gremb != _IC_NODATA))
rtsh_prior = numpy.empty(fracrc.shape, dtype=numpy.float32)
rtsh_prior[:] = _TARGET_NODATA
rtsh_prior[valid_mask] = (
fracrc[valid_mask] / (1. - fracrc[valid_mask]))
quadratic_effect = numpy.empty(fracrc.shape, dtype=numpy.float32)
quadratic_effect[:] = _TARGET_NODATA
quadratic_effect[valid_mask] = numpy.maximum(
rtsh_prior[valid_mask] + 3.05 * flgrem[valid_mask] -
11.78 * numpy.power(flgrem[valid_mask], 2),
0.01)
linear_effect = numpy.empty(fracrc.shape, dtype=numpy.float32)
linear_effect[:] = _TARGET_NODATA
linear_effect[valid_mask] = numpy.maximum(
1. - (flgrem[valid_mask] * gremb[valid_mask]),
0.01)
no_effect_mask = (valid_mask & numpy.isin(grzeff, [0, 1]))
quadratic_mask = (valid_mask & numpy.isin(grzeff, [2, 3]))
linear_mask = (valid_mask & numpy.isin(grzeff, [4, 5, 6]))
rtsh = numpy.empty(fracrc.shape, dtype=numpy.float32)
rtsh[:] = _TARGET_NODATA
rtsh[no_effect_mask] = rtsh_prior[no_effect_mask]
rtsh[quadratic_mask] = quadratic_effect[quadratic_mask]
rtsh[linear_mask] = linear_effect[linear_mask]
return rtsh
def calc_tgprod_final(rtsh, agprod):
"""Calculate final total potential production.
Final total potential production is calculated from aboveground
production impacted by grazing and the final root:shoot ratio
impacted by grazing.
Parameters:
rtsh (numpy.ndarray): derived, final root:shoot ratio impacted
by grazing
agprod (numpy.ndarray): derived, final aboveground potential
production impacted by grazing
Returns:
tgprod, final total potential production
"""
valid_mask = (
(rtsh != _TARGET_NODATA) &
(agprod != _TARGET_NODATA))
tgprod = numpy.empty(rtsh.shape, dtype=numpy.float32)
tgprod[:] = _TARGET_NODATA
tgprod[valid_mask] = (
agprod[valid_mask] + (rtsh[valid_mask] * agprod[valid_mask]))
return tgprod
def calc_final_tgprod_rtsh(
tgprod_pot_prod_path, fracrc_path, flgrem_path, grzeff_path,
gremb_path, tgprod_path, rtsh_path):
"""Calculate final potential production and root:shoot ratio.
Final potential production and root:shoot ratio include the impact of
grazing. First calculate final aboveground production including the
impact of grazing; then calculate rtsh, the final root:shoot ratio
including the impact of grazing; then calculate tgprod, final total
potential production, from final aboveground production and final
root:shoot ratio. Grazrst.f
Parameters:
tgprod_pot_prod_path (string): path to raster containing total
potential biomass production restricted by water and nutrient
availability, prior to effects of grazing
fracrc_path (string): path to raster containing the fraction of
carbon production allocated to roots according to restriction
by water and nutrient availability, prior to effects of
grazing
flgrem_path (string): path to raster containing the fraction of
live aboveground biomass removed by herbivores according to
diet selection in the previous step
grzeff_path (string): path to raster containing the parameter
grzeff, the effect of defolation on production and root:shoot
ratio
gremb_path (string): path to raster containing the parameter
gremb, the grazing effect multiplier
tgprod_path (string): path to raster containing final total
potential production (g biomass)
rtsh_path (string): path to raster containing final root:shoot
ratio of potential production
Side effects:
creates the raster indicated by tgprod_path
creates the raster indicated by rtsh_path
Returns:
None
"""
# temporary intermediate rasters for grazing effect
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
agprod_path = os.path.join(temp_dir, 'agprod.tif')
# grazing effect on aboveground production
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tgprod_pot_prod_path, fracrc_path, flgrem_path,
grzeff_path]],
grazing_effect_on_aboveground_production,
agprod_path, gdal.GDT_Float32, _TARGET_NODATA)
# grazing effect on final root:shoot ratio
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
fracrc_path, flgrem_path, grzeff_path, gremb_path]],
grazing_effect_on_root_shoot, rtsh_path,
gdal.GDT_Float32, _TARGET_NODATA)
# final total potential production
pygeoprocessing.raster_calculator(
[(path, 1) for path in [rtsh_path, agprod_path]],
calc_tgprod_final, tgprod_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _root_shoot_ratio(
aligned_inputs, site_param_table, current_month, pft_id_set,
veg_trait_table, prev_sv_reg, year_reg, month_reg):
"""Calculate final potential production and root:shoot ratio.
Final potential biomass production and root:shoot ratio is calculated
according to nutrient availability and demand for the nutrient, and the
impact of defoliation by herbivores. CropDynC.f
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including the site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
current_month (int): month of the year, such that current_month=1
indicates January
pft_id_set (set): set of integers identifying plant functional types
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
year_reg (dict): map of key, path pairs giving paths to rasters that
are modified once per year, including annual precipitation
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
Side effects:
creates the raster indicated by
`month_reg['tgprod_<PFT>']`, total potential production (g biomass)
for each plant functional type (PFT)
creates the raster indicated by `month_reg['rtsh_<PFT>']` for each
plant functional type (PFT)
Returns:
None
"""
# if growth does not occur this month for all PFTs,
# skip the rest of the function
do_PFT = []
for pft_i in pft_id_set:
# growth occurs in growth months and when senescence not scheduled
do_growth = (
current_month != veg_trait_table[pft_i]['senescence_month'] and
str(current_month) in veg_trait_table[pft_i]['growth_months'])
if do_growth:
do_PFT.append(pft_i)
if not do_PFT:
return
# temporary intermediate rasters for root:shoot submodel
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for pft_i in do_PFT:
for val in ['fracrc_p', 'fracrc', 'availm']:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
for iel in [1, 2]:
for val in ['eavail', 'demand']:
temp_val_dict[
'{}_{}_{}'.format(val, iel, pft_i)] = os.path.join(
temp_dir, '{}_{}_{}.tif'.format(val, iel, pft_i))
# temporary parameter rasters for root:shoot submodel
param_val_dict = {}
# site-level parameters
for val in [
'bgppa', 'bgppb', 'agppa', 'agppb', 'favail_1', 'favail_4',
'favail_5', 'favail_6']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# PFT-level parameters
for pft_i in do_PFT:
for val in [
'frtcindx', 'cfrtcw_1', 'cfrtcw_2', 'cfrtcn_1', 'cfrtcn_2',
'biomax', 'cfrtcw_1', 'cfrtcw_2', 'cfrtcn_1', 'cfrtcn_2',
'grzeff', 'gremb']:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
for val in [
'pramn_1_1', 'pramn_1_2', 'pramx_1_1', 'pramx_1_2',
'prbmn_1_1', 'prbmn_1_2', 'prbmx_1_1', 'prbmx_1_2',
'pramn_2_1', 'pramn_2_2', 'pramx_2_1', 'pramx_2_2',
'prbmn_2_1', 'prbmn_2_2', 'prbmx_2_1', 'prbmx_2_2']:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict[
'{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path,
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
# the parameter favail_2 must be calculated from current mineral N in
# surface layer
param_val_dict['favail_2'] = os.path.join(temp_dir, 'favail_2.tif')
_calc_favail_P(prev_sv_reg, param_val_dict)
for pft_i in do_PFT:
# fracrc_p, provisional fraction of C allocated to roots
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
year_reg['annual_precip_path'],
param_val_dict['frtcindx_{}'.format(pft_i)],
param_val_dict['bgppa'],
param_val_dict['bgppb'],
param_val_dict['agppa'],
param_val_dict['agppb'],
param_val_dict['cfrtcw_1_{}'.format(pft_i)],
param_val_dict['cfrtcw_2_{}'.format(pft_i)],
param_val_dict['cfrtcn_1_{}'.format(pft_i)],
param_val_dict['cfrtcn_2_{}'.format(pft_i)]]],
calc_provisional_fracrc,
temp_val_dict['fracrc_p_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
for iel in [1, 2]:
# persistent ratios used here and in plant growth submodel
calc_ce_ratios(
param_val_dict['pramn_{}_1_{}'.format(iel, pft_i)],
param_val_dict['pramn_{}_2_{}'.format(iel, pft_i)],
prev_sv_reg['aglivc_{}_path'.format(pft_i)],
param_val_dict['biomax_{}'.format(pft_i)],
param_val_dict['pramx_{}_1_{}'.format(iel, pft_i)],
param_val_dict['pramx_{}_2_{}'.format(iel, pft_i)],
param_val_dict['prbmn_{}_1_{}'.format(iel, pft_i)],
param_val_dict['prbmn_{}_2_{}'.format(iel, pft_i)],
param_val_dict['prbmx_{}_1_{}'.format(iel, pft_i)],
param_val_dict['prbmx_{}_2_{}'.format(iel, pft_i)],
year_reg['annual_precip_path'], pft_i, iel, month_reg)
# sum of mineral nutrient in accessible soil layers
_calc_avail_mineral_nutrient(
veg_trait_table[pft_i], prev_sv_reg, iel,
temp_val_dict['availm_{}'.format(pft_i)])
# eavail_iel, available nutrient
_calc_available_nutrient(
pft_i, iel, veg_trait_table[pft_i], prev_sv_reg,
site_param_table, aligned_inputs['site_index'],
temp_val_dict['availm_{}'.format(pft_i)],
param_val_dict['favail_{}'.format(iel)],
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['eavail_{}_{}'.format(iel, pft_i)])
# demand_iel, demand for the nutrient
_calc_nutrient_demand(
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['fracrc_p_{}'.format(pft_i)],
month_reg['cercrp_min_above_{}_{}'.format(iel, pft_i)],
month_reg['cercrp_min_below_{}_{}'.format(iel, pft_i)],
temp_val_dict['demand_{}_{}'.format(iel, pft_i)])
# revised fraction of carbon allocated to roots
calc_revised_fracrc(
param_val_dict['frtcindx_{}'.format(pft_i)],
temp_val_dict['fracrc_p_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
temp_val_dict['demand_1_{}'.format(pft_i)],
temp_val_dict['demand_2_{}'.format(pft_i)],
month_reg['h2ogef_1_{}'.format(pft_i)],
param_val_dict['cfrtcw_1_{}'.format(pft_i)],
param_val_dict['cfrtcw_2_{}'.format(pft_i)],
param_val_dict['cfrtcn_1_{}'.format(pft_i)],
param_val_dict['cfrtcn_2_{}'.format(pft_i)],
temp_val_dict['fracrc_{}'.format(pft_i)])
# final potential production and root:shoot ratio accounting for
# impacts of grazing
calc_final_tgprod_rtsh(
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['fracrc_{}'.format(pft_i)],
month_reg['flgrem_{}'.format(pft_i)],
param_val_dict['grzeff_{}'.format(pft_i)],
param_val_dict['gremb_{}'.format(pft_i)],
month_reg['tgprod_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)])
# clean up temporary files
shutil.rmtree(temp_dir)
def _snow(
site_index_path, site_param_table, precip_path, tave_path,
max_temp_path, min_temp_path, prev_snow_path, prev_snlq_path,
current_month, snowmelt_path, snow_path, snlq_path,
inputs_after_snow_path, pet_rem_path):
"""Account for precipitation as snow and snowmelt from snowpack.
Determine whether precipitation falls as snow. Track the fate of
new and existing snowpack including evaporation and melting. Track the
the remaining snowpack and liquid in snow and potential
evapotranspiration remaining after evaporation of snow. Snowcent.f
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
precip_path (string): path to raster containing precipitation for the
current month
tave_path (string): path to raster containing average temperature for
the current month
max_temp_path (string): path to raster containing maximum temperature
for the current month
min_temp_path (string): path to raster containing minimum temperature
for the current month
prev_snow_path (string): path to raster containing current snowpack
prev_snlq_path (string): path to raster containing current liquid in
snow
current_month (int): current month of the year, such that month=0
indicates January
snow_path (string): path to raster to contain modified snowpack
snlq_path (string): path to raster to contain modified liquid in snow
inputs_after_snow_path (string): path to raster containing water inputs
to the system after accounting for snow
pet_rem_path (string): path to raster containing potential
evapotranspiration remaining after any evaporation of snow
Side effects:
creates the raster indicated by `snowmelt_path`
creates the raster indicated by `snow_path`
creates the raster indicated by `snlq_path`
creates the raster indicated by `inputs_after_snow_path`
creates the raster indicated by `pet_rem_path`
Returns:
None
"""
def calc_snow_moisture(return_type):
"""Calculate change in snow, pet, snow liquid, and moisture inputs.
Record changes in snowpack, liquid in snow, potential
evapotranspiration energy, and liquid draining into soil from snow.
Parameters:
return_type (string): flag indicating whether modified snowpack,
modified liquid in snow, modified potential evapotranspiration,
or soil moisture inputs after snow should be returned
Returns:
the function `_calc_snow_moisture`
"""
def _calc_snow_moisture(
tave, precip, snow, snlq, pet, tmelt_1, tmelt_2, shwave):
"""Calculate the fate of moisture from snow.
Calculate new snowfall or rain on snow. Calculate direct
evaporation of snow and consumption of potential
evapotranspiration energy. Calculate snowmelt and liquid draining
from snow into the soil.
Parameters:
tave (numpy.ndarray): derived, average temperature
precip (numpy.ndarray): input, precipitation for this month
snow (numpy.ndarray): derived, existing snowpack prior to new
snowfall
snlq (numpy.ndarray): derived, existing liquid in snowpack
pet (numpy.ndarray): derived, potential evapotranspiration
tmelt_1 (numpy.ndarray): parameter, minimum temperature above
which snow will melt
tmelt_2 (numpy.ndarray): parameter, ratio between degrees above
the minimum temperature and cm of snow that will melt
shwave (numpy.ndarray): derived, shortwave radiation outside
the atmosphere
Returns:
snowmelt if return_type is 'snowmelt'
snow_revised if return_type is 'snow'
snlq_revised if return_type is 'snlq'
pet_revised if return_type is 'pet'
inputs_after_snow if return_type is 'inputs_after_snow'
"""
valid_mask = (
(tave != _IC_NODATA) &
(~numpy.isclose(precip, precip_nodata)) &
(~numpy.isclose(snow, _SV_NODATA)) &
(~numpy.isclose(snlq, _SV_NODATA)) &
(pet != _TARGET_NODATA) &
(tmelt_1 != _IC_NODATA) &
(tmelt_2 != _IC_NODATA) &
(shwave != _TARGET_NODATA))
inputs_after_snow = numpy.empty(precip.shape, dtype=numpy.float32)
inputs_after_snow[:] = _TARGET_NODATA
inputs_after_snow[valid_mask] = precip[valid_mask]
snowfall_mask = (valid_mask & (tave <= 0))
snow[snowfall_mask] = (snow[snowfall_mask] + precip[snowfall_mask])
inputs_after_snow[snowfall_mask] = 0.
rain_on_snow_mask = (
(valid_mask) &
(tave > 0) &
(snow > 0))
snlq[rain_on_snow_mask] = (
snlq[rain_on_snow_mask] + precip[rain_on_snow_mask])
inputs_after_snow[rain_on_snow_mask] = 0.
snowtot = numpy.zeros(snow.shape, dtype=numpy.float32)
snowtot[valid_mask] = numpy.maximum(
snow[valid_mask] + snlq[valid_mask], 0)
evap_mask = (valid_mask & (snowtot > 0.))
evsnow = numpy.zeros(snow.shape, dtype=numpy.float32)
evsnow[evap_mask] = numpy.minimum(
snowtot[evap_mask], pet[evap_mask] * 0.87)
snow_revised = numpy.empty(snow.shape, dtype=numpy.float32)
snow_revised[:] = _TARGET_NODATA
snow_revised[valid_mask] = snow[valid_mask]
snow_revised[evap_mask] = numpy.maximum(
snow[evap_mask] - evsnow[evap_mask] *
(snow[evap_mask] / snowtot[evap_mask]), 0.)
snlq_revised = numpy.zeros(snow.shape, dtype=numpy.float32)
snlq_revised[valid_mask] = snlq[valid_mask]
snlq_revised[evap_mask] = numpy.maximum(
snlq[evap_mask] - evsnow[evap_mask] *
(snlq[evap_mask] / snowtot[evap_mask]), 0.)
pet_revised = numpy.empty(snow.shape, dtype=numpy.float32)
pet_revised[:] = _TARGET_NODATA
pet_revised[valid_mask] = pet[valid_mask]
pet_revised[evap_mask] = numpy.maximum(
(pet[evap_mask] - evsnow[evap_mask] / 0.87), 0.)
melt_mask = (valid_mask & (tave >= tmelt_1))
snowmelt = numpy.zeros(snow.shape, dtype=numpy.float32)
snowmelt[melt_mask] = numpy.clip(
tmelt_2[melt_mask] * (tave[melt_mask] - tmelt_1[melt_mask]) *
shwave[melt_mask], 0., snow_revised[melt_mask])
snow_revised[melt_mask] = (
snow_revised[melt_mask] - snowmelt[melt_mask])
snlq_revised[melt_mask] = (
snlq_revised[melt_mask] + snowmelt[melt_mask])
drain_mask = (melt_mask & (snlq_revised > 0.5 * snow_revised))
inputs_after_snow[drain_mask] = (
snlq_revised[drain_mask] - 0.5 * snow_revised[drain_mask])
snlq_revised[drain_mask] = (
snlq_revised[drain_mask] - inputs_after_snow[drain_mask])
if return_type == 'snowmelt':
return snowmelt
elif return_type == 'snow':
return snow_revised
elif return_type == 'snlq':
return snlq_revised
elif return_type == 'pet':
return pet_revised
else:
return inputs_after_snow
return _calc_snow_moisture
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in ['shwave', 'pet']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
for val in ['tmelt_1', 'tmelt_2', 'fwloss_4']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for (
site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path, gdal.GDT_Float32,
_IC_NODATA)
max_temp_nodata = pygeoprocessing.get_raster_info(
max_temp_path)['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
min_temp_path)['nodata'][0]
precip_nodata = pygeoprocessing.get_raster_info(
precip_path)['nodata'][0]
# solar radiation outside the atmosphere
_shortwave_radiation(precip_path, current_month, temp_val_dict['shwave'])
# pet, reference evapotranspiration modified by fwloss parameter
_reference_evapotranspiration(
max_temp_path, min_temp_path, temp_val_dict['shwave'],
param_val_dict['fwloss_4'], temp_val_dict['pet'])
# calculate snowmelt
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture('snowmelt'), snowmelt_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate change in snow
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("snow"), snow_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate change in liquid in snow
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("snlq"), snlq_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate change in potential evapotranspiration energy
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("pet"), pet_rem_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate soil moisture inputs draining from snow after snowmelt
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("inputs_after_snow"), inputs_after_snow_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _calc_aboveground_live_biomass(sum_aglivc, sum_tgprod):
"""Calculate aboveground live biomass for purposes of soil water.
Live biomass impacts loss of moisture inputs through canopy
interception and evapotranspiration. Because soil moisture is computed
after potential production, but before actual growth of plants, some of
the predicted growth in biomass (i.e., tgprod) is added here to
existing standing live biomass (i.e., aglivc * 2.5; line 80,
potprod.f, in Century).
Parameters:
sum_aglivc (numpy.ndarray): the sum of aglivc across plant
functional types (pft), weighted by % cover of the pft
sum_tgprod (numpy.ndarray): sum of tgprod, potential production
limited by soil water, nutrient availability, and grazing,
across pfts weighted by % cover of the pft
Returns:
aliv, aboveground live biomass for soil water submodel
"""
valid_mask = (
(sum_aglivc != _TARGET_NODATA) &
(sum_tgprod != _TARGET_NODATA))
aliv = numpy.empty(sum_aglivc.shape, dtype=numpy.float32)
aliv[:] = _TARGET_NODATA
aliv[valid_mask] = (
sum_aglivc[valid_mask] * 2.5 + (0.25 * sum_tgprod[valid_mask]))
return aliv
def _calc_standing_biomass(aliv, sum_stdedc):
"""Calculate total aboveground standing biomass for soil water.
Total standing biomass impacts loss of moisture inputs by increasing
total canopy interception and decreasing bare soil evaporation. It is
the sum of live and dead standing biomass across plant functional
types, bounded to be <= 800 g/m2.
Parameters:
aliv (numpy.ndarray): aboveground live biomass, calculated from
aglivc and tgprod across plant functional types
sum_stdedc (numpy.ndarray): aboveground standing dead C summed
across plant functional types
Returns:
sd, total aboveground standing biomass for soil water.
"""
valid_mask = (
(aliv != _TARGET_NODATA) &
(sum_stdedc != _TARGET_NODATA))
sd = numpy.empty(aliv.shape, dtype=numpy.float32)
sd[:] = _TARGET_NODATA
sd[valid_mask] = numpy.minimum(
aliv[valid_mask] + (sum_stdedc[valid_mask] * 2.5), 800.)
return sd
def subtract_surface_losses(return_type):
"""Calculate surface losses to runoff and surface evaporation.
Calculate the loss of surface moisture to runoff, canopy interception,
and bare soil evaporation.
Parameters:
return_type (string): flag indicating whether soil moisture inputs
after surface losses or total surface evaporation should be
returned
Returns:
the function `_subtract_surface_losses`
"""
def _subtract_surface_losses(
inputs_after_snow, fracro, precro, snow, alit, sd, fwloss_1,
fwloss_2, pet_rem):
"""Subtract moisture losses to runoff, interception, and evaporation.
Of the surface water inputs from precipitation and snowmelt, some water
is lost to runoff (line 113, H2olos.f). After runoff, some water is
lost to canopy interception and bare soil evaporation, if there is no
snow cover. Loss to canopy interception and bare soil evaporation is
a function of live, standing dead, and surface litter biomass. The
total loss of moisture to interception and bare soil evaporation is
bounded to be less than or equal to 40% of reference
evapotranspiration.
Parameters:
inputs_after_snow (numpy.ndarray): derived, surface water inputs
from precipitation and snowmelt, prior to runoff
fracro (numpy.ndarray): parameter, fraction of surface water
above precro that is lost to runoff
precro (numpy.ndarray): parameter, amount of surface water that
must be available for runoff to occur
snow (numpy.ndarray): derived, current snowpack
alit (numpy.ndarray): derived, biomass in surface litter
sd (numpy.ndarray): derived, total standing biomass
fwloss_1 (numpy.ndarray): parameter, scaling factor for
interception and evaporation of precip by vegetation
fwloss_2 (numpy.ndarray): parameter, scaling factor for bare soil
evaporation of precip
pet_rem (numpy.ndarray): derived, potential evaporation remaining
after evaporation of snow
Returns:
inputs_after_surface, surface water inputs to soil after runoff
and surface evaporation are subtracted, if return_type is
'inputs_after_surface'
absevap, bare soil evaporation, if return_type is 'absevap'
evap_losses, total surface evaporation, if return_type is
'evap_losses'
"""
valid_mask = (
(inputs_after_snow != _TARGET_NODATA) &
(fracro != _IC_NODATA) &
(precro != _IC_NODATA) &
(snow != _TARGET_NODATA) &
(alit != _TARGET_NODATA) &
(sd != _TARGET_NODATA) &
(fwloss_1 != _IC_NODATA) &
(fwloss_2 != _IC_NODATA) &
(pet_rem != _TARGET_NODATA))
runoff = numpy.empty(inputs_after_snow.shape, dtype=numpy.float32)
runoff[:] = _TARGET_NODATA
runoff[valid_mask] = numpy.maximum(
fracro[valid_mask] *
(inputs_after_snow[valid_mask] - precro[valid_mask]), 0.)
inputs_after_runoff = numpy.empty(
inputs_after_snow.shape, dtype=numpy.float32)
inputs_after_runoff[:] = _TARGET_NODATA
inputs_after_runoff[valid_mask] = (
inputs_after_snow[valid_mask] - runoff[valid_mask])
evap_mask = (valid_mask & (snow <= 0))
# loss to interception
aint = numpy.zeros(inputs_after_snow.shape, dtype=numpy.float32)
aint[evap_mask] = (
(0.0003 * alit[evap_mask] + 0.0006 * sd[evap_mask]) *
fwloss_1[evap_mask])
# loss to bare soil evaporation
absevap = numpy.empty(inputs_after_snow.shape, dtype=numpy.float32)
absevap[:] = _TARGET_NODATA
absevap[valid_mask] = 0.
absevap[evap_mask] = (
0.5 *
numpy.exp((-0.002 * alit[evap_mask]) - (0.004 * sd[evap_mask])) *
fwloss_2[evap_mask])
# total losses to interception and evaporation
evap_losses = numpy.empty(inputs_after_snow.shape, dtype=numpy.float32)
evap_losses[:] = _TARGET_NODATA
evap_losses[valid_mask] = 0.
evap_losses[evap_mask] = (
numpy.minimum(((absevap[evap_mask] + aint[evap_mask]) *
inputs_after_runoff[evap_mask]), (0.4 * pet_rem[evap_mask])))
# remaining inputs after evaporation
inputs_after_surface = numpy.empty(
inputs_after_snow.shape, dtype=numpy.float32)
inputs_after_surface[:] = _TARGET_NODATA
inputs_after_surface[valid_mask] = inputs_after_runoff[valid_mask]
inputs_after_surface[evap_mask] = (
inputs_after_runoff[evap_mask] - evap_losses[evap_mask])
if return_type == 'inputs_after_surface':
return inputs_after_surface
elif return_type == 'absevap':
return absevap
elif return_type == 'evap_losses':
return evap_losses
return _subtract_surface_losses
def calc_potential_transpiration(return_type):
"""Calculate potential transpiration and evaporation from soil layer 1.
Calculate potential transpiration (trap), potential evaporation from
soil layer 1 (pevp), and initial transpiration water loss (tran).
Remove the initial transpiration water loss from soil moisture inputs
at this step.
Parameters:
return_type (string): flag indicating whether potential transpiration,
potential evaporation from soil layer 1, or modified moisture
inputs should be returned
Returns:
the function `_calc_potential_transpiration`
"""
def _calc_potential_transpiration(
pet_rem, evap_losses, tave, aliv, current_moisture_inputs):
"""Calculate potential water losses to transpiration.
Calculate potential transpiration (trap), the total potential
transpiration from all soil layers by plants. Calculate potential
evaporation from soil layer 1 (pevp); this amount is calculated prior
to transpiration but actually removed after water loss to transpiration
from all soil layers has been accounted. Calculate actual transpiration
(tran). Remove actual transpiration water losses from moisture inputs
before distributing water to soil layers. This is necessary for a
monthly time step to give plants in wet climates adequate access to
water for transpiration.
Parameters:
pet_rem (numpy.ndarray): derived, potential evapotranspiration
remaining after evaporation of snow
evap_losses (numpy.ndarray): derived, total surface evaporation
tave (numpy.ndarray): derived, average temperature
aliv (numpy.ndarray): aboveground live biomass, calculated from
aglivc and tgprod across plant functional types
current_moisture_inputs (numpy.ndarray): derived, moisture inputs
after surface losses
Returns:
trap if return_type is 'trap'
pevp if return_type is 'pevp'
modified_moisture_inputs if return_type is
'modified_moisture_inputs'
"""
valid_mask = (
(pet_rem != _TARGET_NODATA) &
(evap_losses != _TARGET_NODATA) &
(tave != _IC_NODATA) &
(aliv != _TARGET_NODATA) &
(current_moisture_inputs != _TARGET_NODATA))
trap = numpy.empty(pet_rem.shape, dtype=numpy.float32)
trap[:] = _TARGET_NODATA
trap[valid_mask] = pet_rem[valid_mask] - evap_losses[valid_mask]
no_transpiration_mask = (valid_mask & (tave < 2))
trap[no_transpiration_mask] = 0.
transpiration_mask = (valid_mask & (tave >= 2))
trap[transpiration_mask] = numpy.maximum(
numpy.minimum(
trap[transpiration_mask], pet_rem[transpiration_mask] *
0.65 * (1 - numpy.exp(-0.02 * aliv[transpiration_mask]))), 0.)
trap[valid_mask] = numpy.maximum(trap[valid_mask], 0.01)
pevp = numpy.empty(pet_rem.shape, dtype=numpy.float32)
pevp[:] = _TARGET_NODATA
pevp[valid_mask] = numpy.maximum(
pet_rem[valid_mask] - trap[valid_mask] - evap_losses[valid_mask],
0.)
tran = numpy.empty(pet_rem.shape, dtype=numpy.float32)
tran[:] = _TARGET_NODATA
tran[valid_mask] = numpy.minimum(
trap[valid_mask] - 0.01, current_moisture_inputs[valid_mask])
trap[valid_mask] = trap[valid_mask] - tran[valid_mask]
modified_moisture_inputs = numpy.empty(
pet_rem.shape, dtype=numpy.float32)
modified_moisture_inputs[:] = _TARGET_NODATA
modified_moisture_inputs[valid_mask] = (
current_moisture_inputs[valid_mask] - tran[valid_mask])
if return_type == 'trap':
return trap
elif return_type == 'pevp':
return pevp
elif return_type == 'modified_moisture_inputs':
return modified_moisture_inputs
return _calc_potential_transpiration
def distribute_water_to_soil_layer(return_type):
"""Distribute moisture inputs to one soil layer prior to transpiration.
Soil moisture inputs after runoff, evaporation, and initial
transpiration are distributed to soil layers sequentially according to the
field capacity of the layer. If moisture inputs exceed the field capacity
of the layer, the remainder of moisture inputs move down to the next
adjacent soil layer.
Returns:
the function `_distribute_water`
"""
def _distribute_water(adep, afiel, asmos, current_moisture_inputs):
"""Revise soil moisture in this soil layer prior to transpiration.
Moisture inputs coming into this soil layer are compared to the field
capacity of the layer. If the field capacity is exceeded, the excess
moisture moves from this layer to the next adjacent layer.
Parameters:
adep (numpy.ndarray): parameter, depth of this soil layer in cm
afiel (numpy.ndarray): derived, field capacity of this layer
asmos (numpy.ndarray): state variable, current soil moisture
content of this soil layer
current_moisture_inputs (numpy.ndarray): derived, moisture inputs
added to this soil layer
Returns:
asmos_revised, revised soil moisture in this layer, if return_type
is 'asmos_revised'
amov, moisture flowing from this layer into the next, if
return_type is 'amov'
"""
valid_mask = (
(adep != _IC_NODATA) &
(afiel != _TARGET_NODATA) &
(~numpy.isclose(asmos, _SV_NODATA)) &
(current_moisture_inputs != _TARGET_NODATA))
afl = numpy.empty(adep.shape, dtype=numpy.float32)
afl[:] = _TARGET_NODATA
afl[valid_mask] = adep[valid_mask] * afiel[valid_mask]
asmos_interm = numpy.empty(adep.shape, dtype=numpy.float32)
asmos_interm[:] = _TARGET_NODATA
asmos_interm[valid_mask] = (
asmos[valid_mask] + current_moisture_inputs[valid_mask])
amov = numpy.empty(adep.shape, dtype=numpy.float32)
amov[:] = _TARGET_NODATA
exceeded_mask = (valid_mask & (asmos_interm > afl))
amov[exceeded_mask] = asmos_interm[exceeded_mask]
asmos_revised = numpy.empty(adep.shape, dtype=numpy.float32)
asmos_revised[:] = _TARGET_NODATA
asmos_revised[valid_mask] = asmos_interm[valid_mask]
asmos_revised[exceeded_mask] = afl[exceeded_mask]
notexceeded_mask = (valid_mask & (asmos_interm <= afl))
amov[notexceeded_mask] = 0.
if return_type == 'asmos_revised':
return asmos_revised
elif return_type == 'amov':
return amov
return _distribute_water
def calc_available_water_for_transpiration(asmos, awilt, adep):
"""Calculate water available for transpiration in one soil layer.
The water available for transpiration is the amount of water in the soil
layer minus the wilting point of the soil layer.
Parameters:
asmos (numpy.ndarray): derived, interim moisture in the soil layer
awilt (numpy.ndarray): derived, wilting point of the soil layer
adep (numpy.ndarray): parameter, depth of the soil layer in cm
Returns:
avw, available water for transpiration
"""
valid_mask = (
(asmos != _TARGET_NODATA) &
(awilt != _TARGET_NODATA) &
(adep != _IC_NODATA))
avw = numpy.empty(asmos.shape, dtype=numpy.float32)
avw[:] = _TARGET_NODATA
avw[valid_mask] = numpy.maximum(
asmos[valid_mask] - awilt[valid_mask] * adep[valid_mask], 0.)
return avw
def revise_potential_transpiration(trap, tot):
"""Revise potential transpiration according to water available.
Total potential transpiration, trap, is revised to be less than or equal
to total water available for transpiration, tot. Total water available
for transpiration is the sum of available water per soil layer.
Line 241, H2olos.f
Parameters:
trap (numpy.ndarray): derived, potential transpiration water losses
tot (numpy.ndarray): derived, total soil water available for
transpiration
Returns:
trap_revised, revised total potential transpiration
"""
valid_mask = (
(trap != _TARGET_NODATA) &
(tot != _TARGET_NODATA))
trap_revised = numpy.empty(trap.shape, dtype=numpy.float32)
trap_revised[:] = _TARGET_NODATA
trap_revised[valid_mask] = numpy.minimum(trap[valid_mask], tot[valid_mask])
return trap_revised
def remove_transpiration(return_type):
"""Remove water from a soil layer via transpiration by plants.
Transpiration from one soil layer is apportioned from total potential
transpiration, trap, according to the available water for transpiration in
this soil layer. Lines 218-294, H2olos.f
Parameters:
return_type (string): flag indicating whether avinj (water in this soil
layer available to plants for growth) or asmos (total water in this
soil layer) should be returned
Returns:
the function `_remove_transpiration`
"""
def _remove_transpiration(asmos, awilt, adep, trap, awwt, tot2):
"""Remove water from a soil layer via transpiration by plants.
Parameters:
asmos (numpy.ndarray): derived, interim moisture in this soil layer
after additions from current month precipitation
awilt (numpy.ndarray): derived, wilting point of this soil layer
adep (numpy.ndarray): parameter, depth of this soil layer in cm
trap (numpy.ndarray): derived, total potential transpiration
across all soil layers accessible by plant roots
awwt (numpy.ndarray): derived, water available for transpiration
in this soil layer weighted by transpiration depth distribution
parameter
tot2 (numpy.ndarray): derived, the sum of weighted water available
for transpiration across soil layers
Returns:
avinj, water available to plants for growth in this layer after
losses to transpiration, if return type is 'avinj'
asmos_revised, total water in this layer after losses to
transpiration, if return type is 'asmos'
"""
valid_mask = (
(asmos != _TARGET_NODATA) &
(awilt != _TARGET_NODATA) &
(adep != _IC_NODATA) &
(trap != _TARGET_NODATA) &
(awwt != _TARGET_NODATA) &
(tot2 != _TARGET_NODATA))
avinj = numpy.empty(asmos.shape, dtype=numpy.float32)
avinj[:] = _TARGET_NODATA
avinj[valid_mask] = numpy.maximum(
asmos[valid_mask] - awilt[valid_mask] * adep[valid_mask], 0.)
transpire_mask = (valid_mask & (tot2 > 0))
transpiration_loss = numpy.zeros(asmos.shape, dtype=numpy.float32)
transpiration_loss[transpire_mask] = numpy.minimum(
(trap[transpire_mask] *
awwt[transpire_mask]) / tot2[transpire_mask],
avinj[transpire_mask])
avinj[valid_mask] = avinj[valid_mask] - transpiration_loss[valid_mask]
asmos_revised = numpy.empty(asmos.shape, dtype=numpy.float32)
asmos_revised[:] = _TARGET_NODATA
asmos_revised[valid_mask] = (
asmos[valid_mask] - transpiration_loss[valid_mask])
if return_type == 'avinj':
return avinj
elif return_type == 'asmos':
return asmos_revised
return _remove_transpiration
def calc_relative_water_content_lyr_1(asmos_1, adep_1, awilt_1, afiel_1):
"""Calculate the relative water content of soil layer 1.
The relative water content of soil layer 1, prior to any evaporation losses
from soil layer 1, is used to estimate water available for evaporation
from soil layer 1. Line 280, H2olos.f
Parameters:
asmos_1 (numpy.ndarray): derived, interim moisture in soil layer 1
after losses to transpiration
adep_1 (numpy.ndarray): parameter, depth of soil layer 1 in cm
awilt_1 (numpy.ndarray): derived, wilting point of soil layer 1
afiel_1 (numpy.ndarray): derived, field capacity of soil layer 1
Returns:
rwcf_1, relative water content of soil layer 1
"""
valid_mask = (
(asmos_1 != _TARGET_NODATA) &
(adep_1 != _IC_NODATA) &
(awilt_1 != _TARGET_NODATA) &
(afiel_1 != _TARGET_NODATA))
rwcf_1 = numpy.empty(asmos_1.shape, dtype=numpy.float32)
rwcf_1[valid_mask] = (
(asmos_1[valid_mask] / adep_1[valid_mask] - awilt_1[valid_mask]) /
(afiel_1[valid_mask] - awilt_1[valid_mask]))
return rwcf_1
def calc_evaporation_loss(rwcf_1, pevp, absevap, asmos_1, awilt_1, adep_1):
"""Calculate evaporation from soil layer 1.
Some moisture is lost from soil layer 1 (i.e., the top soil layer) to
evaporation, separate from surface evaporation and transpiration by plants.
This amount is calculated from potential soil evaporation, which was
calculated from potential evapotranspiration prior to allocation of water
to soil layers. It is restricted to be less than or equal to water
available in this soil layer.
Parameters:
rwcf_1 (numpy.ndarray): derived, relative water content of soil layer 1
pevp (numpy.ndarray): derived, potential evaporation from soil layer 1
absevap (numpy.ndarray): derived, bare soil evaporation
asmos_1 (numpy.ndarray): derived, interim moisture in soil layer 1
awilt_1 (numpy.ndarray): derived, wilting point of soil layer 1
adep_1 (numpy.ndarray): parameter, depth of soil layer 1 in cm
Returns:
evlos, moisture evaporated from soil layer 1
"""
valid_mask = (
(rwcf_1 != _TARGET_NODATA) &
(pevp != _TARGET_NODATA) &
(absevap != _TARGET_NODATA) &
(asmos_1 != _TARGET_NODATA) &
(awilt_1 != _TARGET_NODATA) &
(adep_1 != _IC_NODATA))
evmt = numpy.empty(rwcf_1.shape, dtype=numpy.float32)
evmt[:] = _TARGET_NODATA
evmt[valid_mask] = numpy.maximum(
(rwcf_1[valid_mask] - 0.25) / (1 - 0.25), 0.01)
evlos = numpy.empty(rwcf_1.shape, dtype=numpy.float32)
evlos[:] = _TARGET_NODATA
evlos[valid_mask] = numpy.minimum(
evmt[valid_mask] * pevp[valid_mask] * absevap[valid_mask] * 0.1,
numpy.maximum(
asmos_1[valid_mask] - awilt_1[valid_mask] *
adep_1[valid_mask], 0.))
return evlos
def _soil_water(
aligned_inputs, site_param_table, veg_trait_table, current_month,
month_index, prev_sv_reg, pp_reg, pft_id_set, month_reg, sv_reg):
"""Allocate precipitation to runoff, transpiration, and soil moisture.
Simulate snowfall and account for evaporation and melting of the snow pack.
Allocate the flow of precipitation through interception by plants,
runoff and infiltration into the soil, percolation through the soil, and
transpiration by plants. Update soil moisture in each soil layer.
Estimate avh2o_1 for each PFT (water available to the PFT for growth),
avh2o_3 (water in first two soil layers), and amov_<lyr> (saturated flow
of water between soil layers, used in decomposition and mineral leaching).
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including precipitation, temperature,
plant functional type composition, and site spatial index
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters, including nlaypg, number of soil
layers access by plant roots
current_month (int): month of the year, such that current_month=1
indicates January
month_index (int): month of the simulation, such that month_index=1
indicates month 1 of the simulation
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
pp_reg (dict): map of key, path pairs giving persistent parameters
including field capacity of each soil layer
pft_id_set (set): set of integers identifying plant functional types
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
creates the raster indicated by `sv_reg['snow_path']`, current snowpack
creates the raster indicated by `sv_reg['snlq_path']`, current liquid
in snow
creates the raster indicated by
`sv_reg['asmos_<lyr>_path']`, soil moisture content, for each soil
layer accessible by roots of any plant functional type
creates the rasters indicated by `month_reg['amov_<lyr>']` for each
soil layer, saturated flow of water from that soil layer
creates the raster indicated by `sv_reg['avh2o_1_<PFT>_path']`, soil
moisture available for growth, for each plant functional type (PFT)
creates the raster indicated by `sv_reg['avh2o_3_path']`, available
water in the top two soil layers
Returns:
None
"""
def calc_avg_temp(max_temp, min_temp):
"""Calculate average temperature from maximum and minimum temp."""
valid_mask = (
(~numpy.isclose(max_temp, max_temp_nodata)) &
(~numpy.isclose(min_temp, min_temp_nodata)))
tave = numpy.empty(max_temp.shape, dtype=numpy.float32)
tave[:] = _IC_NODATA
tave[valid_mask] = (max_temp[valid_mask] + min_temp[valid_mask]) / 2.
return tave
def calc_surface_litter_biomass(strucc_1, metabc_1):
"""Calculate biomass in surface litter."""
valid_mask = (
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(~numpy.isclose(metabc_1, _SV_NODATA)))
alit = numpy.empty(strucc_1.shape, dtype=numpy.float32)
alit[:] = _TARGET_NODATA
alit[valid_mask] = (strucc_1[valid_mask] + metabc_1[valid_mask]) * 2.5
alit = numpy.minimum(alit, 400)
return alit
max_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
# get max number of soil layers accessible by plants
nlaypg_max = int(max(val['nlaypg'] for val in veg_trait_table.values()))
# max number of soil layers simulated, beyond those accessible by plants
nlayer_max = int(max(val['nlayer'] for val in site_param_table.values()))
# temporary intermediate rasters for soil water submodel
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'tave', 'current_moisture_inputs', 'modified_moisture_inputs',
'pet_rem', 'alit', 'sum_aglivc', 'sum_stdedc', 'sum_tgprod',
'aliv', 'sd', 'absevap', 'evap_losses', 'trap', 'trap_revised',
'pevp', 'tot', 'tot2', 'rwcf_1', 'evlos', 'avinj_interim_1']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
# temporary intermediate values for each layer accessible by plants
for val in ['avw', 'awwt', 'avinj']:
for lyr in range(1, nlaypg_max + 1):
val_lyr = '{}_{}'.format(val, lyr)
temp_val_dict[val_lyr] = os.path.join(
temp_dir, '{}.tif'.format(val_lyr))
# temporary intermediate value for each layer total
for lyr in range(1, nlayer_max + 1):
val_lyr = 'asmos_interim_{}'.format(lyr)
temp_val_dict[val_lyr] = os.path.join(
temp_dir, '{}.tif'.format(val_lyr))
# PFT-level temporary calculated values
for pft_i in pft_id_set:
for val in ['tgprod_weighted', 'sum_avinj']:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict = {}
for val in ['fracro', 'precro', 'fwloss_1', 'fwloss_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for lyr in range(1, nlaypg_max + 1):
val_lyr = 'awtl_{}'.format(lyr)
target_path = os.path.join(temp_dir, '{}.tif'.format(val_lyr))
param_val_dict[val_lyr] = target_path
site_to_val = dict(
[(site_code, float(table[val_lyr])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for lyr in range(1, nlayer_max + 1):
val_lyr = 'adep_{}'.format(lyr)
target_path = os.path.join(temp_dir, '{}.tif'.format(val_lyr))
param_val_dict[val_lyr] = target_path
site_to_val = dict(
[(site_code, float(table[val_lyr])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# calculate canopy and litter cover that influence moisture inputs
# calculate biomass in surface litter
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['strucc_1_path'], prev_sv_reg['metabc_1_path']]],
calc_surface_litter_biomass, temp_val_dict['alit'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate the sum of aglivc (standing live biomass) and stdedc
# (standing dead biomass) across PFTs, weighted by % cover of each PFT
for sv in ['aglivc', 'stdedc']:
weighted_sum_path = temp_val_dict['sum_{}'.format(sv)]
weighted_state_variable_sum(
sv, prev_sv_reg, aligned_inputs, pft_id_set, weighted_sum_path)
# calculate the weighted sum of tgprod, potential production, across PFTs
weighted_path_list = []
for pft_i in pft_id_set:
do_growth = (
current_month != veg_trait_table[pft_i]['senescence_month'] and
str(current_month) in veg_trait_table[pft_i]['growth_months'])
if do_growth:
target_path = temp_val_dict['tgprod_weighted_{}'.format(pft_i)]
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
raster_multiplication(
month_reg['tgprod_{}'.format(pft_i)], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
target_path, _TARGET_NODATA)
weighted_path_list.append(target_path)
if weighted_path_list:
raster_list_sum(
weighted_path_list, _TARGET_NODATA,
temp_val_dict['sum_tgprod'], _TARGET_NODATA, nodata_remove=True)
else: # no potential production occurs this month, so tgprod = 0
pygeoprocessing.new_raster_from_base(
temp_val_dict['sum_aglivc'], temp_val_dict['sum_tgprod'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0.])
# calculate average temperature
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)]]],
calc_avg_temp, temp_val_dict['tave'], gdal.GDT_Float32, _IC_NODATA)
# calculate aboveground live biomass
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_aglivc'], temp_val_dict['sum_tgprod']]],
_calc_aboveground_live_biomass, temp_val_dict['aliv'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate total standing biomass
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aliv'], temp_val_dict['sum_stdedc']]],
_calc_standing_biomass, temp_val_dict['sd'],
gdal.GDT_Float32, _TARGET_NODATA)
# modify standing snow, liquid in snow, return moisture inputs after snow
_snow(
aligned_inputs['site_index'], site_param_table,
aligned_inputs['precip_{}'.format(month_index)],
temp_val_dict['tave'],
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
prev_sv_reg['snow_path'], prev_sv_reg['snlq_path'],
current_month, month_reg['snowmelt'], sv_reg['snow_path'],
sv_reg['snlq_path'], temp_val_dict['modified_moisture_inputs'],
temp_val_dict['pet_rem'])
# remove runoff and surface evaporation from moisture inputs
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
temp_val_dict['current_moisture_inputs'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['current_moisture_inputs'],
param_val_dict['fracro'], param_val_dict['precro'],
sv_reg['snow_path'], temp_val_dict['alit'],
temp_val_dict['sd'], param_val_dict['fwloss_1'],
param_val_dict['fwloss_2'], temp_val_dict['pet_rem']]],
subtract_surface_losses('inputs_after_surface'),
temp_val_dict['modified_moisture_inputs'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate bare soil evaporation
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['current_moisture_inputs'],
param_val_dict['fracro'], param_val_dict['precro'],
sv_reg['snow_path'], temp_val_dict['alit'],
temp_val_dict['sd'], param_val_dict['fwloss_1'],
param_val_dict['fwloss_2'], temp_val_dict['pet_rem']]],
subtract_surface_losses('absevap'),
temp_val_dict['absevap'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate total losses to surface evaporation
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['current_moisture_inputs'],
param_val_dict['fracro'], param_val_dict['precro'],
sv_reg['snow_path'], temp_val_dict['alit'],
temp_val_dict['sd'], param_val_dict['fwloss_1'],
param_val_dict['fwloss_2'], temp_val_dict['pet_rem']]],
subtract_surface_losses('evap_losses'),
temp_val_dict['evap_losses'],
gdal.GDT_Float32, _TARGET_NODATA)
# remove losses due to initial transpiration from water inputs
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
temp_val_dict['current_moisture_inputs'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pet_rem'], temp_val_dict['evap_losses'],
temp_val_dict['tave'], temp_val_dict['aliv'],
temp_val_dict['current_moisture_inputs']]],
calc_potential_transpiration('modified_moisture_inputs'),
temp_val_dict['modified_moisture_inputs'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate potential transpiration
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pet_rem'], temp_val_dict['evap_losses'],
temp_val_dict['tave'], temp_val_dict['aliv'],
temp_val_dict['current_moisture_inputs']]],
calc_potential_transpiration('trap'), temp_val_dict['trap'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate potential evaporation from top soil layer
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pet_rem'], temp_val_dict['evap_losses'],
temp_val_dict['tave'], temp_val_dict['aliv'],
temp_val_dict['current_moisture_inputs']]],
calc_potential_transpiration('pevp'), temp_val_dict['pevp'],
gdal.GDT_Float32, _TARGET_NODATA)
# distribute water to each layer
for lyr in range(1, nlayer_max + 1):
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
temp_val_dict['current_moisture_inputs'])
# revise moisture content of this soil layer
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['adep_{}'.format(lyr)],
pp_reg['afiel_{}_path'.format(lyr)],
prev_sv_reg['asmos_{}_path'.format(lyr)],
temp_val_dict['current_moisture_inputs']]],
distribute_water_to_soil_layer('asmos_revised'),
temp_val_dict['asmos_interim_{}'.format(lyr)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate soil moisture moving to next layer
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['adep_{}'.format(lyr)],
pp_reg['afiel_{}_path'.format(lyr)],
prev_sv_reg['asmos_{}_path'.format(lyr)],
temp_val_dict['current_moisture_inputs']]],
distribute_water_to_soil_layer('amov'),
temp_val_dict['modified_moisture_inputs'],
gdal.GDT_Float32, _TARGET_NODATA)
# amov, water moving to next layer, persists between submodels
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
month_reg['amov_{}'.format(lyr)])
# calculate available water for transpiration
avw_list = []
for lyr in range(1, nlaypg_max + 1):
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['asmos_interim_{}'.format(lyr)],
pp_reg['awilt_{}_path'.format(lyr)],
param_val_dict['adep_{}'.format(lyr)]]],
calc_available_water_for_transpiration,
temp_val_dict['avw_{}'.format(lyr)], gdal.GDT_Float32,
_TARGET_NODATA)
avw_list.append(temp_val_dict['avw_{}'.format(lyr)])
# total water available for transpiration
raster_list_sum(
avw_list, _TARGET_NODATA, temp_val_dict['tot'], _TARGET_NODATA)
# calculate water available for transpiration weighted by transpiration
# depth for that soil layer
awwt_list = []
for lyr in range(1, nlaypg_max + 1):
raster_multiplication(
temp_val_dict['avw_{}'.format(lyr)], _TARGET_NODATA,
param_val_dict['awtl_{}'.format(lyr)], _IC_NODATA,
temp_val_dict['awwt_{}'.format(lyr)], _TARGET_NODATA)
awwt_list.append(temp_val_dict['awwt_{}'.format(lyr)])
# total weighted available water for transpiration
raster_list_sum(
awwt_list, _TARGET_NODATA, temp_val_dict['tot2'], _TARGET_NODATA)
# revise total potential transpiration
pygeoprocessing.raster_calculator(
[(path, 1) for path in [temp_val_dict['trap'], temp_val_dict['tot']]],
revise_potential_transpiration, temp_val_dict['trap_revised'],
gdal.GDT_Float32, _TARGET_NODATA)
# remove water via transpiration
for lyr in range(1, nlaypg_max + 1):
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['asmos_interim_{}'.format(lyr)],
pp_reg['awilt_{}_path'.format(lyr)],
param_val_dict['adep_{}'.format(lyr)],
temp_val_dict['trap_revised'],
temp_val_dict['awwt_{}'.format(lyr)], temp_val_dict['tot2']]],
remove_transpiration('avinj'),
temp_val_dict['avinj_{}'.format(lyr)], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['asmos_interim_{}'.format(lyr)],
pp_reg['awilt_{}_path'.format(lyr)],
param_val_dict['adep_{}'.format(lyr)],
temp_val_dict['trap_revised'],
temp_val_dict['awwt_{}'.format(lyr)], temp_val_dict['tot2']]],
remove_transpiration('asmos'), sv_reg['asmos_{}_path'.format(lyr)],
gdal.GDT_Float32, _TARGET_NODATA)
# no transpiration is removed from layers not accessible by plants
for lyr in range(nlaypg_max + 1, nlayer_max + 1):
shutil.copyfile(
temp_val_dict['asmos_interim_{}'.format(lyr)],
sv_reg['asmos_{}_path'.format(lyr)])
# relative water content of soil layer 1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['asmos_1_path'], param_val_dict['adep_1'],
pp_reg['awilt_1_path'], pp_reg['afiel_1_path']]],
calc_relative_water_content_lyr_1, temp_val_dict['rwcf_1'],
gdal.GDT_Float32, _TARGET_NODATA)
# evaporation from soil layer 1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['rwcf_1'], temp_val_dict['pevp'],
temp_val_dict['absevap'], sv_reg['asmos_1_path'],
pp_reg['awilt_1_path'], param_val_dict['adep_1']]],
calc_evaporation_loss, temp_val_dict['evlos'],
gdal.GDT_Float32, _TARGET_NODATA)
# remove evaporation from total moisture in soil layer 1
shutil.copyfile(sv_reg['asmos_1_path'], temp_val_dict['asmos_interim_1'])
raster_difference(
temp_val_dict['asmos_interim_1'], _TARGET_NODATA,
temp_val_dict['evlos'], _TARGET_NODATA, sv_reg['asmos_1_path'],
_TARGET_NODATA)
# remove evaporation from moisture available to plants in soil layer 1
shutil.copyfile(temp_val_dict['avinj_1'], temp_val_dict['avinj_interim_1'])
raster_difference(
temp_val_dict['avinj_interim_1'], _TARGET_NODATA,
temp_val_dict['evlos'], _TARGET_NODATA, temp_val_dict['avinj_1'],
_TARGET_NODATA)
# calculate avh2o_1, soil water available for growth, for each PFT
for pft_i in pft_id_set:
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
soil_layers_accessible = [
temp_val_dict['avinj_{}'.format(lyr)] for lyr in
range(1, int(veg_trait_table[pft_i]['nlaypg']) + 1)]
raster_list_sum(
soil_layers_accessible, _TARGET_NODATA,
temp_val_dict['sum_avinj_{}'.format(pft_i)],
_TARGET_NODATA, nodata_remove=True)
raster_multiplication(
temp_val_dict['sum_avinj_{}'.format(pft_i)], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
sv_reg['avh2o_1_{}_path'.format(pft_i)], _SV_NODATA)
# calculate avh2o_3, moisture in top two soil layers
soil_layers_to_sum = [
temp_val_dict['avinj_{}'.format(lyr)] for lyr in [1, 2]]
raster_list_sum(
soil_layers_to_sum, _TARGET_NODATA, sv_reg['avh2o_3_path'],
_SV_NODATA, nodata_remove=False)
# set correct nodata value for all revised asmos rasters
for lyr in range(1, nlayer_max + 1):
reclassify_nodata(sv_reg['asmos_{}_path'.format(lyr)], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_anerb(rprpet, pevap, drain, aneref_1, aneref_2, aneref_3):
"""Calculate the effect of soil anaerobic conditions on decomposition.
The impact of soil anaerobic conditions on decomposition is calculated from
soil moisture and reference evapotranspiration. Anerob.f.
Parameters:
rprpet (numpy.ndarray): derived, ratio of precipitation or snowmelt to
reference evapotranspiration
pevap (numpy.ndarray): derived, reference evapotranspiration
drain (numpy.ndarray): parameter, the fraction of excess water lost by
drainage. Indicates whether a soil is sensitive for anaerobiosis
(drain = 0) or not (drain = 1)
aneref_1 (numpy.ndarray): parameter, value of rprpet below which there
is no negative impact of soil anaerobic conditions on decomposition
aneref_2 (numpy.ndarray): parameter, value of rprpet above which there
is maximum negative impact of soil anaerobic conditions on
decomposition
aneref_3 (numpy.ndarray): parameter, minimum value of the impact of
soil anaerobic conditions on decomposition
Returns:
anerb, the effect of soil anaerobic conditions on decomposition
"""
valid_mask = (
(rprpet != _TARGET_NODATA) &
(pevap != _TARGET_NODATA) &
(drain != _IC_NODATA) &
(aneref_1 != _IC_NODATA) &
(aneref_2 != _IC_NODATA) &
(aneref_3 != _IC_NODATA))
xh2o = numpy.empty(rprpet.shape, dtype=numpy.float32)
xh2o[:] = _TARGET_NODATA
xh2o[valid_mask] = (
(rprpet[valid_mask] - aneref_1[valid_mask]) * pevap[valid_mask] *
(1. - drain[valid_mask]))
anerb = numpy.empty(rprpet.shape, dtype=numpy.float32)
anerb[:] = _TARGET_NODATA
anerb[valid_mask] = 1.
high_rprpet_mask = (valid_mask & (rprpet > aneref_1) & (xh2o > 0))
anerb[high_rprpet_mask] = numpy.maximum(
1. + (1. - aneref_3[high_rprpet_mask]) /
(aneref_1[high_rprpet_mask] - aneref_2[high_rprpet_mask]) *
(aneref_1[high_rprpet_mask] +
(xh2o[high_rprpet_mask] / pevap[high_rprpet_mask]) -
aneref_1[high_rprpet_mask]),
aneref_3[high_rprpet_mask])
return anerb
def esched(return_type):
"""Calculate flow of an element accompanying decomposition of C.
Calculate the movement of one element (N or P) as C decomposes from one
state variable (the donating stock, or box A) to another state variable
(the receiving stock, or box B). Esched.f
Parameters:
return_type (string): flag indicating whether to return material
leaving box A, material arriving in box B, or material flowing
into or out of the mineral pool
Returns:
the function `_esched`
"""
def _esched(cflow, tca, rcetob, anps, labile):
"""Calculate the flow of one element (iel) to accompany decomp of C.
This is a transcription of Esched.f: "Schedule N, P, or S flow and
associated mineralization or immobilization flow for decomposition
from Box A to Box B."
If there is enough of iel (N or P) in the donating stock to satisfy
the required ratio, that material flows from the donating stock to
the receiving stock and whatever iel is leftover goes to mineral
pool. If there is not enough iel to satisfy the required ratio, iel
is drawn from the mineral pool to satisfy the ratio; if there is
not enough iel in the mineral pool, the material does not leave the
donating stock.
Parameters:
cflow (numpy.ndarray): derived, total C that is decomposing from
box A to box B
tca (numpy.ndarray): state variable, C in donating stock, i.e.
box A
rcetob (numpy.ndarray): derived, required ratio of C/iel in the
receiving stock
anps (numpy.ndarray): state variable, iel (N or P) in the donating
stock
labile (numpy.ndarray): state variable, mineral iel (N or P)
Returns:
material_leaving_a, the amount of material leaving box A, if
return_type is 'material_leaving_a'
material_arriving_b, the amount of material arriving in box B,
if return_type is 'material_arriving_b'
mnrflo, flow to or from mineral pool, if return_type is
'mineral_flow'
"""
valid_mask = (
(cflow != _IC_NODATA) &
(~numpy.isclose(tca, _SV_NODATA)) &
(tca > 0) &
(rcetob != _TARGET_NODATA) &
(~numpy.isclose(anps, _SV_NODATA)) &
(~numpy.isclose(labile, _SV_NODATA)))
outofa = numpy.empty(cflow.shape, dtype=numpy.float32)
outofa[:] = _IC_NODATA
outofa[valid_mask] = (
anps[valid_mask] * (cflow[valid_mask] / tca[valid_mask]))
immobil_ratio = numpy.zeros(cflow.shape)
nonzero_mask = ((outofa > 0) & valid_mask)
immobil_ratio[nonzero_mask] = (
cflow[nonzero_mask] / outofa[nonzero_mask])
immflo = numpy.zeros(cflow.shape)
immflo[valid_mask] = (
cflow[valid_mask] / rcetob[valid_mask] - outofa[valid_mask])
labile_supply = numpy.zeros(cflow.shape)
labile_supply[valid_mask] = labile[valid_mask] - immflo[valid_mask]
atob = numpy.zeros(cflow.shape)
atob[valid_mask] = cflow[valid_mask] / rcetob[valid_mask]
# immobilization
immobilization_mask = (
(immobil_ratio > rcetob) &
(labile_supply > 0) &
valid_mask)
# mineralization
mineralization_mask = (
(immobil_ratio <= rcetob) &
valid_mask)
# no movement
no_movt_mask = (
(immobil_ratio > rcetob) &
(labile_supply <= 0) &
valid_mask)
material_leaving_a = numpy.empty(cflow.shape, dtype=numpy.float32)
material_leaving_a[:] = _IC_NODATA
material_arriving_b = numpy.empty(cflow.shape, dtype=numpy.float32)
material_arriving_b[:] = _IC_NODATA
mnrflo = numpy.empty(cflow.shape, dtype=numpy.float32)
mnrflo[:] = _IC_NODATA
material_leaving_a[immobilization_mask] = (
outofa[immobilization_mask])
material_arriving_b[immobilization_mask] = (
outofa[immobilization_mask] + immflo[immobilization_mask])
mnrflo[immobilization_mask] = -immflo[immobilization_mask]
material_leaving_a[mineralization_mask] = outofa[mineralization_mask]
material_arriving_b[mineralization_mask] = atob[mineralization_mask]
mnrflo[mineralization_mask] = (
outofa[mineralization_mask] - atob[mineralization_mask])
material_leaving_a[no_movt_mask] = 0.
material_arriving_b[no_movt_mask] = 0.
mnrflo[no_movt_mask] = 0.
if return_type == 'material_leaving_a':
return material_leaving_a
elif return_type == 'material_arriving_b':
return material_arriving_b
elif return_type == 'mineral_flow':
return mnrflo
return _esched
def fsfunc(minerl_1_2, sorpmx, pslsrb):
"""Calculate the fraction of mineral P that is in solution.
The fraction of P in solution is influenced by two soil properties:
the maximum sorption potential of the soil and sorption affinity.
Parameters:
minerl_1_2 (numpy.ndarray): state variable, mineral P in top layer
sorpmx (numpy.ndarray): parameter, maximum P sorption potential
pslsrb (numpy.ndarray): parameter, slope term which controls the
fraction of mineral P that is labile
Returns:
fsol, fraction of P in solution
"""
valid_mask = (
(~numpy.isclose(minerl_1_2, _SV_NODATA)) &
(minerl_1_2 > 0) &
(sorpmx != _IC_NODATA) &
(pslsrb != _IC_NODATA))
c_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
c_ar[valid_mask] = (
sorpmx[valid_mask] * (2.0 - pslsrb[valid_mask]) / 2.)
b_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
b_ar[valid_mask] = (
sorpmx[valid_mask] - minerl_1_2[valid_mask] + c_ar[valid_mask])
sq_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
sq_ar[valid_mask] = (
b_ar[valid_mask] * b_ar[valid_mask] + 4. * c_ar[valid_mask] *
minerl_1_2[valid_mask])
sqrt_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
sqrt_ar[valid_mask] = numpy.sqrt(sq_ar[valid_mask])
labile = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
labile[valid_mask] = (-b_ar[valid_mask] + sqrt_ar[valid_mask]) / 2.
fsol = numpy.empty(minerl_1_2.shape, dtype=numpy.float32)
fsol[:] = _TARGET_NODATA
fsol[valid_mask] = labile[valid_mask] / minerl_1_2[valid_mask]
return fsol
def calc_surface_som2_ratio(
som1c_1, som1e_1_iel, rad1p_1_iel, rad1p_2_iel, rad1p_3_iel,
pcemic1_2_iel):
"""Calculate the required C/iel ratio for material entering surface SOM2.
The C/iel ratio of material decomposing from surface SOM1 into surface SOM2
fluctuates with each decomposition time step according to the current C/iel
content of SOM1.
Parameters:
som1c_1 (numpy.ndarray): state variable, C in surface SOM1
som1e_1_iel (numpy.ndarray): state variable, iel in surface SOM1
rad1p_1_iel (numpy.ndarray): parameter, intercept term
rad1p_2_iel (numpy.ndarray): parameter, slope term
rad1p_3_iel (numpy.ndarray): parameter, minimum allowable C/iel for
addition term
pcemic1_2_iel (numpy.ndarray): parameter, minimum C/iel ratio
Returns:
rceto2_surface, required C/iel ratio of material entering surface SOM2
"""
valid_mask = (
(~numpy.isclose(som1c_1, _SV_NODATA)) &
(~numpy.isclose(som1e_1_iel, _SV_NODATA)) &
(som1e_1_iel > 0) &
(rad1p_1_iel != _IC_NODATA) &
(rad1p_2_iel != _IC_NODATA) &
(pcemic1_2_iel != _IC_NODATA) &
(rad1p_3_iel != _IC_NODATA))
radds1 = numpy.empty(som1c_1.shape, dtype=numpy.float32)
radds1[:] = _TARGET_NODATA
radds1[valid_mask] = (
rad1p_1_iel[valid_mask] + rad1p_2_iel[valid_mask] *
((som1c_1[valid_mask] / som1e_1_iel[valid_mask]) -
pcemic1_2_iel[valid_mask]))
rceto2_surface = numpy.empty(som1c_1.shape, dtype=numpy.float32)
rceto2_surface[:] = _TARGET_NODATA
rceto2_surface[valid_mask] = numpy.maximum(
(som1c_1[valid_mask] / som1e_1_iel[valid_mask] + radds1[valid_mask]),
rad1p_3_iel[valid_mask])
return rceto2_surface
def calc_tcflow_strucc_1(
aminrl_1, aminrl_2, strucc_1, struce_1_1, struce_1_2, rnewas_1_1,
rnewas_2_1, strmax_1, defac, dec1_1, pligst_1, strlig_1, pheff_struc):
"""Calculate total flow out of surface structural C.
The total potential flow of C out of surface structural material is
calculated according to its lignin content, the decomposition factor, and
soil pH. The actual flow is limited by the availability of N and P. N and P
may be supplied by the mineral source, or by the element (N or P) in the
decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average surface mineral N
aminrl_2 (numpy.ndarray): derived, average surface mineral P
strucc_1 (numpy.ndarray): state variable, surface structural C
struce_1_1 (numpy.ndarray): state variable, surface structural N
struce_1_2 (numpy.ndarray): state variable, surface structural P
rnewas_1_1 (numpy.ndarray): derived, required C/N ratio for
aboveground material decomposing to SOM1
rnewas_2_1 (numpy.ndarray): derived, required C/P ratio for
aboveground material decomposing to SOM1
strmax_1 (numpy.ndarray): parameter, maximum decomposition amount
defac (numpy.ndarray): derived, decomposition factor
dec1_1 (numpy.ndarray): parameter, maximum decomposition rate
pligst_1 (numpy.ndarray): parameter, effect of lignin content on
decomposition rate
strlig_1 (numpy.ndarray): state variable, lignin content of decomposing
material
pheff_struc (numpy.ndarray): derived, effect of soil pH on
decomposition rate
Returns:
tcflow_strucc_1, total flow of C out of surface structural
material
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(~numpy.isclose(struce_1_1, _SV_NODATA)) &
(~numpy.isclose(struce_1_2, _SV_NODATA)) &
(rnewas_1_1 != _TARGET_NODATA) &
(rnewas_2_1 != _TARGET_NODATA) &
(strmax_1 != _IC_NODATA) &
(defac != _TARGET_NODATA) &
(dec1_1 != _IC_NODATA) &
(pligst_1 != _IC_NODATA) &
(~numpy.isclose(strlig_1, _SV_NODATA)) &
(pheff_struc != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(strucc_1[valid_mask], strmax_1[valid_mask]) *
defac[valid_mask] * dec1_1[valid_mask] *
numpy.exp(-pligst_1[valid_mask] * strlig_1[valid_mask]) * 0.020833 *
pheff_struc[valid_mask])
decompose_mask = (
((aminrl_1 > 0.0000001) | ((strucc_1 / struce_1_1) <= rnewas_1_1)) &
((aminrl_2 > 0.0000001) | ((strucc_1 / struce_1_2) <= rnewas_2_1)) &
valid_mask)
tcflow_strucc_1 = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_strucc_1[:] = _IC_NODATA
tcflow_strucc_1[valid_mask] = 0.
tcflow_strucc_1[decompose_mask] = potential_flow[decompose_mask]
return tcflow_strucc_1
def calc_tcflow_strucc_2(
aminrl_1, aminrl_2, strucc_2, struce_2_1, struce_2_2, rnewbs_1_1,
rnewbs_2_1, strmax_2, defac, dec1_2, pligst_2, strlig_2, pheff_struc,
anerb):
"""Calculate total flow out of soil structural C.
The total potential flow of C out of soil structural material is
calculated according to its lignin content, the decomposition factor, and
soil pH. The actual flow is limited by the availability of N and P. N and P
may be supplied by the mineral source, or by the element (N or P) in the
decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average soil mineral N
aminrl_2 (numpy.ndarray): derived, average soil mineral P
strucc_2 (numpy.ndarray): state variable, soil structural C
struce_2_1 (numpy.ndarray): state variable, soil structural N
struce_2_2 (numpy.ndarray): state variable, soil structural P
rnewbs_1_1 (numpy.ndarray): derived, required C/N ratio for
belowground material decomposing to SOM1
rnewbs_2_1 (numpy.ndarray): derived, required C/P ratio for
belowground material decomposing to SOM1
strmax_2 (numpy.ndarray): parameter, maximum decomposition amount
defac (numpy.ndarray): derived, decomposition factor
dec1_2 (numpy.ndarray): parameter, maximum decomposition rate
pligst_2 (numpy.ndarray): parameter, effect of lignin content on
decomposition rate
strlig_2 (numpy.ndarray): state variable, lignin content of decomposing
material
pheff_struc (numpy.ndarray): derived, effect of soil pH on
decomposition rate
anerb (numpy.ndarray): derived, effect of soil anaerobic conditions on
decomposition rate
Returns:
tcflow_strucc_2, total flow of C out of soil structural
material
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(strucc_2, _SV_NODATA)) &
(~numpy.isclose(struce_2_1, _SV_NODATA)) &
(~numpy.isclose(struce_2_2, _SV_NODATA)) &
(rnewbs_1_1 != _TARGET_NODATA) &
(rnewbs_2_1 != _TARGET_NODATA) &
(strmax_2 != _IC_NODATA) &
(defac != _TARGET_NODATA) &
(dec1_2 != _IC_NODATA) &
(pligst_2 != _IC_NODATA) &
(~numpy.isclose(strlig_2, _SV_NODATA)) &
(pheff_struc != _TARGET_NODATA) &
(anerb != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(strucc_2[valid_mask], strmax_2[valid_mask]) *
defac[valid_mask] * dec1_2[valid_mask] *
numpy.exp(-pligst_2[valid_mask] * strlig_2[valid_mask]) * 0.020833 *
pheff_struc[valid_mask] * anerb[valid_mask])
decompose_mask = (
((aminrl_1 > 0.0000001) | ((strucc_2 / struce_2_1) <= rnewbs_1_1)) &
((aminrl_2 > 0.0000001) | ((strucc_2 / struce_2_2) <= rnewbs_2_1)) &
valid_mask)
tcflow_strucc_2 = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_strucc_2[:] = _IC_NODATA
tcflow_strucc_2[valid_mask] = 0.
tcflow_strucc_2[decompose_mask] = potential_flow[decompose_mask]
return tcflow_strucc_2
def calc_tcflow_surface(
aminrl_1, aminrl_2, cstatv, estatv_1, estatv_2, rcetob_1, rcetob_2,
defac, dec_param, pheff):
"""Calculate total flow of C out of a surface pool.
The total potential flow of C out of a surface pool is calculated according
to the decomposition factor and soil pH. The actual flow is limited by the
availability of N and P. N and P may be supplied by the mineral source, or
by the element (N or P) in the decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average surface mineral N
aminrl_2 (numpy.ndarray): derived, average surface mineral P
cstatv (numpy.ndarray): state variable, C in decomposing pool
estatv_1 (numpy.ndarray): state variable, N in decomposing pool
estatv_2 (numpy.ndarray): state variable, P in decomposing pool
rcetob_1 (numpy.ndarray): derived, required C/N ratio for
material entering the receiving pool
rcetob_2 (numpy.ndarray): derived, required C/P ratio for
material entering the receiving pool
defac (numpy.ndarray): derived, decomposition factor
dec_param (numpy.ndarray): parameter, maximum decomposition rate
pheff (numpy.ndarray): derived, effect of soil pH on
decomposition rate
Returns:
tcflow, total flow of C out of the decomposing pool
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(estatv_1, _SV_NODATA)) &
(~numpy.isclose(estatv_2, _SV_NODATA)) &
(rcetob_1 != _TARGET_NODATA) &
(rcetob_2 != _TARGET_NODATA) &
(defac != _TARGET_NODATA) &
(dec_param != _IC_NODATA) &
(pheff != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(
cstatv[valid_mask] * defac[valid_mask] * dec_param[valid_mask] *
0.020833 * pheff[valid_mask], cstatv[valid_mask]))
decompose_mask = (
((aminrl_1 > 0.0000001) | ((cstatv / estatv_1) <= rcetob_1)) &
((aminrl_2 > 0.0000001) | ((cstatv / estatv_2) <= rcetob_2)) &
valid_mask)
tcflow = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow[:] = _IC_NODATA
tcflow[valid_mask] = 0.
tcflow[decompose_mask] = potential_flow[decompose_mask]
return tcflow
def calc_tcflow_soil(
aminrl_1, aminrl_2, cstatv, estatv_1, estatv_2, rcetob_1,
rcetob_2, defac, dec_param, pheff, anerb):
"""Calculate total flow out of soil metabolic C.
The total potential flow of C out of soil metabolic material is
calculated according to the decomposition factor, soil pH, and soil
anaerobic conditions. The actual flow is limited by the availability of N
and P. N and P may be supplied by the mineral source, or by the element
(N or P) in the decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average soil mineral N
aminrl_2 (numpy.ndarray): derived, average soil mineral P
cstatv (numpy.ndarray): state variable, C in decomposing stock
estatv_1 (numpy.ndarray): state variable, N in decomposing stock
estatv_2 (numpy.ndarray): state variable, P in decomposing stock
rcetob_1 (numpy.ndarray): derived, required C/N ratio for
material entering receiving stock
rceto1_2 (numpy.ndarray): derived, required C/P ratio for
material entering receiving stock
defac (numpy.ndarray): derived, decomposition factor
dec_param (numpy.ndarray): parameter, maximum decomposition rate
pheff (numpy.ndarray): derived, effect of soil pH on
decomposition rate
anerb (numpy.ndarray): derived, effect of soil anaerobic
conditions on decomposition rate
Returns:
tcflow_soil, total flow of C out of soil metabolic
material
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(estatv_1, _SV_NODATA)) &
(~numpy.isclose(estatv_2, _SV_NODATA)) &
(rcetob_1 != _TARGET_NODATA) &
(rcetob_2 != _TARGET_NODATA) &
(defac != _TARGET_NODATA) &
(dec_param != _IC_NODATA) &
(pheff != _TARGET_NODATA) &
(anerb != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(
cstatv[valid_mask] * defac[valid_mask] * dec_param[valid_mask] *
0.020833 * pheff[valid_mask] * anerb[valid_mask],
cstatv[valid_mask]))
decompose_mask = (
((aminrl_1 > 0.0000001) | ((cstatv / estatv_1) <= rcetob_1)) &
((aminrl_2 > 0.0000001) | ((cstatv / estatv_2) <= rcetob_2)) &
valid_mask)
tcflow_soil = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_soil[:] = _IC_NODATA
tcflow_soil[valid_mask] = 0.
tcflow_soil[decompose_mask] = potential_flow[decompose_mask]
return tcflow_soil
def calc_tcflow_som1c_2(
aminrl_1, aminrl_2, som1c_2, som1e_2_1, som1e_2_2, rceto2_1,
rceto2_2, defac, dec3_2, eftext, anerb, pheff_metab):
"""Calculate total flow out of soil SOM1.
The total potential flow of C out of soil SOM1 is calculated
according to the effect of soil texture, anaerobic conditions,
and soil pH. The actual flow is limited by the availability of N
and P. N and P may be supplied by the mineral source, or by the
element (N or P) in the decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average surface mineral N
aminrl_2 (numpy.ndarray): derived, average surface mineral P
som1c_2 (numpy.ndarray): state variable, C in soil SOM1
som1e_2_1 (numpy.ndarray): state variable, N in soil SOM1
som1e_2_2 (numpy.ndarray): state variable, P in soil SOM1
rceto2_1 (numpy.ndarray): derived, required C/N ratio for
material decomposing to soil SOM2
rceto2_2 (numpy.ndarray): derived, required C/P ratio for
material decomposing to soil SOM2
defac (numpy.ndarray): derived, decomposition factor
dec3_2 (numpy.ndarray): parameter, maximum decomposition rate
eftext (numpy.ndarray): derived, effect of soil texture on
decomposition rate
anerb (numpy.ndarray): derived, effect of soil anaerobic conditions
on decomposition rate
pheff_metab (numpy.ndarray): derived, effect of soil pH on
decomposition rate
Returns:
tcflow_som1c_2, total flow of C out of soil SOM1
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som1e_2_1, _SV_NODATA)) &
(~numpy.isclose(som1e_2_2, _SV_NODATA)) &
(rceto2_1 != _TARGET_NODATA) &
(rceto2_2 != _TARGET_NODATA) &
(defac != _TARGET_NODATA) &
(dec3_2 != _IC_NODATA) &
(eftext != _TARGET_NODATA) &
(anerb != _TARGET_NODATA) &
(pheff_metab != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
som1c_2[valid_mask] * defac[valid_mask] * dec3_2[valid_mask] *
eftext[valid_mask] * anerb[valid_mask] * 0.020833 *
pheff_metab[valid_mask])
decompose_mask = (
((aminrl_1 > 0.0000001) | ((som1c_2 / som1e_2_1) <= rceto2_1)) &
((aminrl_2 > 0.0000001) | ((som1c_2 / som1e_2_2) <= rceto2_2)) &
valid_mask)
tcflow_som1c_2 = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_som1c_2[:] = _IC_NODATA
tcflow_som1c_2[valid_mask] = 0.
tcflow_som1c_2[decompose_mask] = potential_flow[decompose_mask]
return tcflow_som1c_2
def calc_som3_flow(tcflow, fps, animpt, anerb):
"""Calculate the C that flows from soil SOM1 or SOM2 to SOM3.
The fraction of total flow leaving SOM1 or SOM2 that goes to SOM3 is
dependent on soil clay content and soil anaerobic conditions.
Parameters:
tcflow (numpy.ndarray): derived, total C leaving soil SOM1 or SOM2
fps (numpy.ndarray): derived, effect of soil clay content on
decomposition to SOM3
animpt (numpy.ndarray): parameter, slope of relationship between
anaerobic conditions and decomposition flow to SOM3
anerb (numpy.ndarray): derived, impact of soil anaerobic conditions
on decomposition
Returns:
tosom3, C flowing to SOM3
"""
valid_mask = (
(tcflow != _IC_NODATA) &
(fps != _IC_NODATA) &
(animpt != _IC_NODATA) &
(anerb != _TARGET_NODATA))
tosom3 = numpy.empty(tcflow.shape, dtype=numpy.float32)
tosom3[:] = _IC_NODATA
tosom3[valid_mask] = (
tcflow[valid_mask] * fps[valid_mask] *
(1. + animpt[valid_mask] * (1. - anerb[valid_mask])))
return tosom3
def calc_som2_flow(som2c_1, cmix, defac):
"""Calculate the C that flows from surface SOM2 to soil SOM2.
Some C flows from surface SOM2 to soil SOM2 via mixing. This flow is
controlled by the parameter cmix.
Parameters:
som2c_1 (numpy.ndarray): state variable, C in surface SOM2
cmix (numpy.ndarray): parameter, amount of C flowing via mixing
defac (numpy.ndarray): derived, decomposition factor
Returns:
tcflow, C flowing to soil SOM2 via mixing
"""
valid_mask = (
(~numpy.isclose(som2c_1, _SV_NODATA)) &
(cmix != _IC_NODATA) &
(defac != _TARGET_NODATA))
tcflow = numpy.empty(som2c_1.shape, dtype=numpy.float32)
tcflow[:] = _IC_NODATA
tcflow[valid_mask] = (
som2c_1[valid_mask] * cmix[valid_mask] * defac[valid_mask] *
0.020833)
return tcflow
def calc_respiration_mineral_flow(cflow, frac_co2, estatv, cstatv):
"""Calculate mineral flow of one element associated with respiration.
As material decomposes from one stock to another, some CO2 is lost
to microbial respiration and some nutrient (N or P) moves to the
mineral pool. Respir.f
Parameters:
cflow (numpy.ndarray): derived, C decomposing from one stock
to another
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
estatv (numpy.ndarray): state variable, iel (N or P) in the
decomposing stock
cstatv (numpy.ndarray): state variable, C in the decomposing
stock
Returns:
mineral_flow, flow of iel (N or P) accompanying respiration
"""
valid_mask = (
(cflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA) &
(~numpy.isclose(estatv, _SV_NODATA)) &
(~numpy.isclose(cstatv, _SV_NODATA)))
co2_loss = numpy.zeros(cflow.shape, dtype=numpy.float32)
co2_loss[valid_mask] = cflow[valid_mask] * frac_co2[valid_mask]
mineral_flow = numpy.empty(cflow.shape, dtype=numpy.float32)
mineral_flow[:] = _IC_NODATA
mineral_flow[valid_mask] = 0.
flow_mask = ((cstatv > 0) & valid_mask)
mineral_flow[flow_mask] = (
co2_loss[flow_mask] * estatv[flow_mask] / cstatv[flow_mask])
return mineral_flow
def update_gross_mineralization(gross_mineralization, mineral_flow):
"""Update gross N mineralization with current mineral flow.
Gross mineralization of N during decomposition is used to calculate
volatilization loss of N after decomposition. It is updated with N
mineral flow if mineral flow is positive.
Parameters:
gross_mineralization (numpy.ndarray): gross N mineralization during
decomposition
mineral_flow (numpy.ndarray): N mineral flow
Returns:
gromin_updated, updated gross mineralization
"""
valid_mask = (
(gross_mineralization != _TARGET_NODATA) &
(mineral_flow != _IC_NODATA))
gromin_updated = numpy.empty(
gross_mineralization.shape, dtype=numpy.float32)
gromin_updated[:] = _TARGET_NODATA
gromin_updated[valid_mask] = gross_mineralization[valid_mask]
update_mask = ((mineral_flow > 0) & valid_mask)
gromin_updated[update_mask] = (
gross_mineralization[update_mask] + mineral_flow[update_mask])
return gromin_updated
def calc_net_cflow(cflow, frac_co2):
"""Calculate net flow of C after loss to CO2.
As material decomposes from one stock to another, some C is lost to
CO2 through microbial respiration. Calculate the net flow of C after
subtracting losses to CO2.
Parameters:
cflow (numpy.ndarray): derived, C decomposing from one stock
to another
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
Returns:
net_cflow, amount of decomposing C that flows after accounting
for CO2 losses
"""
valid_mask = (
(cflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA))
co2_loss = numpy.zeros(cflow.shape, dtype=numpy.float32)
co2_loss[valid_mask] = cflow[valid_mask] * frac_co2[valid_mask]
net_cflow = numpy.empty(cflow.shape, dtype=numpy.float32)
net_cflow[:] = _IC_NODATA
net_cflow[valid_mask] = cflow[valid_mask] - co2_loss[valid_mask]
return net_cflow
def calc_net_cflow_tosom2(tcflow, frac_co2, tosom3, cleach):
"""Calculate net flow of C from soil SOM1 to soil SOM2.
The C flowing from soil SOM1 to SOM2 is the remainder of total flow
from SOM1, after accounting for losses to CO2 through respiration,
decomposition to SOM3, and leaching.
Parameters:
tcflow (numpy.ndarray): derived, total C decomposing from soil
SOM1
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
tosom3 (numpy.ndarray): derived, C flowing from SOM1 to SOM3
cleach (numpy.ndarray): derived, leached organic C
Returns:
net_tosom2, amount of C that flows from soil SOM1 to soil SOm2
"""
valid_mask = (
(tcflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA) &
(tosom3 != _IC_NODATA) &
(cleach != _TARGET_NODATA))
net_tosom2 = numpy.empty(tcflow.shape, dtype=numpy.float32)
net_tosom2[:] = _IC_NODATA
net_tosom2[valid_mask] = (
tcflow[valid_mask] - (tcflow[valid_mask] * frac_co2[valid_mask]) -
tosom3[valid_mask] - cleach[valid_mask])
return net_tosom2
def calc_net_cflow_tosom1(tcflow, frac_co2, tosom3):
"""Calculate net flow of C from soil SOM2 to soil SOM1.
The C flowing from soil SOM2 to SOM1 is the remainder of total flow
from SOM2, after accounting for losses to CO2 through respiration
and decomposition to SOM3.
Parameters:
tcflow (numpy.ndarray): derived, total C decomposing from soil
SOM1
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
tosom3 (numpy.ndarray): derived, C flowing from SOM1 to SOM3
Returns:
net_tosom1, amount of C that flows from soil SOM2 to soil SOM1
"""
valid_mask = (
(tcflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA) &
(tosom3 != _IC_NODATA))
net_tosom1 = numpy.empty(tcflow.shape, dtype=numpy.float32)
net_tosom1[:] = _IC_NODATA
net_tosom1[valid_mask] = (
tcflow[valid_mask] - (tcflow[valid_mask] * frac_co2[valid_mask]) -
tosom3[valid_mask])
return net_tosom1
def respiration(
tcflow_path, frac_co2_path, cstatv_path, estatv_path,
delta_estatv_path, delta_minerl_1_iel_path, gromin_1_path=None):
"""Calculate and apply flow of N or P during respiration.
Microbial respiration accompanies decomposition of most stocks.
Calculate the flow of one element (N or P) to the mineral pool, which
accompanies this respiration.
Parameters:
tcflow_path (string): path to raster containing flow of C that
is accompanied by respiration
frac_co2_path (string): path to raster containing fraction of
C lost to co2
cstatv_path (string): path to raster containing C state variable
of decomposing pool
estatv_path (string): path to raster containing iel (N or P) state
variable of decomposing pool
delta_estatv_path (string): path to raster containing change
in the iel state variable of decomposing pool
delta_minerl_1_iel_path (string): path to raster containing
change in surface mineral iel
gromin_1_path (string): path to raster containing gross
mineralization of N
Side effects:
modifies or creates the raster indicated by `delta_estatv_path`
modifies or creates the raster indicated by `delta_minerl_1_iel_path`
modifies or creates the raster indicated by `gromin_1_path`, if
supplied
Returns:
None
"""
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='d_statv_temp', dir=PROCESSING_DIR) as d_statv_temp_file:
d_statv_temp_path = d_statv_temp_file.name
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tcflow_path, frac_co2_path, estatv_path,
cstatv_path]],
calc_respiration_mineral_flow, operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
# mineral flow is removed from the decomposing iel state variable
shutil.copyfile(delta_estatv_path, d_statv_temp_path)
raster_difference(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
delta_estatv_path, _IC_NODATA)
# mineral flow is added to surface mineral iel
shutil.copyfile(delta_minerl_1_iel_path, d_statv_temp_path)
raster_sum(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
delta_minerl_1_iel_path, _IC_NODATA)
if gromin_1_path:
shutil.copyfile(gromin_1_path, d_statv_temp_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
d_statv_temp_path,
operand_temp_path]],
update_gross_mineralization, gromin_1_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up
os.remove(operand_temp_path)
os.remove(d_statv_temp_path)
def nutrient_flow(
cflow_path, cstatv_donating_path, estatv_donating_path, rcetob_path,
minerl_1_path, d_estatv_donating_path, d_estatv_receiving_path,
d_minerl_path, gromin_path=None):
"""Calculate and apply the flow of one nutrient accompanying C.
As C decomposes from one compartment to another, nutrients (N and P)
also flow from the donating compartment to the receiving compartment.
Some N or P may also flow to or from the mineral pool. Calculate and
apply the flow of iel (N or P) accompanying the given flow of C.
Parameters:
cflow_path (string): path to raster containing the flow of C
from the donating to the receiving pool
cstatv_donating_path (string): path to raster containing the C
state variable in the donating pool
estatv_donating_path (string): path to raster containing the iel
(N or P) in the donating pool
rcetob_path (string): path to raster containing required C/iel
ratio in the receiving pool
minerl_1_path (string): path to raster containing surface mineral iel
d_estatv_donating_path (string): path to raster containing change
in iel in the donating pool
d_estatv_receiving_path (string): path to raster containing change
in iel in the receiving pool
d_minerl_path (string): path to raster containing change in surface
mineral iel
gromin_path (string): path to raster containing gross mineralization
of N
Side effects:
modifies or creates the raster indicated by `d_estatv_donating_path`
modifies or creates the raster indicated by `d_estatv_receiving_path`
modifies or creates the raster indicated by `d_minerl_path`
modifies or creates the raster indicated by `gromin_path`, if supplied
Returns:
None
"""
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='d_statv_temp', dir=PROCESSING_DIR) as d_statv_temp_file:
d_statv_temp_path = d_statv_temp_file.name
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cflow_path, cstatv_donating_path, rcetob_path,
estatv_donating_path, minerl_1_path]],
esched('material_leaving_a'), operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(d_estatv_donating_path, d_statv_temp_path)
raster_difference(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
d_estatv_donating_path, _IC_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cflow_path, cstatv_donating_path, rcetob_path,
estatv_donating_path, minerl_1_path]],
esched('material_arriving_b'), operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(d_estatv_receiving_path, d_statv_temp_path)
raster_sum(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
d_estatv_receiving_path, _IC_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cflow_path, cstatv_donating_path, rcetob_path,
estatv_donating_path, minerl_1_path]],
esched('mineral_flow'), operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(d_minerl_path, d_statv_temp_path)
raster_sum(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
d_minerl_path, _IC_NODATA)
if gromin_path:
shutil.copyfile(gromin_path, d_statv_temp_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
d_statv_temp_path, operand_temp_path]],
update_gross_mineralization, gromin_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up
os.remove(operand_temp_path)
os.remove(d_statv_temp_path)
def calc_c_leach(amov_2, tcflow, omlech_3, orglch):
"""Calculate the amount of C leaching from soil SOM1 to stream flow.
Some C leaches from soil SOM1 if the water flow out of soil layer 2
is above a critical level.
Parameters:
amov_2 (numpy.ndarray): derived, moisture flowing out of soil layer
2
tcflow (numpy.ndarray): derived, total flow of C out of soil SOM1
omlech_3 (numpy.ndarray): parameter, threshold value for amov_2
orglch (numpy.ndarray): derived, effect of sand content on leaching
rate
Returns:
cleach, C leaching from soil SOM1 to stream flow
"""
valid_mask = (
(amov_2 != _TARGET_NODATA) &
(tcflow != _IC_NODATA) &
(omlech_3 != _IC_NODATA) &
(orglch != _IC_NODATA))
cleach = numpy.empty(amov_2.shape, dtype=numpy.float32)
cleach[:] = _TARGET_NODATA
cleach[valid_mask] = 0
linten = numpy.zeros(amov_2.shape)
linten[valid_mask] = numpy.minimum(
(1. - (omlech_3[valid_mask] - amov_2[valid_mask]) /
omlech_3[valid_mask]), 1.)
leach_mask = ((amov_2 > 0) & valid_mask)
cleach[leach_mask] = (
tcflow[leach_mask] * orglch[leach_mask] * linten[leach_mask])
return cleach
def remove_leached_iel(
som1c_2_path, som1e_2_iel_path, cleach_path, d_som1e_2_iel_path,
iel):
"""Remove N or P leached from soil SOM1.
As soil SOM1 decomposes into SOM3, some of N and P is lost from SOM1
through leaching. The amount lost is calculated from the amount of C
leaching from the soil and the proportion of iel (N or P) in soil SOM1.
Parameters:
som1c_2_path (string): path to raster containing C in soil SOM1
som1e_2_iel_path (string): path to raster containing iel in soil
SOM1
cleach_path (string): path to raster containing C leaching from
SOM1
d_som1e_2_iel_path (string): path to raster giving change in
som1e_2_iel
iel (int): index indicating N (iel == 1) or P (iel == 2))
Side effects:
modifies the raster indicated by `d_som1e_2_iel_path`
Returns:
None
"""
def calc_leached_N(som1c_2, som1e_2_1, cleach):
"""Calculate the N leaching from soil SOM1."""
valid_mask = (
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som1e_2_1, _SV_NODATA)) &
(som1c_2 > 0) &
(som1e_2_1 > 0) &
(cleach != _TARGET_NODATA))
rceof1_1 = numpy.zeros(som1c_2.shape)
rceof1_1[valid_mask] = som1c_2[valid_mask] / som1e_2_1[valid_mask] * 2.
orgflow = numpy.empty(som1c_2.shape, dtype=numpy.float32)
orgflow[:] = _IC_NODATA
orgflow[valid_mask] = cleach[valid_mask] / rceof1_1[valid_mask]
return orgflow
def calc_leached_P(som1c_2, som1e_2_2, cleach):
"""Calculate the P leaching from soil SOM1."""
valid_mask = (
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som1e_2_2, _SV_NODATA)) &
(som1c_2 > 0) &
(som1e_2_2 > 0) &
(cleach != _TARGET_NODATA))
rceof1_2 = numpy.zeros(som1c_2.shape)
rceof1_2[valid_mask] = (
som1c_2[valid_mask] / som1e_2_2[valid_mask] * 35.)
orgflow = numpy.empty(som1c_2.shape, dtype=numpy.float32)
orgflow[:] = _IC_NODATA
orgflow[valid_mask] = cleach[valid_mask] / rceof1_2[valid_mask]
return orgflow
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='d_statv_temp', dir=PROCESSING_DIR) as d_statv_temp_file:
d_statv_temp_path = d_statv_temp_file.name
if iel == 1:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
som1c_2_path, som1e_2_iel_path, cleach_path]],
calc_leached_N, operand_temp_path,
gdal.GDT_Float32, _TARGET_NODATA)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
som1c_2_path, som1e_2_iel_path, cleach_path]],
calc_leached_P, operand_temp_path,
gdal.GDT_Float32, _TARGET_NODATA)
# remove leached iel from SOM1
shutil.copyfile(d_som1e_2_iel_path, d_statv_temp_path)
raster_difference(
d_statv_temp_path, _IC_NODATA,
operand_temp_path, _IC_NODATA,
d_som1e_2_iel_path, _IC_NODATA)
# clean up
os.remove(operand_temp_path)
os.remove(d_statv_temp_path)
def calc_pflow(pstatv, rate_param, defac):
"""Calculate the flow of mineral P flowing from one pool to another.
Mineral P contains multiple pools, including parent material, labile P,
sorbed and strongly sorbed P, and occluded P. Calculate the flow from one
mineral P pool to another.
Parameters:
pstatv (numpy.ndarray): state variable, P in donating mineral pool
rate_param (numpy.ndarray): parameter, base rate of flow
defac (numpy.ndarray): derived, decomposition rate
Returns:
pflow, mineral P flowing from donating to receiving pool
"""
valid_mask = (
(~numpy.isclose(pstatv, _SV_NODATA)) &
(rate_param != _IC_NODATA) &
(defac != _TARGET_NODATA))
pflow = numpy.empty(pstatv.shape, dtype=numpy.float64)
pflow[:] = _IC_NODATA
pflow[valid_mask] = (
pstatv[valid_mask] * rate_param[valid_mask] * defac[valid_mask] *
0.020833)
return pflow
def calc_pflow_to_secndy(minerl_lyr_2, pmnsec_2, fsol, defac):
"""Calculate the flow of mineral to secondary P in one soil layer.
P flows from the mineral pool of each soil layer into secondary P (strongly
sorbed P) according to the amount in the mineral pool and the amount of P
in solution.
Parameters:
minerl_lyr_2 (numpy.ndarray): state variable, mineral P in soil layer
lyr
pmnsec_2 (numpy.ndarray): parameter, base flow rate
fsol (numpy.ndarray): derived, fraction of P in solution
defac (numpy.ndarray): derived, decomposition factor
Returns:
fmnsec, flow of mineral P to secondary in one soil layer
"""
valid_mask = (
(~numpy.isclose(minerl_lyr_2, _SV_NODATA)) &
(pmnsec_2 != _IC_NODATA) &
(fsol != _TARGET_NODATA) &
(defac != _TARGET_NODATA))
fmnsec = numpy.empty(minerl_lyr_2.shape, dtype=numpy.float64)
fmnsec[:] = _IC_NODATA
fmnsec[valid_mask] = (
pmnsec_2[valid_mask] * minerl_lyr_2[valid_mask] *
(1. - fsol[valid_mask]) * defac[valid_mask] * 0.020833)
return fmnsec
def update_aminrl(
minerl_1_1_path, minerl_1_2_path, fsol_path, aminrl_1_path,
aminrl_2_path):
"""Update aminrl_1 and aminrl_2, average mineral N and P in surface soil.
Aminrl_1, average mineral N, and aminrl_2, average mineral P, represent
labile N or P available for decomposition. They are kept as a running
average of the minerl_1_1 (for N) or minerl_1_2 (for P) state variable
across decomposition time steps.
Parameters:
minerl_1_1_path (string): path to raster giving current mineral N
in soil layer 1
minerl_1_2_path (string): path to raster giving current mineral N
in soil layer 2
fsol_path (string): path to raster giving fraction of mineral P in
solution
aminrl_1_path (string): path to raster containing average mineral N
aminrl_2_path (string): path to raster containing average mineral P
Side effects:
modifies or creates the raster indicated by `aminrl_1_path`
modifies or creates the raster indicated by `aminrl_2_path
Returns:
None
"""
def update_aminrl_1(aminrl_1_prev, minerl_1_1):
"""Update average mineral N."""
valid_mask = (
(~numpy.isclose(aminrl_1_prev, _SV_NODATA)) &
(~numpy.isclose(minerl_1_1, _SV_NODATA)))
aminrl_1 = numpy.empty(aminrl_1_prev.shape, dtype=numpy.float32)
aminrl_1[:] = _SV_NODATA
aminrl_1[valid_mask] = (
aminrl_1_prev[valid_mask] + minerl_1_1[valid_mask] / 2.)
return aminrl_1
def update_aminrl_2(aminrl_2_prev, minerl_1_2, fsol):
"""Update average mineral P.
Average mineral P is calculated from the fraction of mineral P in
soil layer 1 that is in solution.
Parameters:
aminrl_2_prev (numpy.ndarray): derived, previous average surface
mineral P
minerl_1_2 (numpy.ndarray): state variable, current mineral P in
soil layer 1
fsol (numpy.ndarray): derived, fraction of labile P in solution
Returns:
aminrl_2, updated average mineral P
"""
valid_mask = (
(~numpy.isclose(aminrl_2_prev, _SV_NODATA)) &
(~numpy.isclose(minerl_1_2, _SV_NODATA)) &
(fsol != _TARGET_NODATA))
aminrl_2 = numpy.empty(aminrl_2_prev.shape, dtype=numpy.float32)
aminrl_2[:] = _SV_NODATA
aminrl_2[valid_mask] = (
aminrl_2_prev[valid_mask] +
(minerl_1_2[valid_mask] * fsol[valid_mask]) / 2.)
return aminrl_2
with tempfile.NamedTemporaryFile(
prefix='aminrl_prev', dir=PROCESSING_DIR) as aminrl_prev_file:
aminrl_prev_path = aminrl_prev_file.name
shutil.copyfile(aminrl_1_path, aminrl_prev_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [aminrl_prev_path, minerl_1_1_path]],
update_aminrl_1, aminrl_1_path, gdal.GDT_Float32, _SV_NODATA)
shutil.copyfile(aminrl_2_path, aminrl_prev_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aminrl_prev_path, minerl_1_2_path, fsol_path]],
update_aminrl_2, aminrl_2_path, gdal.GDT_Float32, _SV_NODATA)
# clean up
os.remove(aminrl_prev_path)
def sum_biomass(
weighted_live_c, weighted_dead_c, strucc_1, metabc_1, elitst):
"""Calculate total biomass for the purposes of soil shading.
Total aboveground biomass for the purposes of soil shading is the sum
of live biomass, standing dead biomass, and litter. The impact of
litter is modifed by the parameter elitst.
Parameters:
weighted_live_c (numpy.ndarray): derived, sum of the state variable
aglivc across plant functional types
weighted_dead_c (numpy.ndarray): derived, sum of the state variable
stdedc across plant functional types
strucc_1 (numpy.ndarray): state variable, surface structural c
metabc_1 (numpy.ndarray): state variable, surface metabolic c
elitst (numpy.ndarray): parameter, effect of litter on soil
temperature relative to live and standing dead biomass
Returns:
biomass, total biomass for purposes of soil shading
"""
valid_mask = (
(weighted_live_c != _TARGET_NODATA) &
(weighted_dead_c != _TARGET_NODATA) &
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(~numpy.isclose(metabc_1, _SV_NODATA)) &
(elitst != _IC_NODATA))
biomass = numpy.empty(weighted_live_c.shape, dtype=numpy.float32)
biomass[:] = _TARGET_NODATA
biomass[valid_mask] = (
(weighted_live_c[valid_mask] + weighted_dead_c[valid_mask]) * 2.5 +
(strucc_1[valid_mask] + metabc_1[valid_mask]) * 2.5 *
elitst[valid_mask])
return biomass
def _decomposition(
aligned_inputs, current_month, month_index, pft_id_set,
site_param_table, year_reg, month_reg, prev_sv_reg, pp_reg, sv_reg):
"""Update soil C, N and P after decomposition.
C, N and P move from one surface or soil stock to another depending on the
availability of N and P in the decomposing stock. This function covers
lines 118-323 in Simsom.f, including decomp.f, litdec.f, somdec.f, and
pschem.f.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including precipitation, temperature, and
site spatial index
current_month (int): month of the year, such that current_month=1
indicates January
month_index (int): month of the simulation, such that month_index=13
indicates month 13 of the simulation
pft_id_set (set): set of integers identifying plant functional types
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
year_reg (dict): map of key, path pairs giving paths to annual
precipitation and annual N deposition rasters
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
pp_reg (dict): map of key, path pairs giving persistent parameters
including required ratios for decomposition, the effect of soil
texture on decomposition rate, and the effect of soil texture on
the rate of organic leaching
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
creates all rasters in sv_reg pertaining to structural, metabolic,
som1, som2, and som3 C, N, and P; mineral N and P; and parent,
secondary, and occluded mineral P
Returns:
None
"""
def calc_N_fixation(precip, annual_precip, baseNdep, epnfs_2):
"""Calculate monthly atmospheric N fixation.
Atmospheric N fixation for the month is calculated from annual N
deposition, calculated once per year, according to the ratio of monthly
precipitation to annual precipitation. Total N fixed in this month is
scheduled to be added to the surface mineral N pool. Lines 193-205,
Simsom.f
Parameters:
precip (numpy.ndarray): input, monthly precipitation
annual_precip (numpy.ndarray): derived, annual precipitation
baseNdep (numpy.ndarray): derived, annual atmospheric N deposition
epnfs_2 (numpy.ndarray): parameter, intercept of regression
predicting N deposition from annual precipitation
Returns:
wdfxm, atmospheric N deposition for the current month
"""
valid_mask = (
(~numpy.isclose(precip, precip_nodata)) &
(annual_precip != _TARGET_NODATA) &
(annual_precip > 0) &
(baseNdep != _TARGET_NODATA) &
(epnfs_2 != _IC_NODATA))
wdfxm = numpy.zeros(precip.shape, dtype=numpy.float32)
wdfxm[valid_mask] = (
baseNdep[valid_mask] *
(precip[valid_mask] / annual_precip[valid_mask]) +
epnfs_2[valid_mask] *
numpy.minimum(annual_precip[valid_mask], 100.) *
(precip[valid_mask] / annual_precip[valid_mask]))
return wdfxm
def calc_rprpet(pevap, snowmelt, avh2o_3, precip):
"""Calculate the ratio of precipitation to ref evapotranspiration.
The ratio of precipitation or snowmelt to reference evapotranspiration
influences agdefac and bgdefac, the above- and belowground
decomposition factors.
Parameters:
pevap (numpy.ndarray): derived, reference evapotranspiration
snowmelt (numpy.ndarray): derived, snowmelt occuring this month
avh2o_3 (numpy.ndarray): derived, moisture in top two soil layers
precip (numpy.ndarray): input, precipitation for this month
Returns:
rprpet, the ratio of precipitation or snowmelt to reference
evapotranspiration
"""
valid_mask = (
(pevap != _TARGET_NODATA) &
(snowmelt != _TARGET_NODATA) &
(avh2o_3 != _TARGET_NODATA) &
(~numpy.isclose(precip, precip_nodata)))
rprpet = numpy.empty(pevap.shape, dtype=numpy.float32)
rprpet[:] = _TARGET_NODATA
snowmelt_mask = (valid_mask & (snowmelt > 0) & (pevap > 0))
rprpet[snowmelt_mask] = snowmelt[snowmelt_mask] / pevap[snowmelt_mask]
no_melt_mask = (valid_mask & (snowmelt <= 0))
rprpet[no_melt_mask] = (
(avh2o_3[no_melt_mask] + precip[no_melt_mask]) /
pevap[no_melt_mask])
return rprpet
def calc_bgwfunc(rprpet):
"""Calculate the impact of belowground water content on decomposition.
Bgwfunc reflects the effect of soil moisture on decomposition and is
also used to calculate shoot senescence due to water stress. It is
calculated from the ratio of soil water in the top two soil layers to
reference evapotranspiration.
Parameters:
rprpet (numpy.ndarray): derived, ratio of precipitation or snowmelt
to reference evapotranspiration
Returns:
bgwfunc, the effect of soil moisture on decomposition
"""
valid_mask = (rprpet != _TARGET_NODATA)
bgwfunc = numpy.empty(rprpet.shape, dtype=numpy.float32)
bgwfunc[:] = _TARGET_NODATA
bgwfunc[valid_mask] = (
1. / (1. + 30 * numpy.exp(-8.5 * rprpet[valid_mask])))
bgwfunc[(valid_mask & (rprpet > 9))] = 1
return bgwfunc
def calc_stemp(
biomass, snow, max_temp, min_temp, daylength, pmntmp, pmxtmp):
"""Calculate mean soil surface temperature for decomposition.
Soil surface temperature is modified from monthly temperature inputs
by estimated impacts of shading by aboveground biomass and litter, and
estimated daylength. Surftemp.f
Parameters:
biomass (numpy.ndarray): derived, sum of aboveground biomass and
surface litter across plant functional types
snow (numpy.ndarray): state variable, current snowpack
max_temp (numpy.ndarray): input, maximum temperature this month
min_temp (numpy.ndarray): input, minimum temperature this month
daylength (numpy.ndarray): derived, estimated hours of daylight
pmntmp (numpy.ndarray): parameter, effect of biomass on minimum
surface temperature
pmxtmp (numpy.ndarray): parameter, effect of biomass on maximum
surface temperature
Returns:
stemp, mean soil surface temperature for decomposition
"""
valid_mask = (
(biomass != _TARGET_NODATA) &
(snow != _SV_NODATA) &
(~numpy.isclose(max_temp, max_temp_nodata)) &
(~numpy.isclose(min_temp, min_temp_nodata)) &
(daylength != _TARGET_NODATA) &
(pmntmp != _IC_NODATA) &
(pmxtmp != _IC_NODATA))
tmxs = numpy.empty(biomass.shape, dtype=numpy.float32)
tmxs[valid_mask] = (
max_temp[valid_mask] + (25.4 / (1. + 18. * numpy.exp(
-0.2 * max_temp[valid_mask]))) *
(numpy.exp(pmxtmp[valid_mask] * biomass[valid_mask]) - 0.13))
tmns = numpy.empty(biomass.shape, dtype=numpy.float32)
tmns[valid_mask] = (
min_temp[valid_mask] + pmntmp[valid_mask] * biomass[valid_mask]
- 1.78)
shortday_mask = ((daylength < 12.) & valid_mask)
snow_mask = ((snow > 0) & valid_mask)
tmns_mlt = numpy.empty(biomass.shape, dtype=numpy.float32)
tmns_mlt[valid_mask] = (
((12. - daylength[valid_mask]) * 1.2 + 12.) / 24.)
tmns_mlt[shortday_mask] = (
((12 - daylength[shortday_mask]) * 3. + 12.) / 24.)
tmns_mlt[valid_mask] = numpy.clip(tmns_mlt[valid_mask], 0.05, 0.95)
stemp = numpy.empty(biomass.shape, dtype=numpy.float32)
stemp[:] = _TARGET_NODATA
stemp[valid_mask] = (
(1 - tmns_mlt[valid_mask]) * tmxs[valid_mask] +
tmns_mlt[valid_mask] * tmns[valid_mask])
stemp[snow_mask] = 0.
return stemp
def calc_defac(bgwfunc, stemp, teff_1, teff_2, teff_3, teff_4):
"""Calculate decomposition factor.
The decomposition factor influences the rate of surface and soil
decomposition and reflects the influence of soil temperature and
moisture. Lines 151-200, Cycle.f.
Parameters:
bgwfunc (numpy.ndarray): derived, effect of soil moisture on
decomposition
stemp (numpy.ndarray): derived, average soil surface temperature
teff_1 (numpy.ndarray): parameter, x location of inflection point
for calculating the effect of soil temperature on decomposition
factor
teff_2 (numpy.ndarray): parameter, y location of inflection point
for calculating the effect of soil temperature on decomposition
factor
teff_3 (numpy.ndarray): parameter, step size for calculating the
effect of soil temperature on decomposition factor
teff_4 (numpy.ndarray): parameter, slope of the line at the
inflection point, for calculating the effect of soil
temperature on decomposition factor
Returns:
defac, aboveground and belowground decomposition factor
"""
valid_mask = (
(bgwfunc != _TARGET_NODATA) &
(teff_1 != _IC_NODATA) &
(teff_2 != _IC_NODATA) &
(teff_3 != _IC_NODATA) &
(teff_4 != _IC_NODATA))
tfunc = numpy.empty(bgwfunc.shape, dtype=numpy.float32)
tfunc[:] = _TARGET_NODATA
tfunc[valid_mask] = numpy.maximum(
0.01,
(teff_2[valid_mask] + (teff_3[valid_mask] / numpy.pi) *
numpy.arctan(numpy.pi * teff_4[valid_mask] *
(stemp[valid_mask] - teff_1[valid_mask]))) /
(teff_2[valid_mask] + (teff_3[valid_mask] / numpy.pi) *
numpy.arctan(numpy.pi * teff_4[valid_mask] *
(30.0 - teff_1[valid_mask]))))
defac = numpy.empty(bgwfunc.shape, dtype=numpy.float32)
defac[:] = _TARGET_NODATA
defac[valid_mask] = numpy.maximum(
0., tfunc[valid_mask] * bgwfunc[valid_mask])
return defac
def calc_pheff_struc(pH):
"""Calculate the effect of soil pH on decomp of structural material.
The effect of soil pH on decomposition rate is a multiplier ranging
from 0 to 1. The effect on decomposition of structural material
differs from the effect on decomposition of metabolic material in
the values of two constants.
Parameters:
pH (numpy.ndarray): input, soil pH
Returns:
pheff_struc, the effect of soil pH on decomposition rate of
structural material
"""
valid_mask = (~numpy.isclose(pH, pH_nodata))
pheff_struc = numpy.empty(pH.shape, dtype=numpy.float32)
pheff_struc[valid_mask] = numpy.clip(
(0.5 + (1.1 / numpy.pi) *
numpy.arctan(numpy.pi * 0.7 * (pH[valid_mask] - 4.))), 0, 1)
return pheff_struc
def calc_pheff_metab(pH):
"""Calculate the effect of soil pH on decomp of metabolic material.
The effect of soil pH on decomposition rate is a multiplier ranging
from 0 to 1. The effect on decomposition of structural material
differs from the effect on decomposition of metabolic material in
the values of two constants.
Parameters:
pH (numpy.ndarray): input, soil pH
Returns:
pheff_metab, the effect of soil pH on decomposition rate of
metabolic material
"""
valid_mask = (~numpy.isclose(pH, pH_nodata))
pheff_metab = numpy.empty(pH.shape, dtype=numpy.float32)
pheff_metab[valid_mask] = numpy.clip(
(0.5 + (1.14 / numpy.pi) *
numpy.arctan(numpy.pi * 0.7 * (pH[valid_mask] - 4.8))), 0, 1)
return pheff_metab
def calc_pheff_som3(pH):
"""Calculate the effect of soil pH on decomposition of SOM3.
The effect of soil pH on decomposition rate is a multiplier ranging
from 0 to 1. The effect on decomposition of SOM3 differs from the
effect of pH on decomposition of other pools in the value of
constants.
Parameters:
pH (numpy.ndarray): input, soil pH
Returns:
pheff_som3, the effect of soil pH on decomposition rate of
SOM3
"""
valid_mask = (~numpy.isclose(pH, pH_nodata))
pheff_metab = numpy.empty(pH.shape, dtype=numpy.float32)
pheff_metab[valid_mask] = numpy.clip(
(0.5 + (1.1 / numpy.pi) *
numpy.arctan(numpy.pi * 0.7 * (pH[valid_mask] - 3.))), 0, 1)
return pheff_metab
precip_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['precip_{}'.format(month_index)])['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
max_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
pH_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['ph_path'])['nodata'][0]
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'd_statv_temp', 'operand_temp', 'shwave', 'pevap', 'rprpet',
'daylength', 'sum_aglivc', 'sum_stdedc', 'biomass', 'stemp',
'defac', 'anerb', 'gromin_1', 'pheff_struc', 'pheff_metab',
'aminrl_1', 'aminrl_2', 'fsol', 'tcflow', 'tosom2',
'net_tosom2', 'tosom1', 'net_tosom1', 'tosom3', 'cleach',
'pheff_som3', 'pflow']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
for iel in [1, 2]:
for val in ['rceto1', 'rceto2', 'rceto3']:
temp_val_dict['{}_{}'.format(val, iel)] = os.path.join(
temp_dir, '{}.tif'.format('{}_{}'.format(val, iel)))
param_val_dict = {}
for val in [
'fwloss_4', 'elitst', 'pmntmp', 'pmxtmp', 'teff_1', 'teff_2',
'teff_3', 'teff_4', 'drain', 'aneref_1', 'aneref_2', 'aneref_3',
'sorpmx', 'pslsrb', 'strmax_1', 'dec1_1', 'pligst_1', 'strmax_2',
'dec1_2', 'pligst_2', 'rsplig', 'ps1co2_1', 'ps1co2_2', 'dec2_1',
'pcemic1_1_1', 'pcemic1_2_1', 'pcemic1_3_1', 'pcemic1_1_2',
'pcemic1_2_2', 'pcemic1_3_2', 'varat1_1_1', 'varat1_2_1',
'varat1_3_1', 'varat1_1_2', 'varat1_2_2', 'varat1_3_2', 'dec2_2',
'pmco2_1', 'pmco2_2', 'rad1p_1_1', 'rad1p_2_1', 'rad1p_3_1',
'rad1p_1_2', 'rad1p_2_2', 'rad1p_3_2', 'dec3_1', 'p1co2a_1',
'varat22_1_1', 'varat22_2_1', 'varat22_3_1', 'varat22_1_2',
'varat22_2_2', 'varat22_3_2', 'dec3_2', 'animpt', 'varat3_1_1',
'varat3_2_1', 'varat3_3_1', 'varat3_1_2', 'varat3_2_2',
'varat3_3_2', 'omlech_3', 'dec5_2', 'p2co2_2', 'dec5_1', 'p2co2_1',
'dec4', 'p3co2', 'cmix', 'pparmn_2', 'psecmn_2', 'nlayer',
'pmnsec_2', 'psecoc1', 'psecoc2', 'epnfs_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# shwave, shortwave radiation outside the atmosphere
_shortwave_radiation(
aligned_inputs['site_index'], current_month, temp_val_dict['shwave'])
# pet, reference evapotranspiration modified by fwloss parameter
_reference_evapotranspiration(
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
temp_val_dict['shwave'], param_val_dict['fwloss_4'],
temp_val_dict['pevap'])
# rprpet, ratio of precipitation to reference evapotranspiration
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pevap'], month_reg['snowmelt'],
sv_reg['avh2o_3_path'],
aligned_inputs['precip_{}'.format(month_index)]]],
calc_rprpet, temp_val_dict['rprpet'], gdal.GDT_Float32,
_TARGET_NODATA)
# bgwfunc, effect of soil moisture on decomposition
pygeoprocessing.raster_calculator(
[(temp_val_dict['rprpet'], 1)],
calc_bgwfunc, month_reg['bgwfunc'], gdal.GDT_Float32,
_TARGET_NODATA)
# estimated daylength
_calc_daylength(
aligned_inputs['site_index'], current_month,
temp_val_dict['daylength'])
# total biomass for purposes of soil shading
for sv in ['aglivc', 'stdedc']:
weighted_sum_path = temp_val_dict['sum_{}'.format(sv)]
weighted_state_variable_sum(
sv, prev_sv_reg, aligned_inputs, pft_id_set, weighted_sum_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_aglivc'], temp_val_dict['sum_stdedc'],
prev_sv_reg['strucc_1_path'], prev_sv_reg['metabc_1_path'],
param_val_dict['elitst']]],
sum_biomass, temp_val_dict['biomass'], gdal.GDT_Float32,
_TARGET_NODATA)
# stemp, soil surface temperature for the purposes of decomposition
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['biomass'], sv_reg['snow_path'],
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
temp_val_dict['daylength'], param_val_dict['pmntmp'],
param_val_dict['pmxtmp']]],
calc_stemp, temp_val_dict['stemp'], gdal.GDT_Float32,
_TARGET_NODATA)
# defac, decomposition factor calculated from soil temp and moisture
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
month_reg['bgwfunc'], temp_val_dict['stemp'],
param_val_dict['teff_1'], param_val_dict['teff_2'],
param_val_dict['teff_3'], param_val_dict['teff_4']]],
calc_defac, temp_val_dict['defac'], gdal.GDT_Float32,
_TARGET_NODATA)
# anerb, impact of soil anaerobic conditions on decomposition
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['rprpet'], temp_val_dict['pevap'],
param_val_dict['drain'], param_val_dict['aneref_1'],
param_val_dict['aneref_2'], param_val_dict['aneref_3']]],
calc_anerb, temp_val_dict['anerb'], gdal.GDT_Float32,
_TARGET_NODATA)
# initialize gromin_1, gross mineralization of N
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['gromin_1'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
# pH effect on decomposition for structural material
pygeoprocessing.raster_calculator(
[(aligned_inputs['ph_path'], 1)],
calc_pheff_struc, temp_val_dict['pheff_struc'], gdal.GDT_Float32,
_TARGET_NODATA)
# pH effect on decomposition for metabolic material
pygeoprocessing.raster_calculator(
[(aligned_inputs['ph_path'], 1)],
calc_pheff_metab, temp_val_dict['pheff_metab'], gdal.GDT_Float32,
_TARGET_NODATA)
# initialize aminrl_1 and aminrl_2
shutil.copyfile(prev_sv_reg['minerl_1_1_path'], temp_val_dict['aminrl_1'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['minerl_1_2_path'], param_val_dict['sorpmx'],
param_val_dict['pslsrb']]],
fsfunc, temp_val_dict['fsol'], gdal.GDT_Float32, _TARGET_NODATA)
raster_multiplication(
prev_sv_reg['minerl_1_2_path'], _SV_NODATA,
temp_val_dict['fsol'], _TARGET_NODATA,
temp_val_dict['aminrl_2'], _SV_NODATA)
# initialize current month state variables and delta state variable dict
nlayer_max = int(max(
val['nlayer'] for val in site_param_table.values()))
delta_sv_dict = {
'minerl_1_1': os.path.join(temp_dir, 'minerl_1_1.tif'),
'parent_2': os.path.join(temp_dir, 'parent_2.tif'),
'secndy_2': os.path.join(temp_dir, 'secndy_2.tif'),
'occlud': os.path.join(temp_dir, 'occlud.tif'),
}
for lyr in range(1, nlayer_max + 1):
state_var = 'minerl_{}_2'.format(lyr)
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
# initialize mineral N in current sv_reg
for lyr in range(1, nlayer_max + 1):
state_var = 'minerl_{}_1'.format(lyr)
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for compartment in ['strlig']:
for lyr in [1, 2]:
state_var = '{}_{}'.format(compartment, lyr)
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for compartment in ['som3']:
state_var = '{}c'.format(compartment)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for iel in [1, 2]:
state_var = '{}e_{}'.format(compartment, iel)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for compartment in ['struc', 'metab', 'som1', 'som2']:
for lyr in [1, 2]:
state_var = '{}c_{}'.format(compartment, lyr)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for iel in [1, 2]:
state_var = '{}e_{}_{}'.format(compartment, lyr, iel)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for state_var in ['parent_2', 'secndy_2', 'occlud']:
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for dtm in range(4):
# initialize change (delta, d) in state variables for this decomp step
for state_var in delta_sv_dict.keys():
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], delta_sv_dict[state_var],
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[0])
if dtm == 0:
# schedule flow of N from atmospheric fixation to surface mineral
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['precip_{}'.format(month_index)],
year_reg['annual_precip_path'], year_reg['baseNdep_path'],
param_val_dict['epnfs_2']]],
calc_N_fixation, delta_sv_dict['minerl_1_1'],
gdal.GDT_Float32, _IC_NODATA)
# decomposition of structural material in surface and soil
for lyr in [1, 2]:
if lyr == 1:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['strucc_1_path'], sv_reg['struce_1_1_path'],
sv_reg['struce_1_2_path'], pp_reg['rnewas_1_1_path'],
pp_reg['rnewas_2_1_path'], param_val_dict['strmax_1'],
temp_val_dict['defac'], param_val_dict['dec1_1'],
param_val_dict['pligst_1'], sv_reg['strlig_1_path'],
temp_val_dict['pheff_struc']]],
calc_tcflow_strucc_1, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['strucc_2_path'], sv_reg['struce_2_1_path'],
sv_reg['struce_2_2_path'], pp_reg['rnewbs_1_1_path'],
pp_reg['rnewbs_2_1_path'], param_val_dict['strmax_2'],
temp_val_dict['defac'], param_val_dict['dec1_2'],
param_val_dict['pligst_2'], sv_reg['strlig_2_path'],
temp_val_dict['pheff_struc'], temp_val_dict['anerb']]],
calc_tcflow_strucc_2, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['strucc_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['strucc_{}'.format(lyr)], _IC_NODATA)
# structural material decomposes first to SOM2
raster_multiplication(
temp_val_dict['tcflow'], _IC_NODATA,
sv_reg['strlig_{}_path'.format(lyr)], _SV_NODATA,
temp_val_dict['tosom2'], _IC_NODATA)
# microbial respiration with decomposition to SOM2
respiration(
temp_val_dict['tosom2'], param_val_dict['rsplig'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tosom2'], param_val_dict['rsplig'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tosom2'], param_val_dict['rsplig']]],
calc_net_cflow, temp_val_dict['net_tosom2'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom2'], _IC_NODATA,
delta_sv_dict['som2c_{}'.format(lyr)], _IC_NODATA)
if lyr == 1:
rcetob = 'rnewas'
else:
rcetob = 'rnewbs'
# N and P flows from STRUC to SOM2
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
pp_reg['{}_1_2_path'.format(rcetob)],
sv_reg['minerl_1_1_path'],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['som2e_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
pp_reg['{}_2_2_path'.format(rcetob)],
sv_reg['minerl_1_2_path'],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['som2e_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
# structural material decomposes next to SOM1
raster_difference(
temp_val_dict['tcflow'], _IC_NODATA, temp_val_dict['tosom2'],
_IC_NODATA, temp_val_dict['tosom1'], _IC_NODATA)
# microbial respiration with decomposition to SOM1
respiration(
temp_val_dict['tosom1'],
param_val_dict['ps1co2_{}'.format(lyr)],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tosom1'],
param_val_dict['ps1co2_{}'.format(lyr)],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tosom1'],
param_val_dict['ps1co2_{}'.format(lyr)]]],
calc_net_cflow, temp_val_dict['net_tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom1'], _IC_NODATA,
delta_sv_dict['som1c_{}'.format(lyr)], _IC_NODATA)
if lyr == 1:
rcetob = 'rnewas'
else:
rcetob = 'rnewbs'
# N and P flows from STRUC to SOM1
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
pp_reg['{}_1_1_path'.format(rcetob)],
sv_reg['minerl_1_1_path'],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['som1e_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
pp_reg['{}_2_1_path'.format(rcetob)],
sv_reg['minerl_1_2_path'],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['som1e_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
# decomposition of metabolic material in surface and soil to SOM1
for lyr in [1, 2]:
if lyr == 1:
for iel in [1, 2]:
# required ratio for surface metabolic decomposing to SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['metabe_1_{}_path'.format(iel)],
sv_reg['metabc_1_path'],
param_val_dict['pcemic1_1_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)],
param_val_dict['pcemic1_3_{}'.format(iel)]]],
_aboveground_ratio,
temp_val_dict['rceto1_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['metabc_1_path'], sv_reg['metabe_1_1_path'],
sv_reg['metabe_1_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec2_1'],
temp_val_dict['pheff_metab']]],
calc_tcflow_surface, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
else:
for iel in [1, 2]:
# required ratio for soil metabolic decomposing to SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_{}'.format(iel)],
param_val_dict['varat1_1_{}'.format(iel)],
param_val_dict['varat1_2_{}'.format(iel)],
param_val_dict['varat1_3_{}'.format(iel)]]],
_belowground_ratio,
temp_val_dict['rceto1_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['metabc_2_path'], sv_reg['metabe_2_1_path'],
sv_reg['metabe_2_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec2_2'], temp_val_dict['pheff_metab'],
temp_val_dict['anerb']]],
calc_tcflow_soil, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['metabc_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['metabc_{}'.format(lyr)], _IC_NODATA)
# microbial respiration with decomposition to SOM1
respiration(
temp_val_dict['tcflow'],
param_val_dict['pmco2_{}'.format(lyr)],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_1_path'.format(lyr)],
delta_sv_dict['metabe_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'],
param_val_dict['pmco2_{}'.format(lyr)],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_2_path'.format(lyr)],
delta_sv_dict['metabe_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'],
param_val_dict['pmco2_{}'.format(lyr)]]],
calc_net_cflow, temp_val_dict['net_tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom1'], _IC_NODATA,
delta_sv_dict['som1c_{}'.format(lyr)], _IC_NODATA)
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_1_path'.format(lyr)],
temp_val_dict['rceto1_1'], sv_reg['minerl_1_1_path'],
delta_sv_dict['metabe_{}_1'.format(lyr)],
delta_sv_dict['som1e_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_2_path'.format(lyr)],
temp_val_dict['rceto1_2'], sv_reg['minerl_1_2_path'],
delta_sv_dict['metabe_{}_2'.format(lyr)],
delta_sv_dict['som1e_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
# decomposition of surface SOM1 to surface SOM2: line 63 Somdec.f
for iel in [1, 2]:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['som1c_1_path'],
sv_reg['som1e_1_{}_path'.format(iel)],
param_val_dict['rad1p_1_{}'.format(iel)],
param_val_dict['rad1p_2_{}'.format(iel)],
param_val_dict['rad1p_3_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)]]],
calc_surface_som2_ratio,
temp_val_dict['rceto2_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som1c_1_path'], sv_reg['som1e_1_1_path'],
sv_reg['som1e_1_2_path'], temp_val_dict['rceto2_1'],
temp_val_dict['rceto2_2'], temp_val_dict['defac'],
param_val_dict['dec3_1'],
temp_val_dict['pheff_struc']]],
calc_tcflow_surface, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_1'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som1c_1'], _IC_NODATA)
# microbial respiration with decomposition to SOM2
respiration(
temp_val_dict['tcflow'], param_val_dict['p1co2a_1'],
sv_reg['som1c_1_path'], sv_reg['som1e_1_1_path'],
delta_sv_dict['som1e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['p1co2a_1'],
sv_reg['som1c_1_path'], sv_reg['som1e_1_2_path'],
delta_sv_dict['som1e_1_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p1co2a_1']]],
calc_net_cflow, temp_val_dict['net_tosom2'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_1'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom2'], _IC_NODATA,
delta_sv_dict['som2c_1'], _IC_NODATA)
# N and P flows from som1e_1 to som2e_1, line 123 Somdec.f
nutrient_flow(
temp_val_dict['net_tosom2'], sv_reg['som1c_1_path'],
sv_reg['som1e_1_1_path'], temp_val_dict['rceto2_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som1e_1_1'],
delta_sv_dict['som2e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom2'], sv_reg['som1c_1_path'],
sv_reg['som1e_1_2_path'], temp_val_dict['rceto2_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som1e_1_2'],
delta_sv_dict['som2e_1_2'], delta_sv_dict['minerl_1_2'])
# soil SOM1 decomposes to soil SOM3 and SOM2, line 137 Somdec.f
for iel in [1, 2]:
# required ratio for soil SOM1 decomposing to SOM2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_{}'.format(iel)],
param_val_dict['varat22_1_{}'.format(iel)],
param_val_dict['varat22_2_{}'.format(iel)],
param_val_dict['varat22_3_{}'.format(iel)]]],
_belowground_ratio,
temp_val_dict['rceto2_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_1_path'],
sv_reg['som1e_2_2_path'], temp_val_dict['rceto2_1'],
temp_val_dict['rceto2_2'], temp_val_dict['defac'],
param_val_dict['dec3_2'], pp_reg['eftext_path'],
temp_val_dict['anerb'], temp_val_dict['pheff_metab']]],
calc_tcflow_som1c_2, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som1c_2'], _IC_NODATA)
# microbial respiration with decomposition to SOM3, line 179
respiration(
temp_val_dict['tcflow'], pp_reg['p1co2_2_path'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_1_path'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], pp_reg['p1co2_2_path'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_2_path'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], pp_reg['fps1s3_path'],
param_val_dict['animpt'], temp_val_dict['anerb']]],
calc_som3_flow, temp_val_dict['tosom3'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(delta_sv_dict['som3c'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom3'], _IC_NODATA,
delta_sv_dict['som3c'], _IC_NODATA)
for iel in [1, 2]:
# required ratio for soil SOM1 decomposing to SOM3, line 198
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_{}'.format(iel)],
param_val_dict['varat3_1_{}'.format(iel)],
param_val_dict['varat3_2_{}'.format(iel)],
param_val_dict['varat3_3_{}'.format(iel)]]],
_belowground_ratio,
temp_val_dict['rceto3_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som1c_2_path'],
sv_reg['som1e_2_1_path'], temp_val_dict['rceto3_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som1e_2_1'],
delta_sv_dict['som3e_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som1c_2_path'],
sv_reg['som1e_2_2_path'], temp_val_dict['rceto3_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som1e_2_2'],
delta_sv_dict['som3e_2'], delta_sv_dict['minerl_1_2'])
# organic leaching: line 204 Somdec.f
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
month_reg['amov_2'], temp_val_dict['tcflow'],
param_val_dict['omlech_3'], pp_reg['orglch_path']]],
calc_c_leach, temp_val_dict['cleach'], gdal.GDT_Float32,
_TARGET_NODATA)
for iel in [1, 2]:
remove_leached_iel(
sv_reg['som1c_2_path'], sv_reg['som1e_2_{}_path'.format(iel)],
temp_val_dict['cleach'],
delta_sv_dict['som1e_2_{}'.format(iel)], iel)
# rest of flow from soil SOM1 goes to SOM2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], pp_reg['p1co2_2_path'],
temp_val_dict['tosom3'], temp_val_dict['cleach']]],
calc_net_cflow_tosom2, temp_val_dict['net_tosom2'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom2'], _IC_NODATA,
delta_sv_dict['som2c_2'], _IC_NODATA)
# N and P flows from soil SOM1 to soil SOM2, line 257
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_1_path'],
temp_val_dict['rceto2_1'], sv_reg['minerl_1_1_path'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['som2e_2_1'],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_2_path'],
temp_val_dict['rceto2_2'], sv_reg['minerl_1_2_path'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['som2e_2_2'],
delta_sv_dict['minerl_1_2'])
# soil SOM2 decomposing to soil SOM1 and SOM3, line 269
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som2c_2_path'], sv_reg['som2e_2_1_path'],
sv_reg['som2e_2_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec5_2'], temp_val_dict['pheff_metab'],
temp_val_dict['anerb']]],
calc_tcflow_soil, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_2'], _IC_NODATA)
respiration(
temp_val_dict['tcflow'], param_val_dict['pmco2_2'],
sv_reg['som2c_2_path'], sv_reg['som2e_2_1_path'],
delta_sv_dict['som2e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['pmco2_2'],
sv_reg['som2c_2_path'], sv_reg['som2e_2_2_path'],
delta_sv_dict['som2e_2_2'], delta_sv_dict['minerl_1_2'])
# soil SOM2 flows first to SOM3
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], pp_reg['fps2s3_path'],
param_val_dict['animpt'], temp_val_dict['anerb']]],
calc_som3_flow, temp_val_dict['tosom3'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(delta_sv_dict['som3c'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom3'], _IC_NODATA,
delta_sv_dict['som3c'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_1_path'], temp_val_dict['rceto3_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_2_1'],
delta_sv_dict['som3e_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_2_path'], temp_val_dict['rceto3_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_2_2'],
delta_sv_dict['som3e_2'], delta_sv_dict['minerl_1_2'])
# rest of flow from soil SOM2 goes to soil SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p2co2_2'],
temp_val_dict['tosom3']]],
calc_net_cflow_tosom1, temp_val_dict['net_tosom1'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom1'], _IC_NODATA,
delta_sv_dict['som1c_2'], _IC_NODATA)
nutrient_flow(
temp_val_dict['net_tosom1'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_1_path'], temp_val_dict['rceto1_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_2_1'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom1'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_2_path'], temp_val_dict['rceto1_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_2_2'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['minerl_1_2'])
# surface SOM2 decomposes to surface SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som2c_1_path'], sv_reg['som2e_1_1_path'],
sv_reg['som2e_1_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec5_1'], temp_val_dict['pheff_struc']]],
calc_tcflow_surface, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_1'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_1'], _IC_NODATA)
respiration(
temp_val_dict['tcflow'], param_val_dict['p2co2_1'],
sv_reg['som2c_1_path'], sv_reg['som2e_1_1_path'],
delta_sv_dict['som2e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['p2co2_1'],
sv_reg['som2c_1_path'], sv_reg['som2e_1_2_path'],
delta_sv_dict['som2e_1_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p2co2_1']]],
calc_net_cflow, temp_val_dict['tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_1'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom1'], _IC_NODATA,
delta_sv_dict['som1c_1'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_1_path'], temp_val_dict['rceto1_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_1_1'],
delta_sv_dict['som1e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_2_path'], temp_val_dict['rceto1_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_1_2'],
delta_sv_dict['som1e_1_2'], delta_sv_dict['minerl_1_2'])
# SOM3 decomposing to soil SOM1
# pH effect on decomposition of SOM3
pygeoprocessing.raster_calculator(
[(aligned_inputs['ph_path'], 1)],
calc_pheff_som3, temp_val_dict['pheff_som3'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som3c_path'], sv_reg['som3e_1_path'],
sv_reg['som3e_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec4'], temp_val_dict['pheff_som3'],
temp_val_dict['anerb']]],
calc_tcflow_soil, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som3c'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som3c'], _IC_NODATA)
respiration(
temp_val_dict['tcflow'], param_val_dict['p3co2'],
sv_reg['som3c_path'], sv_reg['som3e_1_path'],
delta_sv_dict['som3e_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['p3co2'],
sv_reg['som3c_path'], sv_reg['som3e_2_path'],
delta_sv_dict['som3e_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p3co2']]],
calc_net_cflow, temp_val_dict['tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom1'], _IC_NODATA,
delta_sv_dict['som1c_2'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som3c_path'],
sv_reg['som3e_1_path'], temp_val_dict['rceto1_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som3e_1'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som3c_path'],
sv_reg['som3e_2_path'], temp_val_dict['rceto1_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som3e_2'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['minerl_1_2'])
# Surface SOM2 flows to soil SOM2 via mixing
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['som2c_1_path'], param_val_dict['cmix'],
temp_val_dict['defac']]],
calc_som2_flow, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_1'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_1'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_2'], _IC_NODATA)
# ratios for N and P entering soil som2 via mixing
raster_division(
sv_reg['som2c_1_path'], _SV_NODATA,
sv_reg['som2e_1_1_path'], _IC_NODATA,
temp_val_dict['rceto2_1'], _IC_NODATA)
raster_division(
sv_reg['som2c_1_path'], _SV_NODATA,
sv_reg['som2e_1_2_path'], _IC_NODATA,
temp_val_dict['rceto2_2'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tcflow'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_1_path'], temp_val_dict['rceto2_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_1_1'],
delta_sv_dict['som2e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tcflow'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_2_path'], temp_val_dict['rceto2_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_1_2'],
delta_sv_dict['som2e_2_2'], delta_sv_dict['minerl_1_2'])
# P flow from parent to mineral: Pschem.f
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['parent_2_path'], param_val_dict['pparmn_2'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['parent_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['parent_2'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['minerl_1_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['minerl_1_2'], _IC_NODATA)
# P flow from secondary to mineral
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['secndy_2_path'], param_val_dict['psecmn_2'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['minerl_1_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['minerl_1_2'], _IC_NODATA)
# P flow from mineral to secondary
for lyr in range(1, nlayer_max + 1):
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_{}_2_path'.format(lyr)],
param_val_dict['pmnsec_2'], temp_val_dict['fsol'],
temp_val_dict['defac']]],
calc_pflow_to_secndy, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['minerl_{}_2'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['minerl_{}_2'.format(lyr)], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
# P flow from secondary to occluded
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['secndy_2_path'], param_val_dict['psecoc1'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['occlud'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['occlud'], _IC_NODATA)
# P flow from occluded to secondary
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['occlud_path'], param_val_dict['psecoc2'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['occlud'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['occlud'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
# accumulate flows
compartment = 'som3'
state_var = '{}c'.format(compartment)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for iel in [1, 2]:
state_var = '{}e_{}'.format(compartment, iel)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for compartment in ['struc', 'metab', 'som1', 'som2']:
for lyr in [1, 2]:
state_var = '{}c_{}'.format(compartment, lyr)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for iel in [1, 2]:
state_var = '{}e_{}_{}'.format(compartment, lyr, iel)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for iel in [1, 2]:
state_var = 'minerl_1_{}'.format(iel)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for state_var in ['parent_2', 'secndy_2', 'occlud']:
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
# update aminrl: Simsom.f line 301
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_1_2_path'], param_val_dict['sorpmx'],
param_val_dict['pslsrb']]],
fsfunc, temp_val_dict['fsol'], gdal.GDT_Float32, _TARGET_NODATA)
update_aminrl(
sv_reg['minerl_1_1_path'], sv_reg['minerl_1_2_path'],
temp_val_dict['fsol'], temp_val_dict['aminrl_1'],
temp_val_dict['aminrl_2'])
# volatilization loss of N: line 323 Simsom.f
raster_multiplication(
temp_val_dict['gromin_1'], _TARGET_NODATA,
pp_reg['vlossg_path'], _IC_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA)
shutil.copyfile(
sv_reg['minerl_1_1_path'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
sv_reg['minerl_1_1_path'], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def partit(
cpart_path, epart_1_path, epart_2_path, frlign_path,
site_index_path, site_param_table, lyr, sv_reg):
"""Partition incoming material into structural and metabolic pools.
When organic material is added to the soil, for example as dead
biomass falls and becomes litter, or when organic material is added
from animal waste, it is partitioned into structural (STRUCC_lyr) and
metabolic (METABC_lyr) material according to the ratio of lignin to N in
the residue. As residue is partitioned, some N and P may be directly
absorbed from surface mineral N or P into the residue.
Parameters:
cpart_path (string): path to raster containing C in incoming material
that is to be partitioned
epart_1_path (string): path to raster containing N in incoming
material
epart_2_path (string): path to raster containing P in incoming
material
frlign_path (string): path to raster containing fraction of incoming
material that is lignin
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
lyr (int): layer which is receiving the incoming material (i.e.,
1=surface layer, 2=soil layer)
sv_reg (dict): map of key, path pairs giving paths to current state
variables
Side effects:
modifies the rasters indicated by the following paths:
sv_reg['minerl_1_1_path']
sv_reg['minerl_1_2_path']
sv_reg['metabc_{}_path'.format(lyr)]
sv_reg['strucc_{}_path'.format(lyr)]
sv_reg['metabe_{}_1_path'.format(lyr)]
sv_reg['metabe_{}_2_path'.format(lyr)]
sv_reg['struce_{}_1_path'.format(lyr)]
sv_reg['struce_{}_2_path'.format(lyr)]
sv_reg['strlig_{}_path'.format(lyr)]
Returns:
None
"""
def calc_dirabs(
cpart, epart_iel, minerl_1_iel, damr_lyr_iel, pabres, damrmn_iel):
"""Calculate direct absorption of mineral N or P.
When organic material is added to the soil, some mineral N or P may
be directly absorbed from the surface mineral layer into the incoming
material. the amount transferred depends on the N or P in the incoming
material and the required C/N or C/P ratio of receiving material.
Parameters:
cpart (numpy.ndarray): derived, C in incoming material
epart_iel (numpy.ndarray): derived, <iel> in incoming material
minerl_1_iel (numpy.ndarray): state variable, surface mineral <iel>
damr_lyr_iel (numpy.ndarray): parameter, fraction of iel in lyr
absorbed by residue
pabres (numpy.ndarray): parameter, amount of residue which will
give maximum direct absorption of iel
damrmn_iel (numpy.ndarray): parameter, minimum C/iel ratio allowed
in residue after direct absorption
Returns:
dirabs_iel, <iel> (N or P) absorbed from the surface mineral pool
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(epart_iel != _TARGET_NODATA) &
(~numpy.isclose(minerl_1_iel, _SV_NODATA)) &
(damr_lyr_iel != _IC_NODATA) &
(pabres != _IC_NODATA) &
(damrmn_iel != _IC_NODATA))
dirabs_iel = numpy.empty(cpart.shape, dtype=numpy.float32)
dirabs_iel[:] = _TARGET_NODATA
dirabs_iel[valid_mask] = 0.
minerl_mask = ((minerl_1_iel >= 0) & valid_mask)
dirabs_iel[minerl_mask] = (
damr_lyr_iel[minerl_mask] * minerl_1_iel[minerl_mask] *
numpy.maximum(cpart[minerl_mask] / pabres[minerl_mask], 1.))
# rcetot: C/E ratio of incoming material
rcetot = numpy.empty(cpart.shape, dtype=numpy.float32)
rcetot[:] = _IC_NODATA
e_sufficient_mask = (((epart_iel + dirabs_iel) > 0) & valid_mask)
rcetot[valid_mask] = 0
rcetot[e_sufficient_mask] = (
cpart[e_sufficient_mask] / (
epart_iel[e_sufficient_mask] + dirabs_iel[e_sufficient_mask]))
dirabs_mod_mask = ((rcetot < damrmn_iel) & valid_mask)
dirabs_iel[dirabs_mod_mask] = numpy.maximum(
cpart[dirabs_mod_mask] / damrmn_iel[dirabs_mod_mask] -
epart_iel[dirabs_mod_mask], 0.)
return dirabs_iel
def calc_d_metabc_lyr(cpart, epart_1, dirabs_1, frlign, spl_1, spl_2):
"""Calculate the change in metabolic C after addition of new material.
Parameters:
cpart (numpy.ndarray): C in incoming material
epart_1 (numpy.ndarray): N in incoming material
dirabs_1 (numpy.ndarray): derived, direct aborption of mineral N
into incoming material
frlign (numpy.ndarray): fraction of incoming material which is
lignin
spl_1 (numpy.ndarray): parameter, intercept of regression
predicting fraction of residue going to metabolic
spl_2 (numpy.ndarray): parameter, slope of regression predicting
fraction of residue going to metabolic
Returns:
d_metabc_lyr, change in metabc_lyr
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(epart_1 != _TARGET_NODATA) &
(dirabs_1 != _TARGET_NODATA) &
(frlign != _TARGET_NODATA) &
(spl_1 != _IC_NODATA) &
(spl_2 != _IC_NODATA))
movt_mask = ((cpart > 0) & valid_mask)
# rlnres: ratio of lignin to N in the incoming material
rlnres = numpy.empty(cpart.shape, dtype=numpy.float32)
rlnres[:] = _TARGET_NODATA
rlnres[valid_mask] = 0.
rlnres[movt_mask] = (
frlign[movt_mask] / (
(epart_1[movt_mask] + dirabs_1[movt_mask]) /
(cpart[movt_mask] * 2.5)))
# frmet: fraction of cpart that goes to metabolic
frmet = numpy.empty(cpart.shape, dtype=numpy.float32)
frmet[:] = _TARGET_NODATA
frmet[valid_mask] = (
spl_1[valid_mask] - spl_2[valid_mask] * rlnres[valid_mask])
lign_exceeded_mask = ((frlign > (1. - frmet)) & valid_mask)
frmet[lign_exceeded_mask] = 1. - frlign[lign_exceeded_mask]
d_metabc_lyr = numpy.empty(cpart.shape, dtype=numpy.float32)
d_metabc_lyr[:] = _TARGET_NODATA
d_metabc_lyr[valid_mask] = cpart[valid_mask] * frmet[valid_mask]
return d_metabc_lyr
def calc_d_strucc_lyr(cpart, d_metabc_lyr):
"""Calculate change in structural C after addition of new material.
Parameters:
cpart (numpy.ndarray): derived, C in incoming material
d_metabc_lyr (numpy.ndarray) derived, change in metabc_lyr
Returns:
d_strucc_lyr, change in strucc_lyr
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(d_metabc_lyr != _TARGET_NODATA))
d_strucc_lyr = numpy.empty(cpart.shape, dtype=numpy.float32)
d_strucc_lyr[:] = _TARGET_NODATA
d_strucc_lyr[valid_mask] = cpart[valid_mask] - d_metabc_lyr[valid_mask]
return d_strucc_lyr
def calc_d_struce_lyr_iel(d_strucc_lyr, rcestr_iel):
"""Calculate the change in N or P in structural material in layer lyr.
Parameters:
d_strucc_lyr (numpy.ndarray): change in strucc_lyr with addition of
incoming material
rcestr_iel (numpy.ndarray): parameter, C/<iel> ratio for structural
material
Returns:
d_struce_lyr_iel, change in structural N or P in layer lyr
"""
valid_mask = (
(d_strucc_lyr != _TARGET_NODATA) &
(rcestr_iel != _IC_NODATA))
d_struce_lyr_iel = numpy.empty(d_strucc_lyr.shape, dtype=numpy.float32)
d_struce_lyr_iel[valid_mask] = (
d_strucc_lyr[valid_mask] / rcestr_iel[valid_mask])
return d_struce_lyr_iel
def calc_d_metabe_lyr_iel(cpart, epart_iel, dirabs_iel, d_struce_lyr_iel):
"""Calculate the change in N or P in metabolic material in layer lyr.
Parameters:
cpart (numpy.ndarray): C in incoming material
epart_iel (numpy.ndarray): <iel> in incoming material
dirabs_iel (numpy.ndarray): <iel> absorbed from the surface mineral
pool
d_struce_lyr_iel (numpy.ndarray): change in structural N or P in
layer lyr
Returns:
d_metabe_lyr_iel, change in metabolic N or P in layer lyr
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(epart_iel != _TARGET_NODATA) &
(dirabs_iel != _TARGET_NODATA) &
(d_struce_lyr_iel != _TARGET_NODATA))
d_metabe_lyr_iel = numpy.empty(cpart.shape, dtype=numpy.float32)
d_metabe_lyr_iel[:] = _TARGET_NODATA
d_metabe_lyr_iel[valid_mask] = (
epart_iel[valid_mask] + dirabs_iel[valid_mask] -
d_struce_lyr_iel[valid_mask])
return d_metabe_lyr_iel
def calc_d_strlig_lyr(frlign, d_strucc_lyr, cpart, strlig_lyr, strucc_lyr):
"""Calculate change in fraction of lignin in structural material.
Parameters:
frlign (numpy.ndarray): fraction of incoming material which is
lignin
d_strucc_lyr (numpy.ndarray): change in strucc_lyr with addition of
incoming material
cpart (numpy.ndarray): C in incoming material
strlig_lyr (numpy.ndarray): state variable, lignin in structural
material in receiving layer
strucc_lyr (numpy.ndarray): state variable, C in structural
material in layer lyr
Returns:
d_strlig_lyr, change in fraction of lignin in structural material
in layer lyr
"""
valid_mask = (
(frlign != _TARGET_NODATA) &
(d_strucc_lyr != _TARGET_NODATA) &
(cpart != _TARGET_NODATA) &
(~numpy.isclose(strlig_lyr, _SV_NODATA)) &
(~numpy.isclose(strucc_lyr, _SV_NODATA)))
movt_mask = ((cpart > 0) & valid_mask)
fligst = numpy.empty(frlign.shape, dtype=numpy.float32)
fligst[:] = _TARGET_NODATA
fligst[valid_mask] = 1.
fligst[movt_mask] = numpy.minimum(
frlign[movt_mask] / (
d_strucc_lyr[movt_mask] / cpart[movt_mask]), 1.)
strlig_lyr_mod = numpy.empty(frlign.shape, dtype=numpy.float32)
strlig_lyr_mod[:] = _TARGET_NODATA
strlig_lyr_mod[valid_mask] = (
((strlig_lyr[valid_mask] * strucc_lyr[valid_mask]) +
(fligst[valid_mask] * d_strucc_lyr[valid_mask])) /
(strucc_lyr[valid_mask] + d_strucc_lyr[valid_mask]))
d_strlig_lyr = numpy.empty(frlign.shape, dtype=numpy.float32)
d_strlig_lyr[:] = _IC_NODATA
d_strlig_lyr[valid_mask] = (
strlig_lyr_mod[valid_mask] - strlig_lyr[valid_mask])
return d_strlig_lyr
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'dirabs_1', 'dirabs_2', 'd_metabc_lyr', 'd_strucc_lyr',
'd_struce_lyr_iel', 'd_statv_temp', 'operand_temp']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
for val in [
'damr_{}_1'.format(lyr), 'damr_{}_2'.format(lyr), 'pabres',
'damrmn_1', 'damrmn_2', 'spl_1', 'spl_2', 'rcestr_1',
'rcestr_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# direct absorption of N and P from surface mineral layer
for iel in [1, 2]:
if iel == 1:
epart_path = epart_1_path
else:
epart_path = epart_2_path
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, epart_path,
sv_reg['minerl_1_{}_path'.format(iel)],
param_val_dict['damr_{}_{}'.format(lyr, iel)],
param_val_dict['pabres'],
param_val_dict['damrmn_{}'.format(iel)]]],
calc_dirabs, temp_val_dict['dirabs_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# remove direct absorption from surface mineral layer
shutil.copyfile(
sv_reg['minerl_1_{}_path'.format(iel)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['dirabs_{}'.format(iel)], _TARGET_NODATA,
sv_reg['minerl_1_{}_path'.format(iel)], _SV_NODATA)
# partition C into structural and metabolic
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, epart_1_path, temp_val_dict['dirabs_1'],
frlign_path, param_val_dict['spl_1'],
param_val_dict['spl_2']]],
calc_d_metabc_lyr, temp_val_dict['d_metabc_lyr'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, temp_val_dict['d_metabc_lyr']]],
calc_d_strucc_lyr, temp_val_dict['d_strucc_lyr'], gdal.GDT_Float32,
_TARGET_NODATA)
shutil.copyfile(
sv_reg['metabc_{}_path'.format(lyr)], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['d_metabc_lyr'], _TARGET_NODATA,
sv_reg['metabc_{}_path'.format(lyr)], _SV_NODATA)
shutil.copyfile(
sv_reg['strucc_{}_path'.format(lyr)], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['d_strucc_lyr'], _TARGET_NODATA,
sv_reg['strucc_{}_path'.format(lyr)], _SV_NODATA)
# partition N and P into structural and metabolic
for iel in [1, 2]:
if iel == 1:
epart_path = epart_1_path
else:
epart_path = epart_2_path
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['d_strucc_lyr'],
param_val_dict['rcestr_{}'.format(iel)]]],
calc_d_struce_lyr_iel, temp_val_dict['d_struce_lyr_iel'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['struce_{}_{}_path'.format(lyr, iel)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['d_struce_lyr_iel'], _TARGET_NODATA,
sv_reg['struce_{}_{}_path'.format(lyr, iel)], _SV_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, epart_path,
temp_val_dict['dirabs_{}'.format(iel)],
temp_val_dict['d_struce_lyr_iel']]],
calc_d_metabe_lyr_iel, temp_val_dict['operand_temp'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['metabe_{}_{}_path'.format(lyr, iel)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
sv_reg['metabe_{}_{}_path'.format(lyr, iel)], _SV_NODATA)
# adjust fraction of lignin in receiving structural pool
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
frlign_path, temp_val_dict['d_strucc_lyr'], cpart_path,
sv_reg['strlig_{}_path'.format(lyr)],
sv_reg['strucc_{}_path'.format(lyr)]]],
calc_d_strlig_lyr, temp_val_dict['operand_temp'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
sv_reg['strlig_{}_path'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['operand_temp'], _IC_NODATA,
sv_reg['strlig_{}_path'.format(lyr)], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_fall_standing_dead(stdedc, fallrt):
"""Calculate delta C with fall of standing dead.
Material falls from standing dead biomass into surface litter
according to a constant monthly fall rate.
Parameters:
stdedc (numpy.ndarray): state variable, C in standing dead material
fallrt (numpy.ndarray): parameter, fraction of standing dead material
that falls each month
Returns:
delta_c_standing_dead, change in C in standing dead
"""
valid_mask = (
(~numpy.isclose(stdedc, _SV_NODATA)) &
(fallrt != _IC_NODATA))
delta_c_standing_dead = numpy.empty(stdedc.shape, dtype=numpy.float32)
delta_c_standing_dead[:] = _TARGET_NODATA
delta_c_standing_dead[valid_mask] = stdedc[valid_mask] * fallrt[valid_mask]
return delta_c_standing_dead
def calc_root_death(
average_temperature, rtdtmp, rdr, avh2o_1, deck5, bglivc):
"""Calculate delta C with death of roots.
Material flows from roots into soil organic matter pools due to root death.
Root death rate is limited by average temperature and influenced by
available soil moisture. Change in C is calculated by multiplying the root
death rate by bglivc, C in live roots.
Parameters:
average_temperature (numpy.ndarray): derived, average temperature for
the current month
rtdtmp (numpy.ndarray): parameter, temperature below which root death
does not occur
rdr (numpy.ndarray): parameter, maximum root death rate at very dry
soil conditions
avh2o_1 (numpy.ndarray): state variable, water available to the current
plant functional type for growth
deck5 (numpy.ndarray): parameter, level of available soil water at
which root death rate is half maximum
bglivc (numpy.ndarray): state variable, C in belowground live roots
Returns:
delta_c_root_death, change in C during root death
"""
valid_mask = (
(average_temperature != _IC_NODATA) &
(rdr != _IC_NODATA) &
(~numpy.isclose(avh2o_1, _SV_NODATA)) &
(deck5 != _IC_NODATA) &
(~numpy.isclose(bglivc, _SV_NODATA)))
root_death_rate = numpy.empty(bglivc.shape, dtype=numpy.float32)
root_death_rate[:] = _TARGET_NODATA
root_death_rate[valid_mask] = 0.
temp_sufficient_mask = ((average_temperature >= rtdtmp) & valid_mask)
root_death_rate[temp_sufficient_mask] = numpy.minimum(
rdr[temp_sufficient_mask] *
(1.0 - avh2o_1[temp_sufficient_mask] / (
deck5[temp_sufficient_mask] + avh2o_1[temp_sufficient_mask])),
0.95)
delta_c_root_death = numpy.empty(bglivc.shape, dtype=numpy.float32)
delta_c_root_death[:] = _TARGET_NODATA
delta_c_root_death[valid_mask] = (
root_death_rate[valid_mask] * bglivc[valid_mask])
return delta_c_root_death
def calc_delta_iel(c_state_variable, iel_state_variable, delta_c):
"""Calculate the change in N or P accompanying change in C.
As C flows out of standing dead biomass or roots, the amount of iel
(N or P) flowing out of the same pool is calculated from the change in C
according to the ratio of C to iel in the pool.
Parameters:
c_state_variable (numpy.ndarray): state variable, C in the pool that is
losing material
iel_state_variable (numpy.ndarray): state variable, N or P in the pool
that is losing material
delta_c (numpy.ndarray): derived, change in C. Change in N or P is
proportional to this amount.
Returns:
delta_iel, change in N or P accompanying the change in C
"""
valid_mask = (
(~numpy.isclose(c_state_variable, _SV_NODATA)) &
(~numpy.isclose(iel_state_variable, _SV_NODATA)) &
(c_state_variable > 0) &
(delta_c != _TARGET_NODATA))
delta_iel = numpy.empty(c_state_variable.shape, dtype=numpy.float32)
delta_iel[:] = _TARGET_NODATA
delta_iel[valid_mask] = (
(iel_state_variable[valid_mask] / c_state_variable[valid_mask]) *
delta_c[valid_mask])
return delta_iel
def _death_and_partition(
state_variable, aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg, sv_reg):
"""Track movement of C, N and P from a pft-level state variable into soil.
Calculate C, N and P leaving the specified state variable and entering
surface or soil organic matter pools. Subtract the change in C, N and P
from the state variable tracked for each pft, sum up the amounts across
pfts, and distribute the sum of the material flowing from the state
variable to surface or soil structural and metabolic pools.
Parameters:
state_variable (string): string identifying the state variable that is
flowing into organic matter. Must be one of "stded" (for fall
of standing dead) or "bgliv" (for death of roots). If the state
variable is stded, material flowing from stded enters surface
structural and metabolic pools. If the state variable is bgliv,
material flowing from bgliv enters soil structural and metabolic
pools.
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including temperature,
plant functional type composition, and site spatial index
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
current_month (int): month of the year, such that current_month=1
indicates January
pft_id_set (set): set of integers identifying plant functional types
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
creates the rasters indicated by
sv_reg['<state_variable>c_<pft>_path'] for each pft
sv_reg['<state_variable>e_1_<pft>_path'] for each pft
sv_reg['<state_variable>e_2_<pft>_path'] for each pft
modifies the rasters indicated by
sv_reg['minerl_1_1_path']
sv_reg['minerl_1_2_path']
sv_reg['metabc_<lyr>_path']
sv_reg['strucc_<lyr>_path']
sv_reg['metabe_<lyr>_1_path']
sv_reg['metabe_<lyr>_2_path']
sv_reg['struce_<lyr>_1_path']
sv_reg['struce_<lyr>_2_path']
sv_reg['strlig_<lyr>_path']
where lyr=1 if `state_variable` == 'stded'
lyr=2 if `state_variable` == 'bgliv'
Returns:
None
"""
def calc_avg_temp(max_temp, min_temp):
"""Calculate average temperature from maximum and minimum temp."""
valid_mask = (
(~numpy.isclose(max_temp, max_temp_nodata)) &
(~numpy.isclose(min_temp, min_temp_nodata)))
tave = numpy.empty(max_temp.shape, dtype=numpy.float32)
tave[:] = _IC_NODATA
tave[valid_mask] = (max_temp[valid_mask] + min_temp[valid_mask]) / 2.
return tave
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'tave', 'delta_c', 'delta_iel', 'delta_sv_weighted',
'operand_temp', 'sum_weighted_delta_C', 'sum_weighted_delta_N',
'sum_weighted_delta_P', 'weighted_lignin', 'sum_lignin',
'fraction_lignin']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
# site-level parameters
val = 'deck5'
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# pft-level parameters
for val in['fallrt', 'rtdtmp', 'rdr']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
# sum of material across pfts to be partitioned to organic matter
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_weighted_delta_C'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_weighted_delta_N'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_weighted_delta_P'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_lignin'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
max_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)]]],
calc_avg_temp, temp_val_dict['tave'], gdal.GDT_Float32, _IC_NODATA)
for pft_i in pft_id_set:
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
# calculate change in C leaving the given state variable
if state_variable == 'stded':
fill_val = veg_trait_table[pft_i]['fallrt']
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], param_val_dict['fallrt'],
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['stdedc_{}_path'.format(pft_i)],
param_val_dict['fallrt']]],
calc_fall_standing_dead, temp_val_dict['delta_c'],
gdal.GDT_Float32, _TARGET_NODATA)
else:
for val in ['rtdtmp', 'rdr']:
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], param_val_dict[val],
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tave'],
param_val_dict['rtdtmp'],
param_val_dict['rdr'],
sv_reg['avh2o_1_{}_path'.format(pft_i)],
param_val_dict['deck5'],
prev_sv_reg['bglivc_{}_path'.format(pft_i)]]],
calc_root_death, temp_val_dict['delta_c'],
gdal.GDT_Float32, _TARGET_NODATA)
# subtract delta_c from the pft-level state variable
raster_difference(
prev_sv_reg['{}c_{}_path'.format(state_variable, pft_i)],
_SV_NODATA, temp_val_dict['delta_c'], _TARGET_NODATA,
sv_reg['{}c_{}_path'.format(state_variable, pft_i)], _SV_NODATA)
# calculate delta C weighted by % cover of this pft
raster_multiplication(
temp_val_dict['delta_c'], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA)
shutil.copyfile(
temp_val_dict['sum_weighted_delta_C'],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_C'], _TARGET_NODATA)
# calculate weighted fraction of flowing C which is lignin
if state_variable == 'stded':
frlign_path = year_reg['pltlig_above_{}'.format(pft_i)]
else:
frlign_path = year_reg['pltlig_below_{}'.format(pft_i)]
raster_multiplication(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
frlign_path, _TARGET_NODATA,
temp_val_dict['weighted_lignin'], _TARGET_NODATA)
shutil.copyfile(
temp_val_dict['sum_lignin'], temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['weighted_lignin'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_lignin'], _TARGET_NODATA)
for iel in [1, 2]:
# calculate N or P flowing out of the pft-level state variable
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['{}c_{}_path'.format(state_variable, pft_i)],
prev_sv_reg['{}e_{}_{}_path'.format(
state_variable, iel, pft_i)],
temp_val_dict['delta_c']]],
calc_delta_iel, temp_val_dict['delta_iel'],
gdal.GDT_Float32, _TARGET_NODATA)
# subtract delta_iel from the pft-level state variable
raster_difference(
prev_sv_reg['{}e_{}_{}_path'.format(
state_variable, iel, pft_i)], _SV_NODATA,
temp_val_dict['delta_iel'], _TARGET_NODATA,
sv_reg['{}e_{}_{}_path'.format(state_variable, iel, pft_i)],
_SV_NODATA)
# calculate delta iel weighted by % cover of this pft
raster_multiplication(
temp_val_dict['delta_iel'], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA)
if iel == 1:
shutil.copyfile(
temp_val_dict['sum_weighted_delta_N'],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_N'], _TARGET_NODATA)
else:
shutil.copyfile(
temp_val_dict['sum_weighted_delta_P'],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_P'], _TARGET_NODATA)
# partition sum of C, N and P into structural and metabolic pools
if state_variable == 'stded':
lyr = 1
else:
lyr = 2
raster_division(
temp_val_dict['sum_lignin'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_C'], _TARGET_NODATA,
temp_val_dict['fraction_lignin'], _TARGET_NODATA)
partit(
temp_val_dict['sum_weighted_delta_C'],
temp_val_dict['sum_weighted_delta_N'],
temp_val_dict['sum_weighted_delta_P'],
temp_val_dict['fraction_lignin'],
aligned_inputs['site_index'], site_param_table, lyr, sv_reg)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_senescence_water_shading(
aglivc, bgwfunc, fsdeth_1, fsdeth_3, fsdeth_4):
"""Calculate shoot death due to water stress and shading.
In months where senescence is not scheduled to occur, some shoot death
may still occur due to water stress and shading.
Parameters:
aglivc (numpy.ndarray): state variable, carbon in aboveground live
biomass
bgwfunc (numpy.ndarray): derived, effect of soil moisture on
decomposition and shoot senescence
fsdeth_1 (numpy.ndarray): parameter, maximum shoot death rate at very
dry soil conditions
fsdeth_3 (numpy.ndarray): parameter, additional fraction of shoots
which die when aglivc is greater than fsdeth_4
fsdeth_4 (numpy.ndarray): parameter, threshold value for aglivc
above which shading increases senescence
Returns:
fdeth, fraction of aboveground live biomass that is converted to
standing dead
"""
valid_mask = (
(~numpy.isclose(aglivc, _SV_NODATA)) &
(bgwfunc != _TARGET_NODATA) &
(fsdeth_1 != _IC_NODATA) &
(fsdeth_3 != _IC_NODATA) &
(fsdeth_4 != _IC_NODATA))
fdeth = numpy.empty(aglivc.shape, dtype=numpy.float32)
fdeth[:] = _TARGET_NODATA
fdeth[valid_mask] = fsdeth_1[valid_mask] * (1. - bgwfunc[valid_mask])
shading_mask = ((aglivc > fsdeth_4) & valid_mask)
fdeth[shading_mask] = fdeth[shading_mask] + fsdeth_3[shading_mask]
fdeth[valid_mask] = numpy.minimum(fdeth[valid_mask], 1.)
return fdeth
def _shoot_senescence(
pft_id_set, veg_trait_table, prev_sv_reg, month_reg, current_month,
sv_reg):
"""Senescence of live material to standing dead.
Live aboveground biomass is converted to standing dead according to
senescence, which is specified for each pft to occur in one or more months
of the year. In other months, some senescence may occur because of water
stress or shading. During senescence, C, N and P move from agliv to stded
state variables.
Parameters:
pft_id_set (set): set of integers identifying plant functional types
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
current_month (int): month of the year, such that current_month=1
indicates January
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
creates the rasters indicated by
sv_reg['aglivc_<pft>_path'] for each pft
sv_reg['aglive_1_<pft>_path'] for each pft
sv_reg['aglive_2_<pft>_path'] for each pft
sv_reg['crpstg_1_<pft>_path'] for each pft
sv_reg['crpstg_2_<pft>_path'] for each pft
modifies the rasters indicated by
sv_reg['stdedc_<pft>_path'] for each pft
sv_reg['stdede_1_<pft>_path'] for each pft
sv_reg['stdede_2_<pft>_path'] for each pft
Returns:
None
"""
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'operand_temp', 'fdeth', 'delta_c', 'delta_iel', 'vol_loss',
'to_storage', 'to_stdede']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
for val in[
'fsdeth_1', 'fsdeth_2', 'fsdeth_3', 'fsdeth_4', 'vlossp',
'crprtf_1', 'crprtf_2']:
for pft_i in pft_id_set:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
prev_sv_reg['aglivc_{}_path'.format(pft_i)], target_path,
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
for pft_i in pft_id_set:
if current_month == veg_trait_table[pft_i]['senescence_month']:
temp_val_dict['fdeth'] = param_val_dict[
'fsdeth_2_{}'.format(pft_i)]
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['aglivc_{}_path'.format(pft_i)],
month_reg['bgwfunc'],
param_val_dict['fsdeth_1_{}'.format(pft_i)],
param_val_dict['fsdeth_3_{}'.format(pft_i)],
param_val_dict['fsdeth_4_{}'.format(pft_i)]]],
calc_senescence_water_shading, temp_val_dict['fdeth'],
gdal.GDT_Float32, _TARGET_NODATA)
# change in C flowing from aboveground live biomass to standing dead
raster_multiplication(
temp_val_dict['fdeth'], _TARGET_NODATA,
prev_sv_reg['aglivc_{}_path'.format(pft_i)], _SV_NODATA,
temp_val_dict['delta_c'], _TARGET_NODATA)
raster_difference(
prev_sv_reg['aglivc_{}_path'.format(pft_i)], _SV_NODATA,
temp_val_dict['delta_c'], _TARGET_NODATA,
sv_reg['aglivc_{}_path'.format(pft_i)], _SV_NODATA)
shutil.copyfile(
sv_reg['stdedc_{}_path'.format(pft_i)],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['operand_temp'], _SV_NODATA,
temp_val_dict['delta_c'], _TARGET_NODATA,
sv_reg['stdedc_{}_path'.format(pft_i)], _SV_NODATA)
for iel in [1, 2]:
# change in N or P flowing from aboveground live biomass to dead
raster_multiplication(
temp_val_dict['fdeth'], _TARGET_NODATA,
prev_sv_reg['aglive_{}_{}_path'.format(iel, pft_i)],
_SV_NODATA, temp_val_dict['delta_iel'], _TARGET_NODATA)
raster_difference(
prev_sv_reg['aglive_{}_{}_path'.format(iel, pft_i)],
_SV_NODATA, temp_val_dict['delta_iel'], _TARGET_NODATA,
sv_reg['aglive_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
if iel == 1:
# volatilization loss of N
raster_multiplication(
temp_val_dict['delta_iel'], _TARGET_NODATA,
param_val_dict['vlossp_{}'.format(pft_i)], _IC_NODATA,
temp_val_dict['vol_loss'], _TARGET_NODATA)
shutil.copyfile(
temp_val_dict['delta_iel'], temp_val_dict['operand_temp'])
raster_difference(
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['vol_loss'], _TARGET_NODATA,
temp_val_dict['delta_iel'], _TARGET_NODATA)
# a fraction of N and P goes to crop storage
raster_multiplication(
temp_val_dict['delta_iel'], _TARGET_NODATA,
param_val_dict['crprtf_{}_{}'.format(iel, pft_i)], _IC_NODATA,
temp_val_dict['to_storage'], _TARGET_NODATA)
raster_sum(
prev_sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)],
_SV_NODATA, temp_val_dict['to_storage'], _TARGET_NODATA,
sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
# the rest goes to standing dead biomass
raster_difference(
temp_val_dict['delta_iel'], _TARGET_NODATA,
temp_val_dict['to_storage'], _TARGET_NODATA,
temp_val_dict['to_stdede'], _TARGET_NODATA)
shutil.copyfile(
sv_reg['stdede_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['operand_temp'], _SV_NODATA,
temp_val_dict['to_stdede'], _TARGET_NODATA,
sv_reg['stdede_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def convert_biomass_to_C(biomass_path, c_path):
"""Convert from grams of biomass to grams of carbon.
The root:shoot submodel calculates potential growth in units of grams of
biomass, but the growth submodel calculates actual growth from that
potential growth in units of grams of carbon. Convert biomass to carbon
using a conversion factor of 2.5.
Parameters:
biomass_path (string): path to raster containing grams of
biomass
c_path (string): path to raster that should contain the equivalent
grams of carbon
Side effects:
modifies or creates the raster indicated by `c_path`
Returns:
None
"""
def convert_op(biomass):
"""Convert grams of biomass to grams of carbon."""
valid_mask = (biomass != _TARGET_NODATA)
carbon = numpy.empty(biomass.shape, dtype=numpy.float32)
carbon[:] = _TARGET_NODATA
carbon[valid_mask] = biomass[valid_mask] / 2.5
return carbon
pygeoprocessing.raster_calculator(
[(biomass_path, 1)], convert_op, c_path, gdal.GDT_Float32,
_TARGET_NODATA)
def restrict_potential_growth(potenc, availm_1, availm_2, snfxmx_1):
"""Restrict potential growth according to mineral nutrients.
Limit potential growth by the availability of mineral N and P. Growth only
occurs if there is some availability of both mineral elements. Line 63
Restrp.f
Parameters:
potenc (numpy.ndarray): potential C production (g C)
availm_1 (numpy.ndarray): derived, total mineral N available to this
pft
availm_2 (numpy.ndarray): derived, total mineral P available to this
pft
snfxmx_1 (numpy.ndarray): parameter, maximum symbiotic N fixation rate
Returns:
potenc_lim_minerl, potential C production limited by availability of
mineral nutrients
"""
valid_mask = (
(potenc != _TARGET_NODATA) &
(availm_1 != _TARGET_NODATA) &
(availm_2 != _TARGET_NODATA) &
(snfxmx_1 != _IC_NODATA))
potenc_lim_minerl = numpy.empty(potenc.shape, dtype=numpy.float32)
potenc_lim_minerl[:] = _TARGET_NODATA
potenc_lim_minerl[valid_mask] = 0
growth_mask = (
((availm_1 > 0) | (snfxmx_1 > 0)) &
(availm_2 > 0) &
valid_mask)
potenc_lim_minerl[growth_mask] = potenc[growth_mask]
return potenc_lim_minerl
def c_uptake_aboveground(cprodl, rtsh):
"""Calculate uptake of C from atmosphere to aboveground live biomass.
Given total C predicted to flow into new growth and the root:shoot ratio
of new growth, calculate the flow of C from the atmosphere into aboveground
live biomass. Lines 137-146 Growth.f
Parameters:
cprodl (numpy.ndarray): derived, c production limited by nutrient
availability
rtsh (numpy.ndarray): derived, root/shoot ratio of new production
Returns:
delta_aglivc, change in C in aboveground live biomass
"""
valid_mask = (
(cprodl != _TARGET_NODATA) &
(rtsh != _TARGET_NODATA))
delta_aglivc = numpy.empty(cprodl.shape, dtype=numpy.float32)
delta_aglivc[:] = _TARGET_NODATA
delta_aglivc[valid_mask] = (
cprodl[valid_mask] * (1. - rtsh[valid_mask] / (rtsh[valid_mask] + 1.)))
return delta_aglivc
def c_uptake_belowground(bglivc, cprodl, rtsh):
"""Do uptake of C from atmosphere to belowground live biomass.
Given total C predicted to flow into new growth and the root:shoot ratio
of new growth, perform the flow of C from the atmosphere into belowground
live biomass. Lines 148-156 Growth.f
Parameters:
bglivc (numpy.ndarray): state variable, existing C in belowground live
biomass
cprodl (numpy.ndarray): derived, c production limited by nutrient
availability
rtsh (numpy.ndarray): derived, root/shoot ratio of new production
Returns:
modified_bglivc, modified C in belowground live biomass
"""
valid_mask = (
(~numpy.isclose(bglivc, _SV_NODATA)) &
(cprodl != _TARGET_NODATA) &
(rtsh != _TARGET_NODATA))
c_prod_belowground = numpy.empty(bglivc.shape, dtype=numpy.float32)
c_prod_belowground[:] = _TARGET_NODATA
c_prod_belowground[valid_mask] = (
cprodl[valid_mask] * (rtsh[valid_mask] / (rtsh[valid_mask] + 1.)))
modified_bglivc = numpy.empty(bglivc.shape, dtype=numpy.float32)
modified_bglivc[:] = _SV_NODATA
modified_bglivc[valid_mask] = (
bglivc[valid_mask] + c_prod_belowground[valid_mask])
return modified_bglivc
def calc_uptake_source(return_type):
"""Calculate uptake of nutrient from available sources."""
def _uptake(
eavail_iel, eup_above_iel, eup_below_iel, plantNfix, storage_iel,
iel):
"""Calculate N or P taken up from one source.
Given the N or P predicted to flow into new above- and belowground
production, calculate how much of that nutrient will be taken from the
crop storage pool and how much will be taken from soil. For N, some of
the necessary uptake maybe also come from symbiotic N fixation.
Parameters:
eavail_iel (numpy.ndarray): derived, total iel available to this
plant functional type
eup_above_iel (numpy.ndarray): derived, iel in new aboveground
production
eup_below_iel (numpy.ndarray): derived, iel in new belowground
production
plantNfix (numpy.ndarray): derived, symbiotic N fixed by this plant
functional type
storage_iel (numpy.ndarray): state variable, iel in crop storage
pool
iel (integer): index identifying N or P
Returns:
uptake_storage, uptake from crop storage pool, if return_type is
'uptake_storage'
uptake_soil, uptake from mineral content of soil layers accessible
by the plant function type, if return_type is 'uptake_soil'
uptake_Nfix, uptake from symbiotically fixed nitrogen, if
return_type is 'uptake_Nfix'
"""
valid_mask = (
(eup_above_iel != _TARGET_NODATA) &
(eup_below_iel != _TARGET_NODATA) &
(plantNfix != _TARGET_NODATA) &
(~numpy.isclose(storage_iel, _SV_NODATA)))
eprodl_iel = numpy.empty(eup_above_iel.shape, dtype=numpy.float32)
eprodl_iel[:] = _TARGET_NODATA
eprodl_iel[valid_mask] = (
eup_above_iel[valid_mask] + eup_below_iel[valid_mask])
uptake_storage = numpy.empty(eup_above_iel.shape, dtype=numpy.float32)
uptake_storage[:] = _TARGET_NODATA
uptake_soil = numpy.empty(eup_above_iel.shape, dtype=numpy.float32)
uptake_soil[:] = _TARGET_NODATA
uptake_Nfix = numpy.empty(eup_above_iel.shape, dtype=numpy.float32)
uptake_Nfix[:] = _TARGET_NODATA
storage_sufficient_mask = ((eprodl_iel <= storage_iel) & valid_mask)
uptake_storage[valid_mask] = 0.
uptake_storage[storage_sufficient_mask] = (
eprodl_iel[storage_sufficient_mask])
uptake_soil[storage_sufficient_mask] = 0.
uptake_Nfix[storage_sufficient_mask] = 0.
insuff_mask = ((eprodl_iel > storage_iel) & valid_mask)
uptake_storage[insuff_mask] = storage_iel[insuff_mask]
if iel == 1:
uptake_soil[insuff_mask] = numpy.minimum(
(eprodl_iel[insuff_mask] - storage_iel[insuff_mask] -
plantNfix[insuff_mask]),
(eavail_iel[insuff_mask] - storage_iel[insuff_mask] -
plantNfix[insuff_mask]))
uptake_Nfix[insuff_mask] = plantNfix[insuff_mask]
else:
uptake_soil[insuff_mask] = (
eprodl_iel[insuff_mask] - storage_iel[insuff_mask])
if return_type == 'uptake_storage':
return uptake_storage
elif return_type == 'uptake_soil':
return uptake_soil
elif return_type == 'uptake_Nfix':
return uptake_Nfix
return _uptake
def calc_aboveground_uptake(total_uptake, eup_above_iel, eup_below_iel):
"""Calculate uptake of nutrient apportioned to aboveground biomass.
Given the total amount of iel (N or P) taken up from one source, the amount
of uptake that is apportioned to aboveground biomass is calculated from the
proportion of demand from above- and belowground growth.
Parameters:
total_uptake (numpy.ndarray): derived, uptake of iel from one source
eup_above_iel (numpy.ndarray): derived, iel in new aboveground growth
eup_below_iel (numpy.ndarray): derived, iel in new belowground growth
Returns:
uptake_above, uptake from one source that is apportioned to aboveground
biomass
"""
valid_mask = (
(total_uptake != _TARGET_NODATA) &
(eup_above_iel != _TARGET_NODATA) &
(eup_below_iel != _TARGET_NODATA))
nonzero_mask = ((eup_above_iel + eup_below_iel > 0) & valid_mask)
uptake_above = numpy.empty(total_uptake.shape, dtype=numpy.float32)
uptake_above[valid_mask] = 0.
uptake_above[nonzero_mask] = (
total_uptake[nonzero_mask] * (
eup_above_iel[nonzero_mask] /
(eup_above_iel[nonzero_mask] + eup_below_iel[nonzero_mask])))
return uptake_above
def calc_belowground_uptake(total_uptake, eup_above_iel, eup_below_iel):
"""Calculate uptake of nutrient apportioned to _belowground biomass.
Given the total amount of iel (N or P) taken up from one source, the amount
of uptake that is apportioned to belowground biomass is calculated from
the proportion of demand from above- and belowground growth.
Parameters:
total_uptake (numpy.ndarray): derived, uptake of iel from one source
eup_above_iel (numpy.ndarray): derived, iel in new aboveground growth
eup_below_iel (numpy.ndarray): derived, iel in new belowground growth
Returns:
uptake_below, uptake from one source that is apportioned to belowground
biomass
"""
valid_mask = (
(total_uptake != _TARGET_NODATA) &
(eup_above_iel != _TARGET_NODATA) &
(eup_below_iel != _TARGET_NODATA))
nonzero_mask = ((eup_above_iel + eup_below_iel > 0) & valid_mask)
uptake_below = numpy.empty(total_uptake.shape, dtype=numpy.float32)
uptake_below[valid_mask] = 0.
uptake_below[nonzero_mask] = (
total_uptake[nonzero_mask] * (
eup_below_iel[nonzero_mask] /
(eup_above_iel[nonzero_mask] + eup_below_iel[nonzero_mask])))
return uptake_below
def calc_minerl_uptake_lyr(uptake_soil, minerl_lyr_iel, fsol, availm):
"""Calculate uptake of mineral iel from one soil layer.
Uptake of mineral iel (N or P) from each soil layer into new growth
is done according to the proportion of total mineral iel contributed
by that layer.
Parameters:
uptake_soil (numpy.ndarray): derived, total uptake of N or P
from soil
minerl_lyr_iel (numpy.ndarray): state variable, mineral iel in
this soil layer
fsol (numpy.ndarray): derived, fraction of iel in solution
availm (numpy.ndarray): derived, sum of mineral iel across
soil layers accessible by this plant functional type
Returns:
minerl_uptake_lyr, uptake of iel from this soil layer
"""
valid_mask = (
(uptake_soil != _TARGET_NODATA) &
(~numpy.isclose(minerl_lyr_iel, _SV_NODATA)) &
(fsol != _TARGET_NODATA) &
(availm != _TARGET_NODATA) &
(availm > 0))
minerl_uptake_lyr = numpy.empty(uptake_soil.shape, dtype=numpy.float32)
minerl_uptake_lyr[valid_mask] = (
uptake_soil[valid_mask] * minerl_lyr_iel[valid_mask] *
fsol[valid_mask] / availm[valid_mask])
return minerl_uptake_lyr
def nutrient_uptake(
iel, nlay, fract_cover_path, eup_above_iel_path, eup_below_iel_path,
plantNfix_path, availm_path, eavail_path, pft_i, pslsrb_path,
sorpmx_path, sv_reg, delta_aglive_iel_path):
"""Calculate uptake of N or P from soil and crop storage to new growth.
Calculate flows of iel from crop storage pool, soil mineral pools, and
symbiotic N fixation into new above- and belowground biomass. Perform the
flow into belowground live, and track the change in aboveground live but
store the change in delta_aglivc_dict and do not perform the flow.
N and P taken up from the soil by one plant functional type are weighted by
the fractional cover of that functional type. Lines 124-156, Restrp.f,
lines 186-226, Growth.f
Parameters:
iel (int): index identifying N (iel=1) or P (iel=2)
nlay (int): number of soil layers accessible by this plant functional
type
fract_cover_path (string): path to raster containing fractional cover
of this plant functional type
eup_above_iel_path (string): path to raster containing iel in new
aboveground production
eup_below_iel_path (string): path to raster containing iel in new
belowground production
plantNfix_path (string): path to raster giving symbiotic N fixed by
this plant functional type
availm_path (string): path to raster giving the sum of mineral iel
across soil layers accessible by this plant functional type
eavail_path (string): path to raster giving total iel available to
this plant functional type
pft_i (int): index identifying the current pft
pslsrb_path (string): path to raster giving pslsrb paramter, slope term
controlling fraction of mineral P that is labile
sorpmx_path (string): path to raster giving sorpmx paramter, maximum P
sorption potential
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
delta_aglive_iel_path (string): path to change in iel in aboveground
live state variable for the current pft
Side effects:
modifies the rasters indicated by
sv_reg['bglive_<iel>_<pft>_path'], iel in belowground live biomass,
for the given iel and current pft
sv_reg['crpstg_<iel>_<pft>_path'], iel in crop storage, for the
given iel and current pft
sv_reg['minerl_<layer>_<iel>_path'], iel in the soil mineral pool,
for each soil layer accessible by the current pft ([1:nlay])
delta_aglive_iel_path, change in aboveground live iel for the
given iel and current pft
Returns:
None
"""
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'uptake_storage', 'uptake_soil', 'uptake_Nfix', 'statv_temp',
'uptake_above', 'uptake_below', 'fsol', 'minerl_uptake_lyr',
'uptake_weighted']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
# calculate uptake from crop storage
pft_nodata = pygeoprocessing.get_raster_info(
fract_cover_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
eavail_path, eup_above_iel_path, eup_below_iel_path,
plantNfix_path, sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)]]] +
[(iel, 'raw')],
calc_uptake_source('uptake_storage'), temp_val_dict['uptake_storage'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate uptake from soil
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
eavail_path, eup_above_iel_path, eup_below_iel_path,
plantNfix_path, sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)]]] +
[(iel, 'raw')],
calc_uptake_source('uptake_soil'), temp_val_dict['uptake_soil'],
gdal.GDT_Float32, _TARGET_NODATA)
if iel == 1:
# calculate uptake from symbiotically fixed N
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
eavail_path, eup_above_iel_path, eup_below_iel_path,
plantNfix_path,
sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)]]] +
[(iel, 'raw')],
calc_uptake_source('uptake_Nfix'), temp_val_dict['uptake_Nfix'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate uptake from crop storage into aboveground and belowground live
shutil.copyfile(
sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['statv_temp'])
raster_difference(
temp_val_dict['statv_temp'], _SV_NODATA,
temp_val_dict['uptake_storage'], _TARGET_NODATA,
sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['uptake_storage'], eup_above_iel_path,
eup_below_iel_path]],
calc_aboveground_uptake, delta_aglive_iel_path,
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['uptake_storage'], eup_above_iel_path,
eup_below_iel_path]],
calc_belowground_uptake, temp_val_dict['uptake_below'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['bglive_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['statv_temp'])
raster_sum(
temp_val_dict['statv_temp'], _SV_NODATA,
temp_val_dict['uptake_below'], _TARGET_NODATA,
sv_reg['bglive_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
# uptake from each soil layer in proportion to its contribution to availm
for lyr in range(1, nlay + 1):
if iel == 2:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_1_2_path'], sorpmx_path,
pslsrb_path]],
fsfunc, temp_val_dict['fsol'], gdal.GDT_Float32,
_TARGET_NODATA)
else:
pygeoprocessing.new_raster_from_base(
sv_reg['aglive_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['fsol'],
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[1.])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['uptake_soil'],
sv_reg['minerl_{}_{}_path'.format(lyr, iel)],
temp_val_dict['fsol'], availm_path]],
calc_minerl_uptake_lyr, temp_val_dict['minerl_uptake_lyr'],
gdal.GDT_Float32, _TARGET_NODATA)
# uptake removed from soil is weighted by pft % cover
raster_multiplication(
fract_cover_path, pft_nodata,
temp_val_dict['minerl_uptake_lyr'], _TARGET_NODATA,
temp_val_dict['uptake_weighted'], _TARGET_NODATA)
shutil.copyfile(
sv_reg['minerl_{}_{}_path'.format(lyr, iel)],
temp_val_dict['statv_temp'])
raster_difference(
temp_val_dict['statv_temp'], _SV_NODATA,
temp_val_dict['uptake_weighted'], _TARGET_NODATA,
sv_reg['minerl_{}_{}_path'.format(lyr, iel)], _SV_NODATA)
# uptake from minerl iel in lyr into above and belowground live
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['minerl_uptake_lyr'], eup_above_iel_path,
eup_below_iel_path]],
calc_aboveground_uptake, temp_val_dict['uptake_above'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(delta_aglive_iel_path, temp_val_dict['statv_temp'])
raster_sum(
temp_val_dict['statv_temp'], _SV_NODATA,
temp_val_dict['uptake_above'], _TARGET_NODATA,
delta_aglive_iel_path, _SV_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['minerl_uptake_lyr'], eup_above_iel_path,
eup_below_iel_path]],
calc_belowground_uptake, temp_val_dict['uptake_below'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['bglive_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['statv_temp'])
raster_sum(
temp_val_dict['statv_temp'], _SV_NODATA,
temp_val_dict['uptake_below'], _TARGET_NODATA,
sv_reg['bglive_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
# uptake from N fixation into above and belowground live
if iel == 1:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['uptake_Nfix'], eup_above_iel_path,
eup_below_iel_path]],
calc_aboveground_uptake, temp_val_dict['uptake_above'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(delta_aglive_iel_path, temp_val_dict['statv_temp'])
raster_sum(
temp_val_dict['statv_temp'], _SV_NODATA,
temp_val_dict['uptake_above'], _TARGET_NODATA,
delta_aglive_iel_path, _SV_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['uptake_Nfix'], eup_above_iel_path,
eup_below_iel_path]],
calc_belowground_uptake, temp_val_dict['uptake_below'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['bglive_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['statv_temp'])
raster_sum(
temp_val_dict['statv_temp'], _SV_NODATA,
temp_val_dict['uptake_below'], _TARGET_NODATA,
sv_reg['bglive_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_nutrient_limitation(return_type):
"""Calculate C, N, and P in new production given nutrient availability."""
def _nutrlm(
potenc, rtsh, eavail_1, eavail_2, snfxmx_1, cercrp_max_above_1,
cercrp_max_below_1, cercrp_max_above_2, cercrp_max_below_2,
cercrp_min_above_1, cercrp_min_below_1, cercrp_min_above_2,
cercrp_min_below_2):
"""Calculate new production limited by N and P.
Growth of new biomass is limited by the availability of N and P.
Compare nutrient availability to the demand for each nutrient, which
differs between above- and belowground production. Nutrlm.f
Parameters:
potenc (numpy.ndarray): derived, potential production of C calculated
by root:shoot ratio submodel
rtsh (numpy.ndarray): derived, root/shoot ratio of new production
eavail_1 (numpy.ndarray): derived, available N (includes predicted
symbiotic N fixation)
eavail_2 (numpy.ndarray): derived, available P
snfxmx_1 (numpy.ndarray): parameter, maximum symbiotic N fixation rate
cercrp_max_above_1 (numpy.ndarray): max C/N ratio of new aboveground
growth
cercrp_max_below_1 (numpy.ndarray): max C/N ratio of new belowground
growth
cercrp_max_above_2 (numpy.ndarray): max C/P ratio of new aboveground
growth
cercrp_max_below_2 (numpy.ndarray): max C/P ratio of new belowground
growth
cercrp_min_above_1 (numpy.ndarray): min C/N ratio of new aboveground
growth
cercrp_min_below_1 (numpy.ndarray): min C/N ratio of new belowground
growth
cercrp_min_above_2 (numpy.ndarray): min C/P ratio of new aboveground
growth
cercrp_min_below_2 (numpy.ndarray): min C/P ratio of new belowground
growth
Returns:
cprodl, total C production limited by nutrient availability,
if return_type is 'cprodl'
eup_above_1, N in new aboveground production, if return_type is
'eup_above_1'
eup_below_1, N in new belowground production, if return_type is
'eup_below_1'
eup_above_2, P in new aboveground production, if return_type is
'eup_above_2'
eup_below_2, P in new belowground production, if return_type is
'eup_below_2'
plantNfix, N fixation that actually occurs, if return_type is
'plantNfix'
"""
valid_mask = (
(potenc != _TARGET_NODATA) &
(rtsh != _TARGET_NODATA) &
(eavail_1 != _TARGET_NODATA) &
(eavail_2 != _TARGET_NODATA) &
(snfxmx_1 != _IC_NODATA) &
(cercrp_max_above_1 != _TARGET_NODATA) &
(cercrp_max_below_1 != _TARGET_NODATA) &
(cercrp_max_above_2 != _TARGET_NODATA) &
(cercrp_max_below_2 != _TARGET_NODATA) &
(cercrp_min_above_1 != _TARGET_NODATA) &
(cercrp_min_below_1 != _TARGET_NODATA) &
(cercrp_min_above_2 != _TARGET_NODATA) &
(cercrp_min_below_2 != _TARGET_NODATA))
cfrac_below = numpy.empty(potenc.shape, dtype=numpy.float32)
cfrac_below[valid_mask] = (
rtsh[valid_mask] / (rtsh[valid_mask] + 1.))
cfrac_above = numpy.empty(potenc.shape, dtype=numpy.float32)
cfrac_above[valid_mask] = 1. - cfrac_below[valid_mask]
# maxec is average e/c ratio across aboveground and belowground
# maxeci is indexed to aboveground only or belowground only
maxeci_above_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
mineci_above_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
maxeci_below_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
mineci_below_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
maxeci_above_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
mineci_above_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
maxeci_below_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
mineci_below_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
maxeci_above_1[valid_mask] = 1. / cercrp_min_above_1[valid_mask]
mineci_above_1[valid_mask] = 1. / cercrp_max_above_1[valid_mask]
maxeci_below_1[valid_mask] = 1. / cercrp_min_below_1[valid_mask]
mineci_below_1[valid_mask] = 1. / cercrp_max_below_1[valid_mask]
maxeci_above_2[valid_mask] = 1. / cercrp_min_above_2[valid_mask]
mineci_above_2[valid_mask] = 1. / cercrp_max_above_2[valid_mask]
maxeci_below_2[valid_mask] = 1. / cercrp_min_below_2[valid_mask]
mineci_below_2[valid_mask] = 1. / cercrp_max_below_2[valid_mask]
maxec_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
maxec_1[valid_mask] = (
cfrac_below[valid_mask] * maxeci_below_1[valid_mask] +
cfrac_above[valid_mask] * maxeci_above_1[valid_mask])
maxec_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
maxec_2[valid_mask] = (
cfrac_below[valid_mask] * maxeci_below_2[valid_mask] +
cfrac_above[valid_mask] * maxeci_above_2[valid_mask])
# N/C ratio in new production according to demand and supply
demand_1 = numpy.zeros(potenc.shape, dtype=numpy.float32)
demand_1[valid_mask] = potenc[valid_mask] * maxec_1[valid_mask]
ecfor_above_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
ecfor_below_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
nonzero_mask = ((demand_1 > 0) & valid_mask)
ecfor_above_1[valid_mask] = 0.
ecfor_below_1[valid_mask] = 0.
ecfor_above_1[nonzero_mask] = (
mineci_above_1[nonzero_mask] +
(maxeci_above_1[nonzero_mask] - mineci_above_1[nonzero_mask]) *
eavail_1[nonzero_mask] / demand_1[nonzero_mask])
ecfor_below_1[nonzero_mask] = (
mineci_below_1[nonzero_mask] +
(maxeci_below_1[nonzero_mask] - mineci_below_1[nonzero_mask]) *
eavail_1[nonzero_mask] / demand_1[nonzero_mask])
sufficient_mask = ((eavail_1 > demand_1) & valid_mask)
ecfor_above_1[sufficient_mask] = maxeci_above_1[sufficient_mask]
ecfor_below_1[sufficient_mask] = maxeci_below_1[sufficient_mask]
# caculate C production limited by N supply
c_constrained_1 = numpy.zeros(potenc.shape, dtype=numpy.float32)
c_constrained_1[nonzero_mask] = (
eavail_1[nonzero_mask] / (
cfrac_below[nonzero_mask] * ecfor_below_1[nonzero_mask] +
cfrac_above[nonzero_mask] * ecfor_above_1[nonzero_mask]))
# P/C ratio in new production according to demand and supply
demand_2 = numpy.zeros(potenc.shape, dtype=numpy.float32)
demand_2[valid_mask] = potenc[valid_mask] * maxec_2[valid_mask]
ecfor_above_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
ecfor_below_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
nonzero_mask = ((demand_2 > 0) & valid_mask)
ecfor_above_2[valid_mask] = 0.
ecfor_below_2[valid_mask] = 0.
ecfor_above_2[nonzero_mask] = (
mineci_above_2[nonzero_mask] +
(maxeci_above_2[nonzero_mask] - mineci_above_2[nonzero_mask]) *
eavail_2[nonzero_mask] / demand_2[nonzero_mask])
ecfor_below_2[nonzero_mask] = (
mineci_below_2[nonzero_mask] +
(maxeci_below_2[nonzero_mask] - mineci_below_2[nonzero_mask]) *
eavail_2[nonzero_mask] / demand_2[nonzero_mask])
sufficient_mask = ((eavail_2 > demand_2) & valid_mask)
ecfor_above_2[sufficient_mask] = maxeci_above_2[sufficient_mask]
ecfor_below_2[sufficient_mask] = maxeci_below_2[sufficient_mask]
# caculate C production limited by P supply
c_constrained_2 = numpy.zeros(potenc.shape, dtype=numpy.float32)
c_constrained_2[nonzero_mask] = (
eavail_2[nonzero_mask] / (
cfrac_below[nonzero_mask] * ecfor_below_2[nonzero_mask] +
cfrac_above[nonzero_mask] * ecfor_above_2[nonzero_mask]))
# C production limited by both N and P
cprodl = numpy.empty(potenc.shape, dtype=numpy.float32)
cprodl[:] = _TARGET_NODATA
cprodl[valid_mask] = numpy.minimum(
c_constrained_1[valid_mask],
c_constrained_2[valid_mask])
cprodl[valid_mask] = numpy.minimum(
cprodl[valid_mask], potenc[valid_mask])
# N uptake into new production, given limited C production
eup_above_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
eup_below_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
eup_above_1[:] = _TARGET_NODATA
eup_below_1[:] = _TARGET_NODATA
eup_above_1[valid_mask] = (
cprodl[valid_mask] * cfrac_above[valid_mask] *
ecfor_above_1[valid_mask])
eup_below_1[valid_mask] = (
cprodl[valid_mask] * cfrac_below[valid_mask] *
ecfor_below_1[valid_mask])
# P uptake into new production, given limited C production
eup_above_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
eup_below_2 = numpy.empty(potenc.shape, dtype=numpy.float32)
eup_above_2[:] = _TARGET_NODATA
eup_below_2[:] = _TARGET_NODATA
eup_above_2[valid_mask] = (
cprodl[valid_mask] * cfrac_above[valid_mask] *
ecfor_above_2[valid_mask])
eup_below_2[valid_mask] = (
cprodl[valid_mask] * cfrac_below[valid_mask] *
ecfor_below_2[valid_mask])
# Calculate N fixation that occurs to subsidize needed N supply
maxNfix = numpy.empty(potenc.shape, dtype=numpy.float32)
maxNfix[:] = _TARGET_NODATA
maxNfix[valid_mask] = snfxmx_1[valid_mask] * potenc[valid_mask]
eprodl_1 = numpy.empty(potenc.shape, dtype=numpy.float32)
eprodl_1[:] = _TARGET_NODATA
eprodl_1[valid_mask] = (
eup_above_1[valid_mask] + eup_below_1[valid_mask])
Nfix_mask = (
(eprodl_1 - (eavail_1 + maxNfix) > 0.05) &
valid_mask)
eprodl_1[Nfix_mask] = eavail_1[Nfix_mask] + maxNfix[Nfix_mask]
plantNfix = numpy.empty(potenc.shape, dtype=numpy.float32)
plantNfix[:] = _TARGET_NODATA
plantNfix[valid_mask] = numpy.maximum(
eprodl_1[valid_mask] - eavail_1[valid_mask], 0.)
if return_type == 'cprodl':
return cprodl
elif return_type == 'eup_above_1':
return eup_above_1
elif return_type == 'eup_below_1':
return eup_below_1
elif return_type == 'eup_above_2':
return eup_above_2
elif return_type == 'eup_below_2':
return eup_below_2
elif return_type == 'plantNfix':
return plantNfix
return _nutrlm
def _new_growth(
pft_id_set, aligned_inputs, site_param_table, veg_trait_table,
month_reg, current_month, sv_reg):
"""Growth of new aboveground and belowground biomass.
Calculate new growth of aboveground and belowground live biomass. New
growth is added to belowground live biomass, but is not added to
aboveground live biomass because grazing offtake must be calculated
relative to biomass before new growth is applied.
C is taken up from the atmosphere, while N and P are taken up from the crop
storage pool, soil mineral N and P content, and symbiotic N fixation. N and
P taken up from the soil are weighted by the fractional cover of the plant
functional type.
Parameters:
pft_id_set (set): set of integers identifying plant functional types
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fractional cover of each plant
functional type
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
current_month (int): month of the year, such that current_month=1
indicates January
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
modifies the rasters indicated by
sv_reg['bglivc_<pft>_path'] for each pft
sv_reg['bglive_1_<pft>_path'] for each pft
sv_reg['bglive_2_<pft>_path'] for each pft
sv_reg['crpstg_1_<pft>_path'] for each pft
sv_reg['crpstg_2_<pft>_path'] for each pft
sv_reg['minerl_{layer}_1_path'] for each soil layer
sv_reg['minerl_{layer}_2_path'] for each soil layer
Returns:
dictionary of key, path pairs indicating paths to rasters containing
change in aboveground live state variables, with the following keys:
- 'delta_aglivc_<pft>': change in aboveground live C for each pft
- 'delta_aglive_1_<pft>': change in aboveground live N for each pft
- 'delta_aglive_2_<pft>': change in aboveground live P for each pft
"""
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in ['statv_temp']:
target_path = os.path.join(
temp_dir, '{}.tif'.format(val))
temp_val_dict['{}'.format(val)] = target_path
for val in [
'availm_1', 'availm_2', 'eavail_1', 'eavail_2', 'potenc',
'potenc_lim_minerl', 'cprodl', 'eup_above_1', 'eup_below_1',
'eup_above_2', 'eup_below_2', 'plantNfix']:
for pft_i in pft_id_set:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
temp_val_dict['{}_{}'.format(val, pft_i)] = target_path
# track change in aboveground live state variables for each pft
delta_sv_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
delta_agliv_dict = {}
for val in ['delta_aglivc', 'delta_aglive_1', 'delta_aglive_2']:
for pft_i in pft_id_set:
target_path = os.path.join(
delta_sv_dir, '{}_{}.tif'.format(val, pft_i))
delta_agliv_dict['{}_{}'.format(val, pft_i)] = target_path
param_val_dict = {}
# site-level parameters
for val in [
'favail_1', 'favail_4', 'favail_5', 'favail_6', 'pslsrb',
'sorpmx']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
param_val_dict['favail_2'] = os.path.join(temp_dir, 'favail_2.tif')
_calc_favail_P(sv_reg, param_val_dict)
# pft-level parameters
for pft_i in pft_id_set:
for val in ['snfxmx_1']:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
sv_reg['aglivc_{}_path'.format(pft_i)], target_path,
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
for pft_i in pft_id_set:
if current_month != veg_trait_table[pft_i]['senescence_month']:
# calculate available nutrients for all pfts prior to
# performing uptake
for iel in [1, 2]:
_calc_avail_mineral_nutrient(
veg_trait_table[pft_i], sv_reg, iel,
temp_val_dict['availm_{}_{}'.format(iel, pft_i)])
for pft_i in pft_id_set:
# growth occurs in growth months and when senescence not scheduled
do_growth = (
current_month != veg_trait_table[pft_i]['senescence_month'] and
str(current_month) in veg_trait_table[pft_i]['growth_months'])
if do_growth:
# calculate available nutrients
for iel in [1, 2]:
# eavail_iel, available nutrient
_calc_available_nutrient(
pft_i, iel, veg_trait_table[pft_i], sv_reg,
site_param_table, aligned_inputs['site_index'],
temp_val_dict['availm_{}_{}'.format(iel, pft_i)],
param_val_dict['favail_{}'.format(iel)],
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['eavail_{}_{}'.format(iel, pft_i)])
# convert from grams of biomass to grams of carbon
convert_biomass_to_C(
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['potenc_{}'.format(pft_i)])
# restrict potential growth by availability of N and P
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['potenc_{}'.format(pft_i)],
temp_val_dict['availm_1_{}'.format(pft_i)],
temp_val_dict['availm_2_{}'.format(pft_i)],
param_val_dict['snfxmx_1_{}'.format(pft_i)]]],
restrict_potential_growth,
temp_val_dict['potenc_lim_minerl_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['potenc_lim_minerl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
param_val_dict['snfxmx_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_1_{}'.format(pft_i)],
month_reg['cercrp_max_below_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_2_{}'.format(pft_i)],
month_reg['cercrp_max_below_2_{}'.format(pft_i)],
month_reg['cercrp_min_above_1_{}'.format(pft_i)],
month_reg['cercrp_min_below_1_{}'.format(pft_i)],
month_reg['cercrp_min_above_2_{}'.format(pft_i)],
month_reg['cercrp_min_below_2_{}'.format(pft_i)]]],
calc_nutrient_limitation('cprodl'),
temp_val_dict['cprodl_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['potenc_lim_minerl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
param_val_dict['snfxmx_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_1_{}'.format(pft_i)],
month_reg['cercrp_max_below_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_2_{}'.format(pft_i)],
month_reg['cercrp_max_below_2_{}'.format(pft_i)],
month_reg['cercrp_min_above_1_{}'.format(pft_i)],
month_reg['cercrp_min_below_1_{}'.format(pft_i)],
month_reg['cercrp_min_above_2_{}'.format(pft_i)],
month_reg['cercrp_min_below_2_{}'.format(pft_i)]]],
calc_nutrient_limitation('eup_above_1'),
temp_val_dict['eup_above_1_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['potenc_lim_minerl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
param_val_dict['snfxmx_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_1_{}'.format(pft_i)],
month_reg['cercrp_max_below_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_2_{}'.format(pft_i)],
month_reg['cercrp_max_below_2_{}'.format(pft_i)],
month_reg['cercrp_min_above_1_{}'.format(pft_i)],
month_reg['cercrp_min_below_1_{}'.format(pft_i)],
month_reg['cercrp_min_above_2_{}'.format(pft_i)],
month_reg['cercrp_min_below_2_{}'.format(pft_i)]]],
calc_nutrient_limitation('eup_below_1'),
temp_val_dict['eup_below_1_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['potenc_lim_minerl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
param_val_dict['snfxmx_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_1_{}'.format(pft_i)],
month_reg['cercrp_max_below_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_2_{}'.format(pft_i)],
month_reg['cercrp_max_below_2_{}'.format(pft_i)],
month_reg['cercrp_min_above_1_{}'.format(pft_i)],
month_reg['cercrp_min_below_1_{}'.format(pft_i)],
month_reg['cercrp_min_above_2_{}'.format(pft_i)],
month_reg['cercrp_min_below_2_{}'.format(pft_i)]]],
calc_nutrient_limitation('eup_above_2'),
temp_val_dict['eup_above_2_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['potenc_lim_minerl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
param_val_dict['snfxmx_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_1_{}'.format(pft_i)],
month_reg['cercrp_max_below_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_2_{}'.format(pft_i)],
month_reg['cercrp_max_below_2_{}'.format(pft_i)],
month_reg['cercrp_min_above_1_{}'.format(pft_i)],
month_reg['cercrp_min_below_1_{}'.format(pft_i)],
month_reg['cercrp_min_above_2_{}'.format(pft_i)],
month_reg['cercrp_min_below_2_{}'.format(pft_i)]]],
calc_nutrient_limitation('eup_below_2'),
temp_val_dict['eup_below_2_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['potenc_lim_minerl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
param_val_dict['snfxmx_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_1_{}'.format(pft_i)],
month_reg['cercrp_max_below_1_{}'.format(pft_i)],
month_reg['cercrp_max_above_2_{}'.format(pft_i)],
month_reg['cercrp_max_below_2_{}'.format(pft_i)],
month_reg['cercrp_min_above_1_{}'.format(pft_i)],
month_reg['cercrp_min_below_1_{}'.format(pft_i)],
month_reg['cercrp_min_above_2_{}'.format(pft_i)],
month_reg['cercrp_min_below_2_{}'.format(pft_i)]]],
calc_nutrient_limitation('plantNfix'),
temp_val_dict['plantNfix_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate uptake of C into new aboveground production
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['cprodl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)]]],
c_uptake_aboveground,
delta_agliv_dict['delta_aglivc_{}'.format(pft_i)],
gdal.GDT_Float32, _SV_NODATA)
# do uptake of C into new belowground production
shutil.copyfile(
sv_reg['bglivc_{}_path'.format(pft_i)],
temp_val_dict['statv_temp'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['statv_temp'],
temp_val_dict['cprodl_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)]]],
c_uptake_belowground, sv_reg['bglivc_{}_path'.format(pft_i)],
gdal.GDT_Float32, _SV_NODATA)
# calculate uptake of N and P into new aboveground production,
# do uptake of N and P into new belowground production
for iel in [1, 2]:
nutrient_uptake(
iel, int(veg_trait_table[pft_i]['nlaypg']),
aligned_inputs['pft_{}'.format(pft_i)],
temp_val_dict['eup_above_{}_{}'.format(iel, pft_i)],
temp_val_dict['eup_below_{}_{}'.format(iel, pft_i)],
temp_val_dict['plantNfix_{}'.format(pft_i)],
temp_val_dict['availm_{}_{}'.format(iel, pft_i)],
temp_val_dict['eavail_{}_{}'.format(iel, pft_i)],
pft_i, param_val_dict['pslsrb'],
param_val_dict['sorpmx'], sv_reg,
delta_agliv_dict['delta_aglive_{}_{}'.format(iel, pft_i)])
else:
# no growth scheduled this month
for val in ['delta_aglivc', 'delta_aglive_1', 'delta_aglive_2']:
pygeoprocessing.new_raster_from_base(
sv_reg['aglivc_{}_path'.format(pft_i)],
delta_agliv_dict['{}_{}'.format(val, pft_i)],
gdal.GDT_Float32, [_SV_NODATA], fill_value_list=[0])
# clean up temporary files
shutil.rmtree(temp_dir)
return delta_agliv_dict
def _apply_new_growth(delta_agliv_dict, pft_id_set, sv_reg):
"""Update aboveground live biomass with new growth.
Use the delta state variable quantities in `delta_agliv_dict` to update
state variables in `sv_reg` with new growth.
Parameters:
delta_agliv_dict (dict): map of key, path pairs indicating paths to
change in aboveground live state variables for the current month
pft_id_set (set): set of integers identifying plant functional types
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
modifies the rasters indicated by
sv_reg['aglivc_<pft>_path'] for each pft
sv_reg['aglive_1_<pft>_path'] for each pft
sv_reg['aglive_2_<pft>_path'] for each pft
Returns:
None
"""
with tempfile.NamedTemporaryFile(
prefix='statv_temp', dir=PROCESSING_DIR) as statv_temp_file:
statv_temp_path = statv_temp_file.name
for pft_i in pft_id_set:
for sv in ['aglivc', 'aglive_1', 'aglive_2']:
shutil.copyfile(
sv_reg['{}_{}_path'.format(sv, pft_i)], statv_temp_path)
raster_sum(
delta_agliv_dict['delta_{}_{}'.format(sv, pft_i)], _SV_NODATA,
statv_temp_path, _SV_NODATA,
sv_reg['{}_{}_path'.format(sv, pft_i)], _SV_NODATA)
# clean up
pathlist = list(delta_agliv_dict)
delta_agliv_dir = os.path.dirname(delta_agliv_dict[pathlist[0]])
shutil.rmtree(delta_agliv_dir)
os.remove(statv_temp_path)
def calc_amount_leached(minlch, amov_lyr, frlech, minerl_lyr_iel):
"""Calculate amount of mineral nutrient leaching from one soil layer.
The amount of mineral N or P leaching from a soil layer into the adjacent
soil layer below depends on the potential fraction of mineral leaching, the
amount of saturated water flow between the two layers, and the mineral
nutrient content of the above layer.
Parameters:
minlch (numpy.ndarray): parameter, critical water flow for leaching of
minerals (cm of H2O leached below 30 cm soil depth)
amov_lyr (numpy.ndarray): derived, saturated water flow from the
current layer
frlech (numpy.ndarray): derived, potential fraction of mineral leaching
minerl_lyr_iel (numpy.ndarray): state variable, mineral N or P in the
current layer
Returns:
amount_leached, mineral N or P leaching from the current soil layer to
the next adjacent soil layer
"""
valid_mask = (
(minlch != _IC_NODATA) &
(amov_lyr != _TARGET_NODATA) &
(frlech != _TARGET_NODATA) &
(~numpy.isclose(minerl_lyr_iel, _SV_NODATA)))
linten = numpy.clip(
1. - (minlch[valid_mask] - amov_lyr[valid_mask]) / minlch[valid_mask],
0., 1.)
amount_leached = numpy.empty(minlch.shape, dtype=numpy.float32)
amount_leached[:] = _TARGET_NODATA
amount_leached[valid_mask] = (
frlech[valid_mask] * minerl_lyr_iel[valid_mask] * linten)
return amount_leached
def _leach(aligned_inputs, site_param_table, month_reg, sv_reg):
"""Simulate the movement of N and P through soil layers by leaching.
Mineral nutrients are carried downward through soil layers if there is
saturated flow of water flowing between layers.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fraction of sand and site
spatial index
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels, including
saturated flow of water between soil layers
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
Side effects:
modifies the raster indicated by sv_reg['minerl_<lyr>_1'], mineral N in
the soil layer, for each soil layer
modofies the raster indicated by sv_reg['minerl_<lyr>_2'], mineral P in
the soil layer, for each soil layer
Returns:
None
"""
def calc_frlech_N(fleach_1, fleach_2, sand, fleach_3):
"""Calculate the potential fraction of N leaching.
Mineral N and P leach from each soil layer to the adjacent layer if
there is saturated water flow between the two layers and if there is
mineral nutrient in the donating layer to flow. With higher soil sand
content, the potential fraction of nutrient that leaches is higher.
Parameters:
fleach_1 (numpy.ndarray): parameter, intercept giving the fraction
of N or P that leaches to the next layer if there is saturated
water flow
fleach_2 (numpy.ndarray): parameter, slope value giving the
fraction of N or P that leaches to the next layer if there is
saturated water flow
sand (numpy.ndarray): input, fraction of soil that is sand
fleach_3 (numpy.ndarray): parameter, leaching fraction multiplier
specific to N.
Returns:
frlech_N, the potential fraction of mineral N leaching
"""
valid_mask = (
(fleach_1 != _IC_NODATA) &
(fleach_2 != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)) &
(fleach_3 != _IC_NODATA))
frlech_N = numpy.empty(fleach_1.shape, dtype=numpy.float32)
frlech_N[:] = _TARGET_NODATA
frlech_N[valid_mask] = (
(fleach_1[valid_mask] + fleach_2[valid_mask] * sand[valid_mask]) *
fleach_3[valid_mask])
return frlech_N
def calc_frlech_P(fleach_1, fleach_2, sand, fleach_4, fsol):
"""Calculate the potential fraction of P leaching.
Mineral N and P leach from each soil layer to the adjacent layer if
there is saturated water flow between the two layers and if there is
mineral nutrient in the donating layer to flow. With higher soil sand
content, the potential fraction of nutrient that leaches is higher.
Parameters:
fleach_1 (numpy.ndarray): parameter, intercept giving the fraction
of N or P that leaches to the next layer if there is saturated
water flow
fleach_2 (numpy.ndarray): parameter, slope value giving the
fraction of N or P that leaches to the next layer if there is
saturated water flow
sand (numpy.ndarray): input, fraction of soil that is sand
fleach_4 (numpy.ndarray): parameter, leaching fraction multiplier
specific to P.
fsol (numpy.ndarray): derived, fraction of P in solution
Returns:
frlech_P, the potential fraction of mineral P leaching
"""
valid_mask = (
(fleach_1 != _IC_NODATA) &
(fleach_2 != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)) &
(fleach_4 != _IC_NODATA) &
(fsol != _TARGET_NODATA))
frlech_P = numpy.empty(fleach_1.shape, dtype=numpy.float32)
frlech_P[:] = _TARGET_NODATA
frlech_P[valid_mask] = (
(fleach_1[valid_mask] + fleach_2[valid_mask] * sand[valid_mask]) *
fleach_4[valid_mask] * fsol[valid_mask])
return frlech_P
nlayer_max = int(max(val['nlayer'] for val in site_param_table.values()))
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'fsol', 'frlech_1', 'frlech_2', 'amount_leached', 'd_statv_temp']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
for val in [
'sorpmx', 'pslsrb', 'minlch', 'fleach_1', 'fleach_2', 'fleach_3',
'fleach_4']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
sand_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['sand'])['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['fleach_1'], param_val_dict['fleach_2'],
aligned_inputs['sand'], param_val_dict['fleach_3']]],
calc_frlech_N, temp_val_dict['frlech_1'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_1_2_path'], param_val_dict['sorpmx'],
param_val_dict['pslsrb']]],
fsfunc, temp_val_dict['fsol'], gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['fleach_1'], param_val_dict['fleach_2'],
aligned_inputs['sand'], param_val_dict['fleach_4'],
temp_val_dict['fsol']]],
calc_frlech_P, temp_val_dict['frlech_2'], gdal.GDT_Float32,
_TARGET_NODATA)
for iel in [1, 2]:
for lyr in range(1, nlayer_max + 1):
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['minlch'], month_reg['amov_{}'.format(lyr)],
temp_val_dict['frlech_{}'.format(iel)],
sv_reg['minerl_{}_{}_path'.format(lyr, iel)]]],
calc_amount_leached, temp_val_dict['amount_leached'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['minerl_{}_{}_path'.format(lyr, iel)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['amount_leached'], _TARGET_NODATA,
sv_reg['minerl_{}_{}_path'.format(lyr, iel)], _SV_NODATA)
if lyr != nlayer_max:
shutil.copyfile(
sv_reg['minerl_{}_{}_path'.format(lyr + 1, iel)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['amount_leached'], _TARGET_NODATA,
sv_reg['minerl_{}_{}_path'.format(lyr + 1, iel)],
_SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_c_removed(c_state_variable, percent_removed):
"""Calculate C consumed by grazing.
Parameters:
c_state_variable (numpy.ndarray): state variable, C in state variable
consumed by grazing
percent_removed (numpy.ndarray): derived, percent of state variable
consumed by grazing
Returns:
c_consumed, C in the given state variable consumed by grazing
"""
valid_mask = (~numpy.isclose(c_state_variable, _SV_NODATA))
consumed_mask = ((percent_removed != _TARGET_NODATA) & valid_mask)
c_consumed = numpy.empty(c_state_variable.shape, dtype=numpy.float32)
c_consumed[:] = _TARGET_NODATA
c_consumed[valid_mask] = 0.
c_consumed[consumed_mask] = (
c_state_variable[consumed_mask] * percent_removed[consumed_mask])
return c_consumed
def calc_iel_removed(c_consumed, iel_state_variable, c_state_variable):
"""Calculate N or P consumed by grazing.
N or P in a state variable consumed by grazing is calculated according to
its proportional content relative to carbon in the material consumed, and
the amount of carbon consumed.
Parameters:
c_consumed (numpy.ndarray): derived, C in the given state variable
consumed by grazing
iel_state_variable (numpy.ndarray): state variable, iel (N or P) in
state variable consumed by grazing
c_state_variable (numpy.ndarray): state variable, C in state variable
consumed by grazing
Returns:
iel_consumed, N or P in the given state variable consumed by grazing
"""
valid_mask = (
(c_consumed != _TARGET_NODATA) &
(~numpy.isclose(iel_state_variable, _SV_NODATA)) &
(~numpy.isclose(c_state_variable, _SV_NODATA)) &
(c_state_variable > 0))
iel_consumed = numpy.empty(c_consumed.shape, dtype=numpy.float32)
iel_consumed[:] = _TARGET_NODATA
iel_consumed[valid_mask] = (
c_consumed[valid_mask] * (
iel_state_variable[valid_mask] / c_state_variable[valid_mask]))
return iel_consumed
def _grazing(
aligned_inputs, site_param_table, month_reg, animal_trait_table,
pft_id_set, sv_reg):
"""Perform offtake of biomass and return of nutrients by herbivores.
Biomass consumed by herbivores is removed from aboveground live biomass
and standing dead biomass. The return of C, N and P in feces are
partitioned into surface structural and metabolic material, while N and P
in urine are returned to the surface mineral pool.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fraction of clay
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels, including
flgrem_<pft>, the fraction of live biomass of one pft removed by
grazing, and fdgrem_<pft>, the fraction of standing dead biomass
of one pft removed by grazing
animal_trait_table (dict): dictionary containing animal parameters
pft_id_set (set): set of integers identifying plant functional types
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
Side effects:
modifies the rasters indicated by
sv_reg['aglivc_<pft>_path'] for each pft
sv_reg['aglive_1_<pft>_path'] for each pft
sv_reg['aglive_2_<pft>_path'] for each pft
sv_reg['stdedc_<pft>_path'] for each pft
sv_reg['stdede_1_<pft>_path'] for each pft
sv_reg['stdede_2_<pft>_path'] for each pft
sv_reg['minerl_1_1_path']
sv_reg['minerl_1_2_path']
sv_reg['metabc_1_path']
sv_reg['strucc_1_path']
sv_reg['metabe_1_1_path']
sv_reg['metabe_1_2_path']
sv_reg['struce_1_1_path']
sv_reg['struce_1_2_path']
sv_reg['strlig_1_path']
Returns:
None
"""
def calc_gret_1(clay):
"""Calculate the fraction of consumed N returned in feces and urine.
The fraction of N consumed by animals that is returned in feces and
urine is linearly related soil clay content, bounded to be between
0.7 and 0.85.
Parameters:
clay (numpy.ndarray): input, soil clay fraction
Returns:
gret_1, fraction of consumed N that is returned in feces and urine
"""
valid_mask = (~numpy.isclose(clay, clay_nodata))
gret_1 = numpy.empty(clay.shape, dtype=numpy.float32)
gret_1[:] = _IC_NODATA
gret_1[valid_mask] = numpy.clip(
((0.85 - 0.7) / 0.3 * (clay[valid_mask] - 0.3) + 0.85), 0.7, 0.85)
return gret_1
def calc_weighted_c_returned(shremc, sdremc, gfcret, pft_cover):
"""Calculate carbon returned in feces from grazing of one pft.
The fraction of carbon removed by herbivores that is returned in their
feces is given by the parameter gfcret. Because carbon returned in
feces is partitioned into soil structural and metabolic pools, carbon
returned from grazing of one plant functional type (pft) must be
weighted by the fractional cover of the pft.
Parameters:
shremc (numpy.ndarray): derived, C in aboveground live biomass
removed by grazing
sdremc (numpy.ndarray): derived, C in standing dead biomass removed
by grazing
gfcret (numpy.ndarray): parameter, fraction of consumed C that is
returned in feces
pft_cover (numpy.ndarray): input, fractional cover of this plant
functional type
Returns:
weighted_c_returned, carbon returned from grazing of this plant
functional type
"""
valid_mask = (
(shremc != _TARGET_NODATA) &
(sdremc != _TARGET_NODATA) &
(gfcret != _IC_NODATA) &
(~numpy.isclose(pft_cover, pft_nodata)))
weighted_c_returned = numpy.empty(shremc.shape, dtype=numpy.float32)
weighted_c_returned[:] = _TARGET_NODATA
weighted_c_returned[valid_mask] = (
(gfcret[valid_mask] * (shremc[valid_mask] + sdremc[valid_mask]) *
pft_cover[valid_mask]))
return weighted_c_returned
def calc_weighted_iel_returned_feces(
shreme, sdreme, gret, fecf, pft_cover):
"""Calculate N or P returned in feces from grazing of one pft.
The fraction of N or P removed by herbivores that is returned in their
feces is calculated from the parameters gret_<iel> and fecf_<iel>.
Nutrients returned in feces from grazing of one functional type (pft)
are partitioned into soil structural and metabolic pools, so they
must be weighted by the fractional cover of the pft.
Parameters:
shreme (numpy.ndarray): derived, iel in aboveground live biomass
removed by grazing
sdreme (numpy.ndarray): derived, iel in standing dead biomass
removed by grazing
gret (numpy.ndarray): parameter, fraction of consumed iel that is
returned
fecf (numpy.ndarray): parameter, fraction of consumed iel that is
returned in feces
pft_cover (numpy.ndarray): input, fractional cover of this plant
functional type
Returns:
weighted_iel_returned_feces, N or P returned in feces
"""
valid_mask = (
(shreme != _TARGET_NODATA) &
(sdreme != _TARGET_NODATA) &
(gret != _IC_NODATA) &
(fecf != _IC_NODATA) &
(~numpy.isclose(pft_cover, pft_nodata)))
weighted_iel_returned_feces = numpy.empty(
shreme.shape, dtype=numpy.float32)
weighted_iel_returned_feces[:] = _TARGET_NODATA
weighted_iel_returned_feces[valid_mask] = (
fecf[valid_mask] * gret[valid_mask] *
(shreme[valid_mask] + sdreme[valid_mask]) * pft_cover[valid_mask])
return weighted_iel_returned_feces
def calc_weighted_iel_returned_urine(
shreme, sdreme, gret, fecf, pft_cover):
"""Calculate N or P returned in urine from grazing of one pft.
While N and P returned by herbivores in feces is partitioned into
soil structural and metabolic pools, N and P returned in urine flows
directly to the surface mineral pool. The amount of N and P returned in
urine is determined according to the complement of the parameter fecf,
the fraction of N and P returned in feces.
Parameters:
shreme (numpy.ndarray): derived, iel in aboveground live biomass
removed by grazing
sdreme (numpy.ndarray): derived, iel in standing dead biomass
removed by grazing
gret (numpy.ndarray): parameter, fraction of consumed iel that is
returned
fecf (numpy.ndarray): parameter, fraction of consumed iel that is
returned in feces
pft_cover (numpy.ndarray): input, fractional cover of this plant
functional type
Returns:
weighted_iel_returned_urine, N or P returned in urine
"""
valid_mask = (~numpy.isclose(pft_cover, pft_nodata))
consumed_mask = (
(shreme != _TARGET_NODATA) &
(sdreme != _TARGET_NODATA) &
(gret != _IC_NODATA) &
(fecf != _IC_NODATA) &
valid_mask)
weighted_iel_returned_urine = numpy.empty(
shreme.shape, dtype=numpy.float32)
weighted_iel_returned_urine[:] = _TARGET_NODATA
weighted_iel_returned_urine[valid_mask] = 0.
weighted_iel_returned_urine[consumed_mask] = (
(1. - fecf[consumed_mask]) * gret[consumed_mask] *
(shreme[consumed_mask] + sdreme[consumed_mask]) *
pft_cover[consumed_mask])
return weighted_iel_returned_urine
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'd_statv_temp', 'shremc', 'sdremc', 'shreme', 'sdreme',
'weighted_iel_urine', 'sum_weighted_C_returned',
'sum_weighted_N_returned', 'sum_weighted_P_returned']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
for val in [
'weighted_C_feces', 'weighted_iel_feces_1',
'weighted_iel_feces_2']:
for pft_i in pft_id_set:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict = {}
param_val_dict['gret_1'] = os.path.join(temp_dir, 'gret_1.tif')
for val in ['gfcret', 'gret_2', 'fecf_1', 'fecf_2', 'feclig']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
animal_to_val = dict(
[(animal_code, float(table[val])) for
(animal_code, table) in animal_trait_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['animal_index'], 1), animal_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
clay_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['clay'])['nodata'][0]
pygeoprocessing.raster_calculator(
[(aligned_inputs['clay'], 1)],
calc_gret_1, param_val_dict['gret_1'], gdal.GDT_Float32, _IC_NODATA)
weighted_C_returned_list = []
weighted_N_returned_list = []
weighted_P_returned_list = []
for pft_i in pft_id_set:
# calculate C consumed
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['aglivc_{}_path'.format(pft_i)],
month_reg['flgrem_{}'.format(pft_i)]]],
calc_c_removed, temp_val_dict['shremc'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['stdedc_{}_path'.format(pft_i)],
month_reg['fdgrem_{}'.format(pft_i)]]],
calc_c_removed, temp_val_dict['sdremc'], gdal.GDT_Float32,
_TARGET_NODATA)
# calculate C returned in feces
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['shremc'], temp_val_dict['sdremc'],
param_val_dict['gfcret'],
aligned_inputs['pft_{}'.format(pft_i)]]],
calc_weighted_c_returned,
temp_val_dict['weighted_C_feces_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
weighted_C_returned_list.append(
temp_val_dict['weighted_C_feces_{}'.format(pft_i)])
# calculate N and P consumed
for iel in [1, 2]:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['shremc'],
sv_reg['aglive_{}_{}_path'.format(iel, pft_i)],
sv_reg['aglivc_{}_path'.format(pft_i)]]],
calc_iel_removed, temp_val_dict['shreme'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sdremc'],
sv_reg['stdede_{}_{}_path'.format(iel, pft_i)],
sv_reg['stdedc_{}_path'.format(pft_i)]]],
calc_iel_removed, temp_val_dict['sdreme'], gdal.GDT_Float32,
_TARGET_NODATA)
shutil.copyfile(
sv_reg['aglive_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['shreme'], _TARGET_NODATA,
sv_reg['aglive_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
shutil.copyfile(
sv_reg['stdede_{}_{}_path'.format(iel, pft_i)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['sdreme'], _TARGET_NODATA,
sv_reg['stdede_{}_{}_path'.format(iel, pft_i)], _SV_NODATA)
# calculate N or P returned in feces
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['shreme'], temp_val_dict['sdreme'],
param_val_dict['gret_{}'.format(iel)],
param_val_dict['fecf_{}'.format(iel)],
aligned_inputs['pft_{}'.format(pft_i)]]],
calc_weighted_iel_returned_feces,
temp_val_dict['weighted_iel_feces_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
if iel == 1:
weighted_N_returned_list.append(
temp_val_dict['weighted_iel_feces_{}_{}'.format(
iel, pft_i)])
else:
weighted_P_returned_list.append(
temp_val_dict['weighted_iel_feces_{}_{}'.format(
iel, pft_i)])
# calculate N or P returned in urine
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['shreme'], temp_val_dict['sdreme'],
param_val_dict['gret_{}'.format(iel)],
param_val_dict['fecf_{}'.format(iel)],
aligned_inputs['pft_{}'.format(pft_i)]]],
calc_weighted_iel_returned_urine,
temp_val_dict['weighted_iel_urine'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['minerl_1_{}_path'.format(iel)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['weighted_iel_urine'], _TARGET_NODATA,
sv_reg['minerl_1_{}_path'.format(iel)], _SV_NODATA)
# remove consumed biomass from C state variables
shutil.copyfile(
sv_reg['aglivc_{}_path'.format(pft_i)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['shremc'], _TARGET_NODATA,
sv_reg['aglivc_{}_path'.format(pft_i)], _SV_NODATA)
shutil.copyfile(
sv_reg['stdedc_{}_path'.format(pft_i)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['sdremc'], _TARGET_NODATA,
sv_reg['stdedc_{}_path'.format(pft_i)], _SV_NODATA)
raster_list_sum(
weighted_C_returned_list, _TARGET_NODATA,
temp_val_dict['sum_weighted_C_returned'], _TARGET_NODATA,
nodata_remove=True)
raster_list_sum(
weighted_N_returned_list, _TARGET_NODATA,
temp_val_dict['sum_weighted_N_returned'], _TARGET_NODATA,
nodata_remove=True)
raster_list_sum(
weighted_P_returned_list, _TARGET_NODATA,
temp_val_dict['sum_weighted_P_returned'], _TARGET_NODATA,
nodata_remove=True)
partit(
temp_val_dict['sum_weighted_C_returned'],
temp_val_dict['sum_weighted_N_returned'],
temp_val_dict['sum_weighted_P_returned'],
param_val_dict['feclig'], aligned_inputs['site_index'],
site_param_table, 1, sv_reg)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_derived_animal_traits(input_animal_trait_table, freer_parameter_df):
"""Calculate non-spatial derived animal traits.
Populate the animal trait table with parameters from Freer et al (2012),
and use these parameters along with input traits to calculate derived
animal traits. Add these traits to the existing dictionary of animal
traits supplied by the user as input.
Parameters:
input_animal_trait_table (dict): dictionary of key, dictionary pairs
where keys indicate animal types and nested dictionaries contain
input parameters that characterize each animal type
freer_parameter_df (data frame): data frame of parameter values from
Freer et al. 2012, the GRAZPLAN animal biology model. The data
frame must contain a column 'type', specifying the animal type or
breed, that can be matched to the field 'type' in the input
animal trait table
Returns:
animal_trait_table, a dictionary of key, dictionary pairs where keys
indicate unique ids for animal types and nested dictionaries contain
animal traits, including inputs, Freer parameters, and the following
derived animal traits:
- SRW_modified, standard reference weight modified by animal sex
- W_total, total body weight (equal to input weight for all animal
types except breeding females)
- BC, relative body condition
- Z, relative size
- ZF, size factor reflecting mouth size of young animals
- sex_int, integer indicating animal sex:
1: entire male
2: castrate male
3: breeding female
4: non-breeding female, default
- type_int, integer indicating animal type or breed:
1: Bos indicus, default
2: Bos taurus
3: Bos indicus * taurus cross
4: sheep or goat
5: camelid
6: hindgut fermenter
"""
input_df = pandas.DataFrame.from_dict(
input_animal_trait_table, orient='index')
animal_df = pandas.merge(
input_df, freer_parameter_df, how='left', on='type')
animal_df.replace('', numpy.nan, inplace=True)
animal_df.fillna(_IC_NODATA, inplace=True)
animal_df['W_total'] = animal_df['weight']
animal_df['SRW_modified'] = numpy.select(
[animal_df['sex'] == 'entire_m', animal_df['sex'] == 'castrate',
animal_df['sex'] == 'NA'],
[animal_df['srw'] * 1.4, animal_df['srw'] * 1.2,
(animal_df['srw'] + animal_df['srw'] * 1.4 / 2)],
default=animal_df['srw'])
Nmax = (
animal_df['SRW_modified'] - (
animal_df['SRW_modified'] - animal_df['birth_weight']) * numpy.exp(
(-animal_df['CN1'] * animal_df['age']) /
(animal_df['SRW_modified'] ** animal_df['CN2'])))
N = animal_df['CN3'] * Nmax + (1. - animal_df['CN3']) * animal_df['weight']
animal_df['Z'] = N / animal_df['SRW_modified'] # relative size
animal_df['ZF'] = numpy.where(
animal_df['Z'] < animal_df['CR7'], 1. +
(animal_df['CR7'] - animal_df['Z']), 1.)
animal_df['BC'] = animal_df['weight'] / N # relative condition
animal_df['sex_int'] = 4
animal_df.loc[animal_df.sex == 'entire_m', 'sex_int'] = 1
animal_df.loc[animal_df.sex == 'castrate', 'sex_int'] = 2
animal_df.loc[animal_df.sex == 'breeding_female', 'sex_int'] = 3
animal_df['type_int'] = 1
animal_df.loc[animal_df.type == 'b_taurus', 'type_int'] = 2
animal_df.loc[animal_df.type == 'indicus_x_taurus', 'type_int'] = 3
animal_df.loc[animal_df.type == 'sheep', 'type_int'] = 4
animal_df.loc[animal_df.type == 'camelid', 'type_int'] = 5
animal_df.loc[animal_df.type == 'hindgut_fermenter', 'type_int'] = 6
animal_df['reproductive_status_int'] = 0
animal_df['A_foet'] = 0
animal_df['A_y'] = 0
animal_df.set_index(['animal_id'], inplace=True)
animal_trait_table = animal_df.to_dict(orient='index')
return animal_trait_table
def update_breeding_female_status(inner_animal_trait_dict, month_index):
"""Update derived traits of a single animal type that is breeding females.
Because breeding females undergo cycles of conception, pregnancy, and
lactation, some derived traits must be updated at each model time step.
These traits do not vary spatially.
Parameters:
inner_animal_trait_dict (dict): dictionary of key, value pairs
representing input and derived traits for this animal type.
month_index (int): month of the simulation, such that month_index=13
indicates month 13 of the simulation
Returns:
updated_trait_table, a dictionary of key, value pairs where values
indicate input and derived traits for this animal type, including the
following updated animal traits:
- reproductive_status_int, integer indicating animal reproductive
status:
0: not pregnant or lactating (default)
1: pregnant
2: lactating
- W_total, total weight including weight of conceptus if pregnant
- A_foet, age of the foetus if pregnant
- A_y, age of the suckling young if lactating
"""
updated_trait_table = inner_animal_trait_dict.copy()
months_of_pregnancy = 9
cycle_month_index = (
(month_index - updated_trait_table['conception_step']) %
updated_trait_table['calving_interval'])
if cycle_month_index < months_of_pregnancy:
# animal is pregnant
updated_trait_table['reproductive_status_int'] = 1
updated_trait_table['A_foet'] = cycle_month_index * 30 + 1
RA = updated_trait_table['A_foet'] / updated_trait_table['CP1']
BW = (
(1 - updated_trait_table['CP4'] +
updated_trait_table['CP4'] *
updated_trait_table['Z']) *
updated_trait_table['CP15'] *
updated_trait_table['SRW_modified'])
W_c_1 = updated_trait_table['CP5'] * BW
W_c_2 = math.exp(
updated_trait_table['CP6'] *
(1 - math.exp(updated_trait_table['CP7'] * (1 - RA))))
W_c = W_c_1 * W_c_2 # equation 62, weight of conceptus
updated_trait_table['W_total'] = (
updated_trait_table['weight'] + W_c)
elif (cycle_month_index <
(months_of_pregnancy +
updated_trait_table['lactation_duration'])):
# animal is lactating
updated_trait_table['reproductive_status_int'] = 2
updated_trait_table['W_total'] = updated_trait_table['weight']
updated_trait_table['A_y'] = (
(cycle_month_index - months_of_pregnancy) * 30 + 1)
else:
# animal is not pregnant or lactating
updated_trait_table['reproductive_status_int'] = 0
updated_trait_table['W_total'] = updated_trait_table['weight']
updated_trait_table['A_foet'] = 0
updated_trait_table['A_y'] = 0
return updated_trait_table
def calc_max_intake(inner_animal_trait_dict):
"""Calculate maximum daily forage intake for a single animal type.
An animal's maximum intake is the maximum potential daily intake of dry
matter (kg) and depends on the size, condition, and reproductive stage of
the animal. This trait is "non-spatial", i.e. it does not vary according
to the context of the animal but is dictated solely by inherent animal
traits.
Parameters:
inner_animal_trait_dict (dict): dictionary of key, value pairs
representing input and derived traits for this animal type.
Returns:
updated_trait_table, a dictionary of key, value pairs where values
indicate input and derived traits for this animal type, including the
following updated animal trait:
- max_intake, maximum daily forage intake in kg dry matter
"""
updated_trait_table = inner_animal_trait_dict.copy()
if updated_trait_table['BC'] > 1.:
CF = (
updated_trait_table['BC'] *
(updated_trait_table['CI20'] - updated_trait_table['BC']) /
(updated_trait_table['CI20'] - 1.))
else:
CF = 1.
YF = 1. # eq 4 gives a different value for unweaned animals
TF = 1. # ignore effect of temperature on intake
LF = 1. # assume any lactating animals are suckling young (eq 8)
if updated_trait_table['reproductive_status_int'] == 2:
BCpart = updated_trait_table['BC'] # body condition at parturition
Mi = updated_trait_table['A_y'] / updated_trait_table['CI8']
LA = (
1. - updated_trait_table['CI15'] +
updated_trait_table['CI15'] * BCpart)
LF = (
1. + updated_trait_table['CI19'] * Mi **
updated_trait_table['CI9'] * math.exp(
updated_trait_table['CI9'] * (1 - Mi)) * LA)
updated_trait_table['max_intake'] = (
updated_trait_table['CI1'] * updated_trait_table['SRW_modified'] *
updated_trait_table['Z'] * (
updated_trait_table['CI2'] - updated_trait_table['Z']) *
CF * YF * TF * LF) # eq 2
return updated_trait_table
def calc_pasture_height(sv_reg, aligned_inputs, pft_id_set, processing_dir):
"""Calculate estimated height in cm for each forage feed type.
Follow GRAZPLAN by calculating estimated height of each forage feed type
from its biomass, assuming that 1 tonne of dry matter per ha has a height
of 3 cm. C state variables tracked by the model are first converted from gC
per square m to kg biomass per ha, then the height of each feed type is
estimated following equation 134 from Freer et al. (2012).
Parameters:
sv_reg (dict): map of key, path pairs giving paths to state variables,
including C in aboveground live and standing dead biomass
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fractional cover of each pft
pft_id_set (set): set of integers identifying plant functional types
processing_dir (string): path to temporary processing directory where
rasters of pasture height should be stored
Returns:
pasture_height_dict, a dictionary of key, path pairs giving estimated
height in cm of each feed type
"""
def calc_weighted_biomass_kgha(cstatv, pft_cover):
"""Calculate biomass in kg/ha weighted by fractional cover of the pft.
Convert a state variable representing grams of carbon per square meter
into kg of biomass per ha, accounting for fractional cover of the
plant functional type. Biomass in kg/ha is calculated from the state
variable representing grams of carbon per square meter, entailing two
conversion steps: first multiply by 2.5 to get biomass, then multiply
by 10 to get kg/ha from g/m2.
Parameters:
cstatv (numpy.ndarray): state variable, C state variable belonging
to the plant functional type
pft_cover (numpy.ndarray): input, fractional cover of the plant
functional type
Returns:
biomass_kgha, absolute biomass of this state variable and this
plant functional type in kg per ha
"""
valid_mask = (
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(pft_cover, pft_nodata)))
biomass_kgha = numpy.empty(cstatv.shape, dtype=numpy.float32)
biomass_kgha[:] = _TARGET_NODATA
biomass_kgha[valid_mask] = (
cstatv[valid_mask] * 2.5 * 10 * pft_cover[valid_mask])
return biomass_kgha
def calc_scale_term(*biomass_array_list):
"""Calculate the scaling term to estimate pasture height from biomass.
The height of each feed type is estimated from its biomass by
multiplying its biomass by a scale term, which is the square of the sum
of biomass across feed types divided by the sum of squares of biomass
across feed types, multiplied by 3e-3. Treat nodata values in each
biomass array as zero. Equation 134, Freer et al. (2012).
Parameters:
biomass_array_list (list): list of numpy.ndarrays containing
biomass in kg per ha
Returns:
scale_term, the scaling term to estimate pasture height from
biomass
"""
square_list = []
for r in biomass_array_list:
numpy.place(r, numpy.isclose(r, _TARGET_NODATA), [0])
square_list.append(r ** 2)
numerator = (numpy.sum(biomass_array_list, axis=0)) ** 2
denominator = numpy.sum(square_list, axis=0)
nonzero_mask = (denominator > 0)
scale_term = numpy.empty(denominator.shape, dtype=numpy.float32)
scale_term[:] = _TARGET_NODATA
scale_term[nonzero_mask] = (
(numerator[nonzero_mask] / denominator[nonzero_mask]) * 0.003)
return scale_term
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
temp_val_dict['scale_term'] = os.path.join(temp_dir, 'scale_term.tif')
biomass_raster_list = []
for pft_i in pft_id_set:
for val in ['agliv_kgha', 'stded_kgha']:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
# calculate weighted aboveground live biomass in kg/ha
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['aglivc_{}_path'.format(pft_i)],
aligned_inputs['pft_{}'.format(pft_i)]]],
calc_weighted_biomass_kgha,
temp_val_dict['agliv_kgha_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate weighted standing dead biomass in kg/ha
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['stdedc_{}_path'.format(pft_i)],
aligned_inputs['pft_{}'.format(pft_i)]]],
calc_weighted_biomass_kgha,
temp_val_dict['stded_kgha_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
biomass_raster_list.append(
temp_val_dict['agliv_kgha_{}'.format(pft_i)])
biomass_raster_list.append(
temp_val_dict['stded_kgha_{}'.format(pft_i)])
pygeoprocessing.raster_calculator(
[(path, 1) for path in biomass_raster_list], calc_scale_term,
temp_val_dict['scale_term'], gdal.GDT_Float32,
_TARGET_NODATA)
pasture_height_dict = {}
for pft_i in pft_id_set:
pasture_height_dict['agliv_{}'.format(pft_i)] = os.path.join(
processing_dir, 'agliv_height_{}.tif'.format(pft_i))
raster_multiplication(
temp_val_dict['agliv_kgha_{}'.format(pft_i)], _TARGET_NODATA,
temp_val_dict['scale_term'], _TARGET_NODATA,
pasture_height_dict['agliv_{}'.format(pft_i)],
_TARGET_NODATA)
pasture_height_dict['stded_{}'.format(pft_i)] = os.path.join(
processing_dir, 'stded_height_{}.tif'.format(pft_i))
raster_multiplication(
temp_val_dict['stded_kgha_{}'.format(pft_i)], _TARGET_NODATA,
temp_val_dict['scale_term'], _TARGET_NODATA,
pasture_height_dict['stded_{}'.format(pft_i)],
_TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
return pasture_height_dict
def calc_fraction_biomass(
sv_reg, aligned_inputs, pft_id_set, processing_dir,
total_weighted_C_path):
"""Calculate the fraction of total biomass represented by each feed type.
The fraction of total biomass represented by live and standing dead biomass
of each plant functional type must be calculated while accounting for the
fractional cover of the pft. This quantity is the member variable
"rel_availability" in the beta rangeland production model.
Parameters:
sv_reg (dict): map of key, path pairs giving paths to state variables,
including C in aboveground live and standing dead biomass
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fractional cover of each pft
pft_id_set (set): set of integers identifying plant functional types
processing_dir (string): path to temporary processing directory where
rasters of pasture height should be stored
total_weighted_C_path (string): path to raster giving total carbon in
aboveground live and standing dead biomass across plant functional
types
Returns:
frac_biomass_dict, a dictionary of key, path pairs giving fraction of
total biomass represented by each feed type
"""
def weighted_fraction(cstatv, pft_cover, total_weighted_C):
"""Calculate fraction of total C accounting for cover of the pft.
Parameters:
cstatv (numpy.ndarray): state variable, C state variable belonging
to the plant functional type
pft_cover (numpy.ndarray): input, fractional cover of the plant
functional type
total_weighted_C (numpy.ndarray): derived, total carbon in
aboveground live and standing dead biomass across plant
functional types
Returns:
weighted_fraction, fraction of total biomass represented by this
feed type
"""
valid_mask = (
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(pft_cover, pft_nodata)) &
(total_weighted_C != _TARGET_NODATA) &
(total_weighted_C > 0))
weighted_fraction = numpy.empty(cstatv.shape, dtype=numpy.float32)
weighted_fraction[:] = _TARGET_NODATA
weighted_fraction[valid_mask] = (
cstatv[valid_mask] * pft_cover[valid_mask] /
total_weighted_C[valid_mask])
return weighted_fraction
# calculate the fraction of total biomass for aglivc and stdedc of each pft
frac_biomass_dict = {}
for pft_i in pft_id_set:
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
target_path = os.path.join(
processing_dir, 'agliv_frac_bio_{}'.format(pft_i))
frac_biomass_dict['agliv_{}'.format(pft_i)] = target_path
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['aglivc_{}_path'.format(pft_i)],
aligned_inputs['pft_{}'.format(pft_i)],
total_weighted_C_path]], weighted_fraction,
target_path, gdal.GDT_Float32, _TARGET_NODATA)
target_path = os.path.join(
processing_dir, 'stded_frac_bio_{}'.format(pft_i))
frac_biomass_dict['stded_{}'.format(pft_i)] = target_path
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['stdedc_{}_path'.format(pft_i)],
aligned_inputs['pft_{}'.format(pft_i)],
total_weighted_C_path]], weighted_fraction,
target_path, gdal.GDT_Float32, _TARGET_NODATA)
return frac_biomass_dict
def order_by_digestibility(sv_reg, pft_id_set, aoi_path):
"""Calculate the order of feed types according to their digestibility.
During diet selection, animals select among feed types in descending order
by feed type digestibility. Because digestibility is linearly related to
crude protein content, the order of feed types may be estimated from their
nitrogen to carbon ratios. Order feed types by digestibility according to
the mean nitrogen to carbon ratio of each feed type across the study area
aoi.
Parameters:
sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month, including C and N in aboveground
live and standing dead
pft_id_set (set): set of integers identifying plant functional types
aoi_path (string): path to vector layer giving the spatial extent of
the model
Returns:
ordered_feed_types, a list of strings where each string designates a
feed type by a combination of pft_i and fraction (aboveground live
or standing dead), in descending order of digestibility
"""
def calc_nc_ratio(cstatv_path, nstatv_path, aoi_path):
"""Calculate the mean nitrogen to carbon ratio of a biomass fraction.
Calculate the mean nitrogen to carbon ratio of a biomass fraction
falling inside the study area aoi. The ratio is calculated from the
state variables representing carbon and nitrogen content of that
biomass fraction. If the area of interest vector dataset contains more
than one polygon feature, the average ratio is calculated across
features.
Parameters:
cstatv_path (string): path to raster containing carbon in the
biomass fraction
nstatv_path (string): path to raster containing nitrogen in the
biomass fraction
aoi_path (string): path to vector layer defining the study area of
interest
Returns:
nc_ratio, the ratio of mean nitrogen to mean carbon for this state
variable inside the model area of interest
"""
carbon_zonal_stat_df = pandas.DataFrame.from_dict(
pygeoprocessing.zonal_statistics((cstatv_path, 1), aoi_path),
orient='index')
if carbon_zonal_stat_df['count'].sum() == 0:
return 0
else:
mean_carbon = (
carbon_zonal_stat_df['sum'].sum() /
carbon_zonal_stat_df['count'].sum())
nitrogen_zonal_stat_df = pandas.DataFrame.from_dict(
pygeoprocessing.zonal_statistics((nstatv_path, 1), aoi_path),
orient='index')
if nitrogen_zonal_stat_df['count'].sum() == 0:
mean_nitrogen = 0
else:
mean_nitrogen = (
nitrogen_zonal_stat_df['sum'].sum() /
nitrogen_zonal_stat_df['count'].sum())
return (mean_nitrogen / mean_carbon)
nc_ratio_dict = {}
for pft_i in pft_id_set:
for statv in ['agliv', 'stded']:
cstatv_path = sv_reg['{}c_{}_path'.format(statv, pft_i)]
nstatv_path = sv_reg['{}e_1_{}_path'.format(statv, pft_i)]
nc_ratio = calc_nc_ratio(cstatv_path, nstatv_path, aoi_path)
nc_ratio_dict['{}_{}'.format(statv, pft_i)] = nc_ratio
# order the dictionary by descending N/C ratio keys, get list from values
sorted_list = sorted(
[(ratio, feed_type) for (feed_type, ratio) in
nc_ratio_dict.items()], reverse=True)
ordered_feed_types = [feed_type for (ratio, feed_type) in sorted_list]
return ordered_feed_types
def calc_digestibility(
cstatv, nstatv, digestibility_slope, digestibility_intercept):
"""Calculate the dry matter digestibility of this feed type.
Dry matter digestibility, expressed as a fraction between 0 and 1, is
calculated via linear regression from crude protein content of the feed
type, with regression coefficients that are specific to the plant
functional type.
Parameters:
cstatv (numpy.ndarray): state variable, carbon in the feed type
nstatv (numpy.ndarray): state variable, nitrogen in the feed type
digestibility_slope (numpy.ndarray): parameter, slope of
relationship predicting dry matter digestibility from crude
protein concentration
digestibility_intercept (numpy.ndarray): parameter, intercept of
relationship predicting dry matter digestibility from crude
protein concentration
Returns:
digestibility, dry matter digestibility of the feed type
"""
valid_mask = (
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(nstatv, _SV_NODATA)) &
(digestibility_slope != _IC_NODATA) &
(digestibility_intercept != _IC_NODATA))
digestibility = numpy.zeros(cstatv.shape, dtype=numpy.float32)
if CRUDE_PROTEIN:
digestibility[valid_mask] = (
CRUDE_PROTEIN *
digestibility_slope[valid_mask] +
digestibility_intercept[valid_mask])
else:
digestibility[valid_mask] = (
((nstatv[valid_mask] * 6.25) / (cstatv[valid_mask] * 2.5)) *
digestibility_slope[valid_mask] +
digestibility_intercept[valid_mask])
return digestibility
def calc_relative_availability(avail_biomass, sum_previous_classes):
"""Calculate relative availability of one forage feed type.
The relative availability of a feed type is calculated from predicted rate
of eating and time spent eating this forage type, and from the unsatisfied
capacity that is left unmet by relative availability of other feed types of
greater digestibility. Equation 14, Freer et al. (2012).
Parameters:
avail_biomass (numpy.ndarray): derived, estimated rate of eating and
time spent eating this feed type
sum_previous_classes (numpy.ndarray): derived, the sum of relative
availability of other feed types with higher digestibility than the
current feed type
Returns:
relative_availability, relative availability of this feed type
"""
valid_mask = (
(avail_biomass != _TARGET_NODATA) &
(sum_previous_classes != _TARGET_NODATA))
relative_availability = numpy.empty(
avail_biomass.shape, dtype=numpy.float32)
relative_availability[:] = _TARGET_NODATA
relative_availability[valid_mask] = (
numpy.maximum(0., 1. - sum_previous_classes[valid_mask]) *
avail_biomass[valid_mask])
return relative_availability
def calc_digestibility_intake(
diet_path_dict, feed_type_list, diet_digestibility_path):
"""Calculate the dry matter digestibility of forage in the diet.
The dry matter digestibility of the diet selected by grazing animals is
calculated from the digestibility of each feed type and the intake of that
feed type.
Parameters:
diet_path_dict (dict): map of key, path pairs where keys are strings
composed of 'intake' or 'digestibility' and a feed type from
`feed_type_list`, and paths indicate rasters describing intake or
digestibility of a feed type.
feed_type_list (list): a list of strings, each indicating one feed type
diet_digestibility_path (string): path to location where the result,
dry matter digestibility of forage in the diet, should be stored
Side effects:
modifies or creates the raster indicated by `diet_digestibility_path`
to indicate the overall dry matter digestibility of forage in the
diet
Returns:
None
"""
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in ['intake_sum', 'digestibility_sum']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
intake_path_list = [
diet_path_dict['daily_intake_{}'.format(feed_type)] for feed_type in
sorted(feed_type_list)]
digestibility_path_list = [
diet_path_dict['digestibility_{}'.format(feed_type)] for feed_type in
sorted(feed_type_list)]
# sum intake across feed types
raster_list_sum(
intake_path_list, _TARGET_NODATA, temp_val_dict['intake_sum'],
_TARGET_NODATA)
# sum digestibility of feed types weighted by intake
weighted_digestibility_path_list = []
for feed_type_index in range(len(intake_path_list)):
target_path = os.path.join(
temp_dir, 'weighted_digestibility_{}.tif'.format(feed_type_index))
raster_multiplication(
intake_path_list[feed_type_index], _TARGET_NODATA,
digestibility_path_list[feed_type_index], _TARGET_NODATA,
target_path, _TARGET_NODATA)
weighted_digestibility_path_list.append(target_path)
raster_list_sum(
weighted_digestibility_path_list, _TARGET_NODATA,
temp_val_dict['digestibility_sum'], _TARGET_NODATA)
# average digestibility across feed types
raster_division(
temp_val_dict['digestibility_sum'], _TARGET_NODATA,
temp_val_dict['intake_sum'], _TARGET_NODATA,
diet_digestibility_path, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_crude_protein_intake(
sv_reg, diet_path_dict, feed_type_list, crude_protein_intake_path):
"""Calculate the intake of crude protein from forage in the diet.
The total intake of crude protein in the selected diet is calculated from
the crude protein content of each feed type and the intake of that feed
type.
Parameters:
sv_reg (dict): map of key, path pairs giving paths to state variables,
including carbon and nitrogen in each feed type
diet_path_dict (dict): map of key, path pairs where keys are strings
composed of 'intake' and a feed type from `feed_type_list`, and
paths indicate rasters describing intake of a feed type.
feed_type_list (list): a list of strings, each indicating one feed type
crude_protein_intake_path (string): path to location where the result,
crude protein intake in the diet, should be stored
Side effects:
modifies or creates the raster indicated by `crude_protein_intake_path`
to indicate the crude protein intake in the diet
Returns:
none
"""
def calc_weighted_crude_protein(cstatv, nstatv, intake):
"""Calculate intake of crude protein from one feed type.
The intake of crude protein from one feed type is calculated from
an adjusted ratio of nitrogen to carbon in the feed type, and the
intake of that feed type.
Parameters:
cstatv (numpy.ndarray): state variable, carbon in the feed type
nstatv (numpy.ndarray): state variable, nitrogen in the feed type
intake (numpy.ndarray): derived, intake of this feed type in the
diet
Returns:
weighted_cp, intake of crude protein from one feed type
"""
valid_mask = (
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(nstatv, _SV_NODATA)) &
(intake != _TARGET_NODATA))
weighted_cp = numpy.empty(cstatv.shape, dtype=numpy.float32)
weighted_cp[:] = _TARGET_NODATA
if CRUDE_PROTEIN:
weighted_cp[valid_mask] = (CRUDE_PROTEIN * intake[valid_mask])
else:
weighted_cp[valid_mask] = (
((nstatv[valid_mask] * 6.25) / (cstatv[valid_mask] * 2.5)) *
intake[valid_mask])
return weighted_cp
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
weighted_crude_protein_path_list = []
for feed_type in feed_type_list:
statv = feed_type.split('_')[0]
pft_i = feed_type.split('_')[1]
target_path = os.path.join(
temp_dir, 'weighted_cp_{}.tif'.format(feed_type))
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['{}c_{}_path'.format(statv, pft_i)],
sv_reg['{}e_1_{}_path'.format(statv, pft_i)],
diet_path_dict['daily_intake_{}'.format(feed_type)]]],
calc_weighted_crude_protein, target_path,
gdal.GDT_Float32, _TARGET_NODATA)
weighted_crude_protein_path_list.append(target_path)
raster_list_sum(
weighted_crude_protein_path_list, _TARGET_NODATA,
crude_protein_intake_path, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_energy_intake(total_intake, total_digestibility):
"""Calculate the total intake of metabolizable energy.
The intake of metabolizable energy in the selected diet is estimated from
the dry matter digestibility of the diet, expressed as a fraction between
0 and 1. Equation 31 in Freer et al. (2012).
Parameters:
total_intake (numpy.ndarray): derived, intake of forage in the diet in
kg per ha per day
total_digestibility (numpy.ndarray): derived, dry matter digestibility
of forage in the selected diet
Returns:
energy_intake, total intake of metabolizable energy from the diet
"""
valid_mask = (
(total_intake != _TARGET_NODATA) &
(total_digestibility != _TARGET_NODATA))
energy_intake = numpy.empty(total_intake.shape, dtype=numpy.float32)
energy_intake[:] = _TARGET_NODATA
energy_intake[valid_mask] = (
(17. * total_digestibility[valid_mask] - 2.) *
total_intake[valid_mask])
return energy_intake
def calc_energy_maintenance(
age, sex, weight, energy_intake, total_intake, total_digestibility,
CK1, CK2, CM1, CM2, CM3, CM4, CM6, CM7, CM16):
"""Calculate energy requirements of maintenance.
Energy requirements of maintenance include basal metabolic energy
requirements according to the animal's size, and energy requirements of
walking and grazing. Equations 41-44, Freer et al. (2012).
Parameters:
age (numpy.ndarray): input, animal age in days
sex (numpy.ndarray): derived, integer indication of animal sex:
1: entire male
2: castrate male
3: breeding female
4: non-breeding female
weight (numpy.ndarray): derived, animal weight in kg including weight
of the fetus for pregnant females
energy_intake (numpy.ndarray): derived, total intake of metabolizable
energy from the diet
total_intake (numpy.ndarray): derived, intake of forage in the diet
total_digestibility (numpy.ndarray): derived, dry matter digestibility
of forage in the diet
CK1 (numpy.ndarray): parameter, basal efficiency of energy use for
maintenance
CK2 (numpy.ndarray): parameter, impact of energy density of diet on
efficiency of energy use for maintenance
CM1 (numpy.ndarray): parameter, basal rate of energy use for
maintenance
CM2 (numpy.ndarray): parameter, weight scalar for basal metabolic rate
CM3 (numpy.ndarray): parameter, effect of age on basal metabolic rate
CM4 (numpy.ndarray): parameter, minimum effect of age on basal
metabolic rate
CM6 (numpy.ndarray): parameter, multiplier for energetic cost of
chewing
CM7 (numpy.ndarray): parameter, effect of digestibility on energetic
cost of chewing
CM16 (numpy.ndarray): parameter, basal energy cost of walking
Returns:
energy_maintenance, energy requirements of maintenance
"""
valid_mask = (
(age != _TARGET_NODATA) &
(sex != _TARGET_NODATA) &
(weight != _TARGET_NODATA) &
(energy_intake != _TARGET_NODATA) &
(total_intake != _TARGET_NODATA) &
(total_digestibility != _TARGET_NODATA) &
(CK1 != _IC_NODATA) &
(CK2 != _IC_NODATA) &
(CM1 != _IC_NODATA) &
(CM2 != _IC_NODATA) &
(CM3 != _IC_NODATA) &
(CM4 != _IC_NODATA) &
(CM6 != _IC_NODATA) &
(CM7 != _IC_NODATA) &
(CM16 != _IC_NODATA))
nonzero_mask = (
(total_intake > 0) &
valid_mask)
km = numpy.empty(age.shape, dtype=numpy.float32)
km[nonzero_mask] = (
CK1[nonzero_mask] + CK2[nonzero_mask] * (
energy_intake[nonzero_mask] / total_intake[nonzero_mask]))
Egraze = numpy.empty(age.shape, dtype=numpy.float32)
Egraze[nonzero_mask] = (
CM6[nonzero_mask] * weight[nonzero_mask] * total_intake[nonzero_mask] *
(CM7[nonzero_mask] - total_digestibility[nonzero_mask]) +
(CM16[nonzero_mask] * 4. * weight[nonzero_mask]))
Emetab = numpy.empty(age.shape, dtype=numpy.float32)
Emetab[nonzero_mask] = (
CM2[nonzero_mask] * weight[nonzero_mask] ** 0.75 *
numpy.maximum(
numpy.exp(-CM3[nonzero_mask] * age[nonzero_mask]),
CM4[nonzero_mask]))
energy_maintenance_female = numpy.empty(age.shape, dtype=numpy.float32)
energy_maintenance_female[:] = _TARGET_NODATA
energy_maintenance_female[valid_mask] = 0
energy_maintenance_female[nonzero_mask] = (
(Emetab[nonzero_mask] + Egraze[nonzero_mask]) / km[nonzero_mask] +
CM1[nonzero_mask] * energy_intake[nonzero_mask])
energy_maintenance = energy_maintenance_female
male_mask = (
(sex < 3) &
(valid_mask))
energy_maintenance[male_mask] = energy_maintenance_female[male_mask] * 1.15
return energy_maintenance
def calc_degr_protein_intake(crude_protein_intake, total_digestibility):
"""Calculate rumen degradable protein intake from the diet.
Rumen degradable protein intake from the diet is calculated from total
crude protein intake. If the diet is low in dry matter digestibility, the
degradable protein in the diet is less than the intake of crude protein.
Parameters:
crude_protein_intake (numpy.ndarray): derived, intake of crude protein
from forage
total_digestibility (numpy.ndarray): derived, dry matter digestibility
of forage in the diet
Returns:
degr_protein_intake, rumen degradable protein intake from the diet
"""
valid_mask = (
(crude_protein_intake != _TARGET_NODATA) &
(total_digestibility != _TARGET_NODATA))
degr_protein_intake = numpy.empty(
crude_protein_intake.shape, dtype=numpy.float32)
degr_protein_intake[:] = _TARGET_NODATA
degr_protein_intake[valid_mask] = (
crude_protein_intake[valid_mask] * numpy.minimum(
0.84 * total_digestibility[valid_mask] + 0.33, 1.))
return degr_protein_intake
def calc_protein_req(
energy_intake_path, energy_maintenance_path, CRD4_path, CRD5_path,
CRD6_path, CRD7_path, current_month, protein_req_path):
"""Calculate rumen degradable protein required.
The requirement for rumen degradable protein depends on the ratio of energy
intake to maintenance energy requirements, and estimated seasonal impacts
on microbial protein synthesis.
Parameters:
energy_intake_path (string): path to raster containing total energy
intake from the diet
energy_maintenance_path (string): path to raster containing energy
requirements of maintenance
CRD4_path (string): path to raster containing the parameter CRD4
CRD5_path (string): path to raster containing the parameter CRD5
CRD6_path (string): path to raster containing the parameter CRD6
CRD7_path (string): path to raster containing the parameter CRD7
current_month (int): month of the year, such that current_month=1
indicates January
protein_req_path (string): path to raster that should contain the
result, rumen degradable protein required
Side effects:
modifies or creates the raster indicated by `protein_req_path`
Returns:
None
"""
def protein_req_op(current_month):
def _protein_req_op(
latitude, energy_intake, energy_maintenance, CRD4, CRD5, CRD6,
CRD7):
"""Calculate rumen degradable protein required.
Parameters:
latitude (numpy.ndarray): derived, site latitude in degrees
energy_intake (numpy.ndarray): derived, total intake of
metabolizable energy from the diet
energy_maintenance (numpy.ndarray): derived, energy
requirements of maintenance
CRD4 (numpy.ndarray): parameter, basal rumen degradable protein
requirement
CRD5 (numpy.ndarray): parameter, multiplier for total impact of
energy intake and seasonal effects on rumen degradable
protein requirement
CRD6 (numpy.ndarray): parameter, multiplier for impact of
energy intake on rumen degradable protein requirement
CRD7 (numpy.ndarray): parameter, multiplier for seasonal impact
on rumen degradable protein requirement
Returns:
protein_req, rumen degradable protein required
"""
valid_mask = (
(energy_maintenance != _TARGET_NODATA) &
(energy_intake != _TARGET_NODATA) &
(CRD4 != _IC_NODATA) &
(CRD5 != _IC_NODATA) &
(CRD6 != _IC_NODATA) &
(CRD7 != _IC_NODATA))
nonzero_mask = (
(energy_maintenance > 0) &
valid_mask)
# estimated day of the year in the middle of current current_month
day_of_year = 15.2 + 30.4 * (current_month - 1)
radiation_factor = numpy.empty(latitude.shape, dtype=numpy.float32)
radiation_factor[valid_mask] = (
1. + CRD7[valid_mask] * (latitude[valid_mask] / 40.) *
numpy.sin((2. * numpy.pi * day_of_year) / 365.))
protein_req = numpy.empty(latitude.shape, dtype=numpy.float32)
protein_req[:] = _TARGET_NODATA
protein_req[valid_mask] = 0
protein_req[nonzero_mask] = (
(CRD4[nonzero_mask] + CRD5[nonzero_mask] * (1. - numpy.exp(
-CRD6[nonzero_mask] * (
energy_intake[nonzero_mask] /
energy_maintenance[nonzero_mask])))) *
(radiation_factor[nonzero_mask] * energy_intake[nonzero_mask]))
return protein_req
return _protein_req_op
# calculate an intermediate input, latitude at each pixel center
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
latitude_raster_path = os.path.join(temp_dir, 'latitude.tif')
calc_latitude(energy_intake_path, latitude_raster_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
latitude_raster_path, energy_intake_path, energy_maintenance_path,
CRD4_path, CRD5_path, CRD6_path, CRD7_path]],
protein_req_op(current_month), protein_req_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def revise_max_intake(
max_intake, total_digestibility, energy_intake, energy_maintenance,
degr_protein_intake, protein_req, animal_type, CRD1, CRD2):
"""Calculate revised maximum intake from protein content of the diet.
When animals are unable to obtain enough protein from the diet to maintain
microbial activity in the rumen, the passage rate of feed slows and the
animal is able to eat less forage overall. Here that dynamic is reflected
by reducing maximum potential intake if protein content of the initially
selected diet is low.
Parameters:
max_intake (numpy.ndarray): derived, initial maximum potential daily
intake of forage
total_digestibility (numpy.ndarray): derived, average dry matter
digestibility of forage in the diet
energy_intake (numpy.ndarray): derived, total metabolizable energy
intake from the diet
energy_maintenance (numpy.ndarray): derived, energy requirements of
maintenance
degr_protein_intake (numpy.ndarray): derived, total rumen degradable
protein intake from the diet
protein_req (numpy.ndarray): derived, rumen degradable protein required
to maintain microbial activity
animal_type (numpy.ndarray): parameter, integer indication of animal
type or breed:
1: Bos indicus, default
2: Bos taurus
3: Bos indicus * taurus cross
4: sheep or goat
5: camelid
6: hindgut fermenter
CRD1 (numpy.ndarray): parameter, intercept of regression predicting
degradability of protein from digestibility of the diet
CRD2 (numpy.ndarray): parameter, slope of relationship predicting
degradability of protein from digestibility of the diet
Returns:
max_intake_revised, revised maximum potential daily intake of forage
"""
valid_mask = (
(max_intake != _TARGET_NODATA) &
(total_digestibility != _TARGET_NODATA) &
(energy_intake != _TARGET_NODATA) &
(energy_maintenance != _TARGET_NODATA) &
(degr_protein_intake != _TARGET_NODATA) &
(protein_req != _TARGET_NODATA) &
(animal_type != _IC_NODATA) &
(CRD1 != _IC_NODATA) &
(CRD2 != _IC_NODATA))
corrected_protein_intake = degr_protein_intake.copy()
feeding_level = | numpy.zeros(max_intake.shape, dtype=numpy.float32) | numpy.zeros |
import re
import textwrap
import numpy as np
import pytest
from numpy.testing import (assert_almost_equal, assert_array_almost_equal,
assert_equal)
from skimage.transform._geometric import (_affine_matrix_from_vector,
_center_and_normalize_points,
_euler_rotation_matrix,
GeometricTransform)
from skimage.transform import (estimate_transform, matrix_transform,
EuclideanTransform, SimilarityTransform,
AffineTransform, FundamentalMatrixTransform,
EssentialMatrixTransform, ProjectiveTransform,
PolynomialTransform, PiecewiseAffineTransform)
SRC = np.array([
[-12.3705, -10.5075],
[-10.7865, 15.4305],
[8.6985, 10.8675],
[11.4975, -9.5715],
[7.8435, 7.4835],
[-5.3325, 6.5025],
[6.7905, -6.3765],
[-6.1695, -0.8235],
])
DST = np.array([
[0, 0],
[0, 5800],
[4900, 5800],
[4900, 0],
[4479, 4580],
[1176, 3660],
[3754, 790],
[1024, 1931],
])
def test_estimate_transform():
for tform in ('euclidean', 'similarity', 'affine', 'projective',
'polynomial'):
estimate_transform(tform, SRC[:2, :], DST[:2, :])
with pytest.raises(ValueError):
estimate_transform('foobar', SRC[:2, :], DST[:2, :])
def test_matrix_transform():
tform = AffineTransform(scale=(0.1, 0.5), rotation=2)
assert_equal(tform(SRC), matrix_transform(SRC, tform.params))
def test_euclidean_estimation():
# exact solution
tform = estimate_transform('euclidean', SRC[:2, :], SRC[:2, :] + 10)
assert_almost_equal(tform(SRC[:2, :]), SRC[:2, :] + 10)
assert_almost_equal(tform.params[0, 0], tform.params[1, 1])
assert_almost_equal(tform.params[0, 1], - tform.params[1, 0])
# over-determined
tform2 = estimate_transform('euclidean', SRC, DST)
assert_almost_equal(tform2.inverse(tform2(SRC)), SRC)
assert_almost_equal(tform2.params[0, 0], tform2.params[1, 1])
assert_almost_equal(tform2.params[0, 1], - tform2.params[1, 0])
# via estimate method
tform3 = EuclideanTransform()
tform3.estimate(SRC, DST)
assert_almost_equal(tform3.params, tform2.params)
def test_euclidean_init():
# init with implicit parameters
rotation = 1
translation = (1, 1)
tform = EuclideanTransform(rotation=rotation, translation=translation)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.translation, translation)
# init with transformation matrix
tform2 = EuclideanTransform(tform.params)
assert_almost_equal(tform2.rotation, rotation)
assert_almost_equal(tform2.translation, translation)
# test special case for scale if rotation=0
rotation = 0
translation = (1, 1)
tform = EuclideanTransform(rotation=rotation, translation=translation)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.translation, translation)
# test special case for scale if rotation=90deg
rotation = np.pi / 2
translation = (1, 1)
tform = EuclideanTransform(rotation=rotation, translation=translation)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.translation, translation)
def test_similarity_estimation():
# exact solution
tform = estimate_transform('similarity', SRC[:2, :], DST[:2, :])
assert_almost_equal(tform(SRC[:2, :]), DST[:2, :])
assert_almost_equal(tform.params[0, 0], tform.params[1, 1])
assert_almost_equal(tform.params[0, 1], - tform.params[1, 0])
# over-determined
tform2 = estimate_transform('similarity', SRC, DST)
assert_almost_equal(tform2.inverse(tform2(SRC)), SRC)
assert_almost_equal(tform2.params[0, 0], tform2.params[1, 1])
assert_almost_equal(tform2.params[0, 1], - tform2.params[1, 0])
# via estimate method
tform3 = SimilarityTransform()
tform3.estimate(SRC, DST)
assert_almost_equal(tform3.params, tform2.params)
def test_similarity_init():
# init with implicit parameters
scale = 0.1
rotation = 1
translation = (1, 1)
tform = SimilarityTransform(scale=scale, rotation=rotation,
translation=translation)
assert_almost_equal(tform.scale, scale)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.translation, translation)
# init with transformation matrix
tform2 = SimilarityTransform(tform.params)
assert_almost_equal(tform2.scale, scale)
assert_almost_equal(tform2.rotation, rotation)
assert_almost_equal(tform2.translation, translation)
# test special case for scale if rotation=0
scale = 0.1
rotation = 0
translation = (1, 1)
tform = SimilarityTransform(scale=scale, rotation=rotation,
translation=translation)
assert_almost_equal(tform.scale, scale)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.translation, translation)
# test special case for scale if rotation=90deg
scale = 0.1
rotation = np.pi / 2
translation = (1, 1)
tform = SimilarityTransform(scale=scale, rotation=rotation,
translation=translation)
assert_almost_equal(tform.scale, scale)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.translation, translation)
# test special case for scale where the rotation isn't exactly 90deg,
# but very close
scale = 1.0
rotation = np.pi / 2
translation = (0, 0)
params = np.array([[0, -1, 1.33226763e-15],
[1, 2.22044605e-16, -1.33226763e-15],
[0, 0, 1]])
tform = SimilarityTransform(params)
assert_almost_equal(tform.scale, scale)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.translation, translation)
def test_affine_estimation():
# exact solution
tform = estimate_transform('affine', SRC[:3, :], DST[:3, :])
assert_almost_equal(tform(SRC[:3, :]), DST[:3, :])
# over-determined
tform2 = estimate_transform('affine', SRC, DST)
assert_almost_equal(tform2.inverse(tform2(SRC)), SRC)
# via estimate method
tform3 = AffineTransform()
tform3.estimate(SRC, DST)
assert_almost_equal(tform3.params, tform2.params)
def test_affine_init():
# init with implicit parameters
scale = (0.1, 0.13)
rotation = 1
shear = 0.1
translation = (1, 1)
tform = AffineTransform(scale=scale, rotation=rotation, shear=shear,
translation=translation)
assert_almost_equal(tform.scale, scale)
assert_almost_equal(tform.rotation, rotation)
assert_almost_equal(tform.shear, shear)
assert_almost_equal(tform.translation, translation)
# init with transformation matrix
tform2 = AffineTransform(tform.params)
assert_almost_equal(tform2.scale, scale)
assert_almost_equal(tform2.rotation, rotation)
assert_almost_equal(tform2.shear, shear)
assert_almost_equal(tform2.translation, translation)
# scalar vs. tuple scale arguments
assert_almost_equal(AffineTransform(scale=0.5).scale, AffineTransform(scale=(0.5, 0.5)).scale)
def test_piecewise_affine():
tform = PiecewiseAffineTransform()
tform.estimate(SRC, DST)
# make sure each single affine transform is exactly estimated
assert_almost_equal(tform(SRC), DST)
assert_almost_equal(tform.inverse(DST), SRC)
def test_fundamental_matrix_estimation():
src = np.array([1.839035, 1.924743, 0.543582, 0.375221,
0.473240, 0.142522, 0.964910, 0.598376,
0.102388, 0.140092, 15.994343, 9.622164,
0.285901, 0.430055, 0.091150, 0.254594]).reshape(-1, 2)
dst = np.array([1.002114, 1.129644, 1.521742, 1.846002,
1.084332, 0.275134, 0.293328, 0.588992,
0.839509, 0.087290, 1.779735, 1.116857,
0.878616, 0.602447, 0.642616, 1.028681]).reshape(-1, 2)
tform = estimate_transform('fundamental', src, dst)
# Reference values obtained using COLMAP SfM library.
tform_ref = np.array([[-0.217859, 0.419282, -0.0343075],
[-0.0717941, 0.0451643, 0.0216073],
[0.248062, -0.429478, 0.0221019]])
assert_almost_equal(tform.params, tform_ref, 6)
def test_fundamental_matrix_residuals():
essential_matrix_tform = EssentialMatrixTransform(
rotation=np.eye(3), translation=np.array([1, 0, 0]))
tform = FundamentalMatrixTransform()
tform.params = essential_matrix_tform.params
src = np.array([[0, 0], [0, 0], [0, 0]])
dst = np.array([[2, 0], [2, 1], [2, 2]])
assert_almost_equal(tform.residuals(src, dst)**2, [0, 0.5, 2])
def test_fundamental_matrix_forward():
essential_matrix_tform = EssentialMatrixTransform(
rotation=np.eye(3), translation=np.array([1, 0, 0]))
tform = FundamentalMatrixTransform()
tform.params = essential_matrix_tform.params
src = np.array([[0, 0], [0, 1], [1, 1]])
assert_almost_equal(tform(src), [[0, -1, 0], [0, -1, 1], [0, -1, 1]])
def test_fundamental_matrix_inverse():
essential_matrix_tform = EssentialMatrixTransform(
rotation=np.eye(3), translation=np.array([1, 0, 0]))
tform = FundamentalMatrixTransform()
tform.params = essential_matrix_tform.params
src = np.array([[0, 0], [0, 1], [1, 1]])
assert_almost_equal(tform.inverse(src),
[[0, 1, 0], [0, 1, -1], [0, 1, -1]])
def test_essential_matrix_init():
tform = EssentialMatrixTransform(rotation=np.eye(3),
translation=np.array([0, 0, 1]))
assert_equal(tform.params,
np.array([0, -1, 0, 1, 0, 0, 0, 0, 0]).reshape(3, 3))
def test_essential_matrix_estimation():
src = np.array([1.839035, 1.924743, 0.543582, 0.375221,
0.473240, 0.142522, 0.964910, 0.598376,
0.102388, 0.140092, 15.994343, 9.622164,
0.285901, 0.430055, 0.091150, 0.254594]).reshape(-1, 2)
dst = np.array([1.002114, 1.129644, 1.521742, 1.846002,
1.084332, 0.275134, 0.293328, 0.588992,
0.839509, 0.087290, 1.779735, 1.116857,
0.878616, 0.602447, 0.642616, 1.028681]).reshape(-1, 2)
tform = estimate_transform('essential', src, dst)
# Reference values obtained using COLMAP SfM library.
tform_ref = np.array([[-0.0811666, 0.255449, -0.0478999],
[-0.192392, -0.0531675, 0.119547],
[0.177784, -0.22008, -0.015203]])
assert_almost_equal(tform.params, tform_ref, 6)
def test_essential_matrix_forward():
tform = EssentialMatrixTransform(rotation=np.eye(3),
translation=np.array([1, 0, 0]))
src = np.array([[0, 0], [0, 1], [1, 1]])
assert_almost_equal(tform(src), [[0, -1, 0], [0, -1, 1], [0, -1, 1]])
def test_essential_matrix_inverse():
tform = EssentialMatrixTransform(rotation=np.eye(3),
translation=np.array([1, 0, 0]))
src = np.array([[0, 0], [0, 1], [1, 1]])
assert_almost_equal(tform.inverse(src),
[[0, 1, 0], [0, 1, -1], [0, 1, -1]])
def test_essential_matrix_residuals():
tform = EssentialMatrixTransform(rotation=np.eye(3),
translation=np.array([1, 0, 0]))
src = np.array([[0, 0], [0, 0], [0, 0]])
dst = np.array([[2, 0], [2, 1], [2, 2]])
assert_almost_equal(tform.residuals(src, dst)**2, [0, 0.5, 2])
def test_projective_estimation():
# exact solution
tform = estimate_transform('projective', SRC[:4, :], DST[:4, :])
assert_almost_equal(tform(SRC[:4, :]), DST[:4, :])
# over-determined
tform2 = estimate_transform('projective', SRC, DST)
assert_almost_equal(tform2.inverse(tform2(SRC)), SRC)
# via estimate method
tform3 = ProjectiveTransform()
tform3.estimate(SRC, DST)
assert_almost_equal(tform3.params, tform2.params)
def test_projective_weighted_estimation():
# Exact solution with same points, and unity weights
tform = estimate_transform('projective', SRC[:4, :], DST[:4, :])
tform_w = estimate_transform('projective',
SRC[:4, :], DST[:4, :], np.ones(4))
assert_almost_equal(tform.params, tform_w.params)
# Over-determined solution with same points, and unity weights
tform = estimate_transform('projective', SRC, DST)
tform_w = estimate_transform('projective',
SRC, DST, np.ones(SRC.shape[0]))
assert_almost_equal(tform.params, tform_w.params)
# Repeating a point, but setting its weight small, should give nearly
# the same result.
point_weights = np.ones(SRC.shape[0] + 1)
point_weights[0] = 1.0e-15
tform1 = estimate_transform('projective', SRC, DST)
tform2 = estimate_transform('projective',
SRC[np.arange(-1, SRC.shape[0]), :],
DST[np.arange(-1, SRC.shape[0]), :],
point_weights)
assert_almost_equal(tform1.params, tform2.params, decimal=3)
def test_projective_init():
tform = estimate_transform('projective', SRC, DST)
# init with transformation matrix
tform2 = ProjectiveTransform(tform.params)
assert_almost_equal(tform2.params, tform.params)
def test_polynomial_estimation():
# over-determined
tform = estimate_transform('polynomial', SRC, DST, order=10)
assert_almost_equal(tform(SRC), DST, 6)
# via estimate method
tform2 = PolynomialTransform()
tform2.estimate(SRC, DST, order=10)
assert_almost_equal(tform2.params, tform.params)
def test_polynomial_weighted_estimation():
# Over-determined solution with same points, and unity weights
tform = estimate_transform('polynomial', SRC, DST, order=10)
tform_w = estimate_transform('polynomial',
SRC,
DST,
order=10,
weights=np.ones(SRC.shape[0]))
assert_almost_equal(tform.params, tform_w.params)
# Repeating a point, but setting its weight small, should give nearly
# the same result.
point_weights = np.ones(SRC.shape[0] + 1)
point_weights[0] = 1.0e-15
tform1 = estimate_transform('polynomial', SRC, DST, order=10)
tform2 = estimate_transform('polynomial',
SRC[np.arange(-1, SRC.shape[0]), :],
DST[np.arange(-1, SRC.shape[0]), :],
order=10,
weights=point_weights)
assert_almost_equal(tform1.params, tform2.params, decimal=4)
def test_polynomial_init():
tform = estimate_transform('polynomial', SRC, DST, order=10)
# init with transformation parameters
tform2 = PolynomialTransform(tform.params)
assert_almost_equal(tform2.params, tform.params)
def test_polynomial_default_order():
tform = estimate_transform('polynomial', SRC, DST)
tform2 = estimate_transform('polynomial', SRC, DST, order=2)
assert_almost_equal(tform2.params, tform.params)
def test_polynomial_inverse():
with pytest.raises(Exception):
PolynomialTransform().inverse(0)
def test_union():
tform1 = SimilarityTransform(scale=0.1, rotation=0.3)
tform2 = SimilarityTransform(scale=0.1, rotation=0.9)
tform3 = SimilarityTransform(scale=0.1 ** 2, rotation=0.3 + 0.9)
tform = tform1 + tform2
assert_almost_equal(tform.params, tform3.params)
tform1 = AffineTransform(scale=(0.1, 0.1), rotation=0.3)
tform2 = SimilarityTransform(scale=0.1, rotation=0.9)
tform3 = SimilarityTransform(scale=0.1 ** 2, rotation=0.3 + 0.9)
tform = tform1 + tform2
assert_almost_equal(tform.params, tform3.params)
assert tform.__class__ == ProjectiveTransform
tform = AffineTransform(scale=(0.1, 0.1), rotation=0.3)
assert_almost_equal((tform + tform.inverse).params, np.eye(3))
tform1 = SimilarityTransform(scale=0.1, rotation=0.3)
tform2 = SimilarityTransform(scale=0.1, rotation=0.9)
tform3 = SimilarityTransform(scale=0.1 * 1/0.1, rotation=0.3 - 0.9)
tform = tform1 + tform2.inverse
assert_almost_equal(tform.params, tform3.params)
def test_union_differing_types():
tform1 = SimilarityTransform()
tform2 = PolynomialTransform()
with pytest.raises(TypeError):
tform1.__add__(tform2)
def test_geometric_tform():
tform = GeometricTransform()
with pytest.raises(NotImplementedError):
tform(0)
with pytest.raises(NotImplementedError):
tform.inverse(0)
with pytest.raises(NotImplementedError):
tform.__add__(0)
# See gh-3926 for discussion details
for i in range(20):
# Generate random Homography
H = np.random.rand(3, 3) * 100
H[2, H[2] == 0] += np.finfo(float).eps
H /= H[2, 2]
# Craft some src coords
src = np.array([
[(H[2, 1] + 1) / -H[2, 0], 1],
[1, (H[2, 0] + 1) / -H[2, 1]],
[1, 1],
])
# Prior to gh-3926, under the above circumstances,
# destination coordinates could be returned with nan/inf values.
tform = ProjectiveTransform(H) # Construct the transform
dst = tform(src) # Obtain the dst coords
# Ensure dst coords are finite numeric values
assert(np.isfinite(dst).all())
def test_invalid_input():
with pytest.raises(ValueError):
ProjectiveTransform(np.zeros((2, 3)))
with pytest.raises(ValueError):
AffineTransform(np.zeros((2, 3)))
with pytest.raises(ValueError):
SimilarityTransform(np.zeros((2, 3)))
with pytest.raises(ValueError):
EuclideanTransform( | np.zeros((2, 3)) | numpy.zeros |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 22 23:38:35 2017
para UNLP
calibracion con incerteza:
1- calibracion intrinseca chessboard con ocv
2- tomo como condicion inicial y optimizo una funcion error custom
3- saco el hessiano en el optimo
4- sacar asi la covarianza de los parametros optimizados
teste0:
1- con imagenes no usadas para calibrar calcula la probabilidad de los
parámetros optimos dado los datos de test
@author: sebalander
"""
# %%
#import glob
import numpy as np
#import scipy.linalg as ln
import scipy.stats as sts
import matplotlib.pyplot as plt
#from importlib import reload
from copy import deepcopy as dc
#import numdifftools as ndf
#from calibration import calibrator as cl
import corner
import time
import sys
sys.path.append("/home/sebalander/Code/sebaPhD")
#from dev import multipolyfit as mpf
from dev import bayesLib as bl
#from multiprocess import Process, Queue, Value
# https://github.com/uqfoundation/multiprocess/tree/master/py3.6/examples
# %% LOAD DATA
# input
plotCorners = False
# cam puede ser ['vca', 'vcaWide', 'ptz'] son los datos que se tienen
camera = 'vcaWide'
# puede ser ['rational', 'fisheye', 'poly']
modelos = ['poly', 'rational', 'fisheye']
model = modelos[2]
imagesFolder = "./resources/intrinsicCalib/" + camera + "/"
cornersFile = imagesFolder + camera + "Corners.npy"
patternFile = imagesFolder + camera + "ChessPattern.npy"
imgShapeFile = imagesFolder + camera + "Shape.npy"
# model data files
distCoeffsFile = imagesFolder + camera + model + "DistCoeffs.npy"
linearCoeffsFile = imagesFolder + camera + model + "LinearCoeffs.npy"
tVecsFile = imagesFolder + camera + model + "Tvecs.npy"
rVecsFile = imagesFolder + camera + model + "Rvecs.npy"
imageSelection = np.arange(33) # selecciono con que imagenes trabajar
# load data
imagePoints = np.load(cornersFile)[imageSelection]
n = len(imagePoints) # cantidad de imagenes
chessboardModel = np.load(patternFile)
imgSize = tuple( | np.load(imgShapeFile) | numpy.load |
import numpy as np
from pydiva import pydiva2d
import os
import unittest
print("Running tests on Diva data")
print(" ")
class TestDivaData(unittest.TestCase):
@classmethod
def setUp(cls):
# Create lists and arrays
cls.xlist = [1., 2., 10]
cls.ylist = [2., -1., 0.]
cls.datalist = [0., 10, 0]
cls.weightlist = [1., .2, 1.]
cls.xarray = np.array((6., 4., 2.1))
cls.yarray = np.array((1., 10., -1))
cls.yarray2 = np.array((1., 10., -1, 3.))
cls.datarray = np.array((7., 8., 9.))
cls.weightarray = np.array((1., 1., 1.))
cls.nogeojsonfile = "./nodata/data.js"
cls.outputfile = "./datawrite/data.dat"
cls.geojsonfile = "./datawrite/data.js"
def test_init_data(self):
data0 = pydiva2d.Diva2DData()
self.assertIsNone(data0.x)
self.assertIsNone(data0.y)
self.assertIsNone(data0.field)
self.assertIsNone(data0.weight)
data1 = pydiva2d.Diva2DData(self.xlist, self.ylist, self.datalist)
np.testing.assert_array_equal(data1.x, self.xlist)
np.testing.assert_array_equal(data1.y, self.ylist)
np.testing.assert_array_equal(data1.field, self.datalist)
np.testing.assert_array_equal(data1.weight, np.ones_like(data1.field))
# Mix lists and arrays
data2 = pydiva2d.Diva2DData(self.xarray, self.yarray, self.datalist, self.weightlist)
np.testing.assert_array_equal(data2.x, self.xarray)
np.testing.assert_array_equal(data2.y, self.yarray)
| np.testing.assert_array_equal(data2.field, self.datalist) | numpy.testing.assert_array_equal |
# -*- coding: utf-8 -*-
"""
Created on Tue May 25 23:51:59 2021
@author: Raktim
"""
seed = 42
import tensorflow as tf
import os
import random
import numpy as np
from data_class import Data
from tqdm import tqdm
from skimage.io import imread, imshow
from skimage.transform import resize
import matplotlib.pyplot as plt
from skimage.color import rgb2gray
from skimage import img_as_float
from skimage.transform import resize
from keras.models import Model
from keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, concatenate, Conv2DTranspose, BatchNormalization, Dropout, Lambda
from keras.callbacks import ModelCheckpoint, LearningRateScheduler, EarlyStopping
from keras import backend as K
#from models_new import *
#from sq_ex_block import *
#from models import *
IMG_WIDTH = 256
IMG_HEIGHT = 256
IMG_CHANNELS = 3
TRAIN_PATH = 'C:/Users/rakti/Desktop/Test_Qupath/tiles/train/'
TEST_PATH = 'C:/Users/rakti/Desktop/Test_Qupath/tiles/test_all/'
data_obj= Data()
# You can provide your desired image size
# You can upscale or downscale
X_train, Y_train = data_obj.load_segmentation_data(TRAIN_PATH, 'tif', IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS)
X_test, Y_test = data_obj.load_segmentation_data(TEST_PATH, 'tif', IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS)
# Visualize image with corresponding mask
#data_obj.visualize(X_train,Y_train)
#Std Data Augmentation
from sklearn.model_selection import train_test_split
X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.25, random_state = seed)
from keras.preprocessing.image import ImageDataGenerator
img_data_gen_args = dict(rotation_range=90,
width_shift_range=0.3,
height_shift_range=0.3,
shear_range=0.5,
zoom_range=0.3,
horizontal_flip=True,
vertical_flip=True,
fill_mode='reflect')
mask_data_gen_args = dict(rotation_range=90,
width_shift_range=0.3,
height_shift_range=0.3,
shear_range=0.5,
zoom_range=0.3,
horizontal_flip=True,
vertical_flip=True,
fill_mode='reflect',
preprocessing_function = lambda x: np.where(x>0, 1, 0).astype(x.dtype)) #Binarize the output again.
image_data_generator = ImageDataGenerator(**img_data_gen_args)
image_data_generator.fit(X_train, augment=True, seed=seed)
mask_data_generator = ImageDataGenerator(**mask_data_gen_args)
mask_data_generator.fit(Y_train, augment=True, seed=seed)
train_image = image_data_generator.flow(X_train, seed=seed)
val_image = image_data_generator.flow(X_val, seed=seed)
train_mask = mask_data_generator.flow(Y_train, seed=seed)
val_mask = mask_data_generator.flow(Y_val, seed=seed)
#i=0
#for batch in tqdm(image_data_generator.flow(X_train, batch_size=X_train.shape[0],
# save_to_dir='C:/Users/rakti/Desktop/U-Net/augmented/image', save_format='tif', seed=seed)):
# i += 1
# if i >= 3:
# break # otherwise the generator would loop indefinitely
#
#j=0
#for batch in tqdm(mask_data_generator.flow(Y_train, batch_size=Y_train.shape[0],
# save_to_dir='C:/Users/rakti/Desktop/U-Net/augmented/mask', save_format='tif', seed=seed)):
# j += 1
# if j >=3:
# break # otherwise the generator would loop indefinitely
def my_image_mask_generator(image_generator, mask_generator):
train_generator = zip(image_generator, mask_generator)
for (img, mask) in train_generator:
yield (img, mask)
train_generator = my_image_mask_generator(train_image, train_mask)
validation_generator = my_image_mask_generator(val_image, val_mask)
x = train_image.next()
y = train_mask.next()
for i in range(0,1):
image = x[i]
mask = y[i]
plt.subplot(1,2,1)
plt.imshow(image[:,:])
plt.subplot(1,2,2)
plt.imshow(mask[:,:,0], cmap='gray')
plt.show()
from sklearn.model_selection import train_test_split
import segmentation_models as sm
from segmentation_models.losses import bce_jaccard_loss, bce_dice_loss, binary_crossentropy
from segmentation_models.metrics import iou_score, f1_score, recall, precision
from segmentation_models.utils import set_trainable
from segmentation_models import metrics, losses
from keras.models import load_model
from skimage import img_as_float, img_as_int
BACKBONE = 'seresnet50'
preprocess_input = sm.get_preprocessing(BACKBONE)
model_checkpoint = ModelCheckpoint('unet_v1_camelyon16.h5', monitor='loss', verbose=1, save_best_only=True)
#X_train = preprocess_input(X_train)
#X_train = preprocess_input(train_img)
#x_val = preprocess_input(_val)
# define model
model = sm.Unet(BACKBONE, encoder_weights='imagenet', input_shape=(IMG_WIDTH, IMG_HEIGHT, IMG_CHANNELS), classes=1, encoder_freeze=True)
#model = sm.PSPNet(BACKBONE, encoder_weights='imagenet', input_shape=(240, 240, 3))
model.compile(optimizer='adam', loss=bce_dice_loss, metrics=[metrics.iou_score])
print(model.summary())
batch_size = 50
steps_per_epoch = 3*(len(X_train))//batch_size
history = model.fit_generator(train_generator, validation_data=validation_generator,
epochs=100, validation_steps=steps_per_epoch, steps_per_epoch=steps_per_epoch,
callbacks=[model_checkpoint])
#history = model.fit(train_generator, validation_steps=20, validation_data=validation_datagen, epochs=50, steps_per_epoch=100)
#steps_per_epoch=2000 // batch_size
#validation_steps=800 // batch_size
#model.load_weights('unet_seresnet50_camelyon16.h5')
objects={'binary_crossentropy_plus_dice_loss': bce_dice_loss, 'iou_score':iou_score}
model=load_model('unet_seresnet50_camelyon16.h5', custom_objects=objects)
#model.compile(optimizer='adam', loss=bce_dice_loss, metrics=[iou_score])
model.summary()
#Evaluate the model
# evaluate model
_, acc = model.evaluate(X_test, Y_test)
print("Accuracy of Jacard Model is = ", (acc * 100.0), "%")
#IOU
y_pred=model.predict(X_test)
y_pred_thresholded = y_pred > 0.5
intersection = np.logical_and(Y_test, y_pred_thresholded)
union = np.logical_or(Y_test, y_pred_thresholded)
iou_score = np.sum(intersection) / | np.sum(union) | numpy.sum |
import torch
import numpy as np
from torch import nn
from .base import PDE
from .cuboid_mesh import CuboidMesh
def gauss_pt_eval(tensor, N, nsd=2, stride=1):
if nsd == 1:
conv_gp = nn.functional.conv1d
elif nsd == 2:
conv_gp = nn.functional.conv2d
elif nsd == 3:
conv_gp = nn.functional.conv3d
result_list = []
for i in range(len(N)):
result_list.append(conv_gp(tensor, N[i], stride=stride))
return torch.cat(result_list, 1)
class DiffNetFEM(PDE):
"""docstring for DiffNetFEM"""
def __init__(self, network, dataset, **kwargs):
super(DiffNetFEM, self).__init__(network, dataset, **kwargs)
self.ngp_1d = kwargs.get('ngp_1d', 2)
self.fem_basis_deg = kwargs.get('fem_basis_deg', 1)
# Gauss quadrature setup
if self.fem_basis_deg == 1:
ngp_1d = 2
elif self.fem_basis_deg == 2:
ngp_1d = 3
elif self.fem_basis_deg == 3:
ngp_1d = 3
if ngp_1d > self.ngp_1d:
self.ngp_1d = ngp_1d
self.ngp_total = ngp_total = self.ngp_1d**self.nsd
self.gpx_1d, self.gpw_1d = self.gauss_guadrature_scheme(self.ngp_1d)
self.nelemX = nelemX = int((self.domain_sizeX - 1)/self.fem_basis_deg)
self.nelemY = nelemY = int((self.domain_sizeY - 1)/self.fem_basis_deg)
if self.nsd == 3:
self.nelemZ = nelemZ = int((self.domain_sizeZ - 1)/self.fem_basis_deg)
self.nelem = nelem = int((self.domain_size - 1)/self.fem_basis_deg) # for backward compatibility (uses the X dir value)
self.hx = self.domain_lengthX / self.nelemX
self.hy = self.domain_lengthY / self.nelemY
if self.nsd == 3:
self.hz = self.domain_lengthZ / self.nelemZ
self.h = self.domain_length / self.nelem # for backward compatibility (uses the X dir value)
# Basis functions setup
if self.fem_basis_deg == 1:
self.nbf_1d = nbf_1d = 2
self.nbf_total = nbf_total = self.nbf_1d**self.nsd
self.bf_1d = lambda x: np.array([0.5*(1.-x), 0.5*(1.+x)])
self.bf_1d_der = lambda x: | np.array([0.5*(0.-1.), 0.5*(0.+1.)]) | numpy.array |
__all__ = [
"B_components",
"geodetic_to_geocentric",
"geodetic_to_geocentric_IGRF13",
"decdeg2dms",
"Norm_Schimdt",
"Norm_Stacey",
"grid_geomagnetic",
"construct_xarray",
"plot_geomagetism",
]
# Ellipsoid parameters: semi major axis in metres, reciprocal flattening.
GRS80 = (6_378_137, 298.257222100882711)
WGS84 = (6_378_137, 298.257223563)
# Ellipsoid parameters: semi major axis in metres, semi minor axis in metres.
GRS80_ = (6378.137, 6356.752314140355847852106)
WGS84_ = (6378.137, 6356.752314245179497563967)
# mean radius of the earth in metres must be chosen in accorance with the radius used in determining
# the SH coefficients
EARTH_RADIUS = 6_371_200
def B_components(
phi_,
theta_,
altitude,
Date,
referential="geodetic",
file="IGRF13.COF",
ELLIPSOID=WGS84,
SV=False,
):
"""B_components computes the geomagnetic magnetic field components.
We use the Peddie's notation <NAME>. (1982). "International Geomagnetic Reference Field : the third generation."
J. Geomag. Geolectr 34: 309-326.
Arguments
phi_ (float): longitude in deg (0° - 360°) or West East longitude (-180° - +180°)
theta_(float): Colatitude in deg (0° - 180°)
altitude (float): Elevation in m,
Date : Date used to compute the magnetic field 1900<= Date< 2025 . Date is a dictionary
Date["mode"]="ymd" if Date is expressed as yyyy/mm/dd otherwise Date is in decimal value
Date["year"]= year if Date["mode"]="ymd" oterwise Date["year"]=decimal value year
Date["month"]
Date["day"],
Date["hour"]
Date["minute"]
Date["second"]
ex: Date = {"mode":"ymd","year":2020,"month":16,"day":16,"hour":0,"minute":0,"second":0}
Date = {"dec":"ymd","year":2020.5}
referential : referential = geotetic if the colatitude is expressed in geotetic referential
: referential = geocentric if the colatitude is expressed in geotetic referential
file (string) : name of the file containing the Gauss coefficients h and g
file = "IGRF13.COF" or "WMM_2015.COF" or "WMM_2020.COF" (default "WMM_2020.COF")
ELLIPSOID (tuple): WGS84 or WGS84 (default WGS84)
SV (bool): if True computation of the field secular variation
Returns
result (dict):{'D': Declination in deg,
'F': Total field intensity in nT,
'H': Horizontal field intensity in nT,
'I': Inclination in deg,
'X': North component in nT in the geocentric coordinate,
'Y': East component in nT in both geocentric and geotetic coordinate,
'Z': Down component in nT in the geocentric coordinate,
'Fd': Total field intensity secular variation in nT/year if SV==True None elsewhere,
'Hd': Horizontal field intensity secular variation in nT/year if SV==True None if SV==True None elsewhere,
'Yd': East component secular variation in nT/year in both geocentric and geotetic coordinate if SV==True None elsewhere,
'Zd': Down component secular variatin in nT/year in the geocentric coordinate if SV==True None elsewhere,
'Id': Inclination secular variationin deg/year,
'Dd': Declination secular variationin deg/year
"""
# Standard Library dependencies
import os as os
# 3rd party import
import numpy as np
from scipy.special import lpmn
# Internal import
from .read_geo_data import read_gauss_coeff
EPS = 1.0e-5 # if colatitude <EOS rad or colatitude > pi-EPS we call field_computation_pole
ADD_YEARS = 5 # extrapolation possible over ADD_YEARS additional years
def assign_hg(Date):
"""Time interpollation/extrapollation of the coefficients h and g :
- for years[0]<= Year <years[-1] we use an interpollation scheme
- for years[-1]<=year<=years[-1]+ 5 we use an extrapolationllation scheme with a secular variation (SV) nT/year """
if Date["mode"] == "ymd":
del Date["mode"]
Year = decimal_year(**Date)
else:
Year = Date["year"]
if (Year < years[0]) or (Year > years[-1] + ADD_YEARS):
raise Exception(
f"Year={Year} out of range. Must be >={years[0]} and <= {years[0]+5}"
)
idx = (np.where(years <= Year))[0][-1]
year = int(years[idx])
dt = Year - year
dic_h0 = dic_dic_h[str(year)]
dic_g0 = dic_dic_g[str(year)]
N = dic_N[str(year)]
dic_h = {}
dic_g = {}
if (
(Year >= years[0]) & (Year < years[-1]) & (years[0] != years[-1])
): # use interpollation
Dt = years[idx + 1] - years[idx]
dic_h1 = dic_dic_h[str(int(years[idx + 1]))]
dic_g1 = dic_dic_g[str(int(years[idx + 1]))]
for x in dic_h0.keys():
dic_h[x] = dic_h0[x] + dt * (dic_h1[x] - dic_h0[x]) / Dt
dic_g[x] = dic_g0[x] + dt * (dic_g1[x] - dic_g0[x]) / Dt
elif (Year >= years[-1]) & (
Year < years[-1] + ADD_YEARS
): # use extrapolation through secular variation (SV)
for x in dic_h0.keys():
dic_h[x] = dic_h0[x] + dic_dic_SV_h[str(int(years[-1]))][x] * dt
dic_g[x] = dic_g0[x] + dic_dic_SV_g[str(int(years[-1]))][x] * dt
return dic_h, dic_g, N, year
# Assign dic_dic_g,dic_dic_h,dic_dic_SV_g,dic_dic_SV_h,dic_N,years
# Avoid the reaffectation of these coefficients after the first call of B_components
B_components.flag = getattr(B_components, "flag", True)
if B_components.flag: # First call
(
dic_dic_h,
dic_dic_g,
dic_dic_SV_h,
dic_dic_SV_g,
dic_N,
years,
) = read_gauss_coeff(file=file)
B_components.dic_dic_g = getattr(B_components, "dic_dic_g", dic_dic_g)
B_components.dic_dic_h = getattr(B_components, "dic_dic_h", dic_dic_h)
B_components.dic_dic_SV_h = getattr(B_components, "dic_dic_SV_h", dic_dic_SV_h)
B_components.dic_dic_SV_g = getattr(B_components, "dic_dic_SV_g", dic_dic_SV_g)
B_components.dic_N = getattr(B_components, "dic_N", dic_N)
B_components.years = getattr(B_components, "years", years)
B_components.flag = False
else:
dic_dic_g = B_components.dic_dic_g
dic_dic_h = B_components.dic_dic_h
dic_dic_SV_h = B_components.dic_dic_SV_h
dic_dic_SV_g = B_components.dic_dic_SV_g
dic_N = B_components.dic_N
years = B_components.years
dic_h, dic_g, N, year = assign_hg(
Date
) # performs interpolation of the coefficients h and g
# Compute the transformation matrix from geodetic to geocentric frames
if referential == "geodetic":
r_geocentric, co_latitude_geocentric, delta = geodetic_to_geocentric(
ELLIPSOID, theta_, altitude
)
theta = co_latitude_geocentric
mat_rot = np.array(
[
[np.cos(delta), 0, np.sin(delta)],
[0, 1, 0],
[-np.sin(delta), 0, np.cos(delta)],
]
)
else:
r_geocentric = EARTH_RADIUS + altitude
theta = theta_ * np.pi / 180
mat_rot = np.identity(3)
r_a = EARTH_RADIUS / r_geocentric
if phi_ >= 0:
phi = phi_ * np.pi / 180
else:
phi = (360 + phi_) * np.pi / 180
# synthesis of Xc, Yc and Zc in geocentric coordinates
if theta > EPS and theta < np.pi - EPS:
# Legendre polynomes computation
Norm = Norm_Schimdt(N, N)
M, Mp = lpmn(N, N, np.cos(theta))
M = M * Norm
Mp = Mp * Norm * (-1) * np.sin(theta) # dPn,m(cos(theta))/d theta
X, Y, Z = field_computation(r_a, M, Mp, phi, theta, dic_g, dic_h, N, mat_rot)
else:
X, Y, Z = field_computation_pole(r_a, phi, theta, dic_g, dic_h, N, mat_rot, EPS)
F = np.linalg.norm([X, Y, Z])
H = np.linalg.norm([X, Y])
D = np.arctan2(Y, X) * 180 / np.pi # declination
I = np.arctan2(Z, H) * 180 / np.pi # inclination
# secular variation computation
Xd, Yd, Zd, Hd, Fd = [None] * 5
if SV:
if theta > EPS and theta < np.pi - EPS:
# Legendre polynomes computation
Norm = Norm_Schimdt(N, N)
M, Mp = lpmn(N, N, np.cos(theta))
M = M * Norm
Mp = Mp * Norm * (-1) * np.sin(theta) # dPn,m(cos(theta))/d theta
Xd, Yd, Zd = field_computation(
r_a,
M,
Mp,
phi,
theta,
dic_dic_SV_g[str(year)],
dic_dic_SV_h[str(year)],
N,
mat_rot,
)
else:
Xd, Yd, Zd = field_computation_pole(
r_a,
phi,
theta,
dic_dic_SV_g[str(year)],
dic_dic_SV_h[str(year)],
N,
mat_rot,
EPS,
)
Hd = (X * Xd + Y * Yd) / H
Fd = (X * Xd + Y * Yd + Z * Zd) / F
Id = 180 * (H * Zd - Z * Hd) / (F * F * np.pi)
Dd = 180 * (X * Yd - Y * Xd) / (H * H * np.pi)
result = dict(
zip(
[
"X",
"Y",
"Z",
"F",
"H",
"I",
"D",
"Xd",
"Yd",
"Zd",
"Hd",
"Fd",
"Id",
"Dd",
],
[X, Y, Z, F, H, I, D, Xd, Yd, Zd, Hd, Fd, Id, Dd],
)
)
return result
def field_computation_pole(r_a, phi, theta, dic_g, dic_h, N, mat_rot, EPS):
"""
compute the geomagnetic field in the geotetic coordinates near the north and south pole.
Arguments:
r_a (float): geocentric radial ccordinale/radius of the Earth
phi (float); longitude (rad)
theta:
dic_g (dict): g Gauss coefficients
dic_h (dict): h Gauss coefficients
N (int): order of the spherical harmonic decomposition
Returns:
X (float): North component in nT in the geocentric coordinate,
Y (float): East component in nT in both geocentric and geotetic coordinate,
Z (float): Down component in nT in the geocentric coordinate,
"""
# 3rd party import
import numpy as np
Zc = 0
Sh = 0
Sg = 0
coef = r_a * r_a
if theta < EPS:
for n in range(1, N + 1):
coef *= r_a
Zc -= (n + 1) * (r_a) ** (n + 2) * dic_g[(0, n)]
Sh += np.sqrt(n * (n + 1) / 2) * (r_a) ** (n + 2) * dic_h[(1, n)]
Sg += np.sqrt(n * (n + 1) / 2) * (r_a) ** (n + 2) * dic_g[(1, n)]
Xc = Sg * np.cos(phi) + Sh * np.sin(phi)
Yc = Sg * np.sin(phi) - Sh * np.cos(phi)
elif theta > np.pi - EPS:
for n in range(1, N + 1):
coef *= -r_a
Zc -= coef * (n + 1) * dic_g[(0, n)]
Sh += coef * np.sqrt(n * (n + 1) / 2) * dic_h[(1, n)]
Sg += coef * np.sqrt(n * (n + 1) / 2) * dic_g[(1, n)]
Xc = Sg * np.cos(phi) + Sh * np.sin(phi)
Yc = -Sg * np.sin(phi) + Sh * np.cos(phi)
[X, Y, Z] = np.matmul(mat_rot, [Xc, Yc, Zc])
return X, Y, Z
def field_computation(r_a, M, Mp, phi, theta, dic_g, dic_h, N, mat_rot):
"""
compute the geomagnetic field in the geotetic coordinates
Arguments:
r_a (float): geocentric radial ccordinale/radius of the Earth
M (np array): matrix of the Legendre polynomes values
Mp (np array): matrix of the derivative of the Legendre polynomes vs the colatitude
phi (float); longitude (rad)
theta:
dic_g (dict): g Gauss coefficients
dic_h (dict): h Gauss coefficients
N (int): order of the spherical harmonic decomposition
Returns:
X (float): North component in nT in the geocentric coordinate,
Y (float): East component in nT in both geocentric and geotetic coordinate,
Z (float): Down component in nT in the geocentric coordinate,
"""
# 3rd party import
import numpy as np
# synthesis of Xc, Yc and Zc in geocentric coordinates
Xc = 0.0
Yc = 0.0
Zc = 0.0
coef = r_a * r_a
for n in range(1, N + 1):
coef *= r_a
Xc += (
sum(
[
Mp[m, n]
* (
dic_g[(m, n)] * np.cos(m * phi)
+ dic_h[(m, n)] * np.sin(m * phi)
)
for m in range(0, n + 1)
]
)
* coef
)
Yc += (
sum(
[
m
* M[m, n]
* (
dic_g[(m, n)] * np.sin(m * phi)
- dic_h[(m, n)] * np.cos(m * phi)
)
for m in range(0, n + 1)
]
)
* coef
)
Zc -= (
sum(
[
M[m, n]
* (
dic_g[(m, n)] * np.cos(m * phi)
+ dic_h[(m, n)] * np.sin(m * phi)
)
for m in range(0, n + 1)
]
)
* coef
* (n + 1)
)
Yc = Yc / np.sin(theta)
# conversion to the coordinate system specified by variable referential
[X, Y, Z] = np.matmul(mat_rot, [Xc, Yc, Zc])
return X, Y, Z
def geodetic_to_geocentric(ellipsoid, co_latitude, height):
"""Return geocentric (Cartesian) radius and colatitude corresponding to
the geodetic coordinates given by colatitude (in
degrees ) and height (in metre) above ellipsoid.
see http://clynchg3c.com/Technote/geodesy/coordcvt.pdf
credit : https://codereview.stackexchange.com/questions/195933/convert-geodetic-coordinates-to-geocentric-cartesian
with minor modifications.
Arguments:
ellipsoid (tuple): ellipsoid parameters (semi-major axis, reciprocal flattening)
co_latitude (float): geotetic colatitude (in degrees) 0°<=co_latitude<=180°
height (float): height (in metre) above ellipsoid
Returns
r_geocentric (float): geocentric radius (m)
co_latitude_geocentric (float): geocentric colatitude (radians)
delta (float): angle between geocentric and geodetic referentials (radians)
"""
# 3rd Party dependencies
from math import radians
import numpy as np
lat = radians(90 - co_latitude) # geodetic latitude
sin_lat = np.sin(lat)
a, rf = ellipsoid # semi-major axis, reciprocal flattening
e2 = 1 - (1 - 1 / rf) ** 2 # eccentricity squared
r_n = a / np.sqrt(1 - e2 * sin_lat ** 2) # prime vertical curvature radius
r = (r_n + height) * np.cos(lat) # perpendicular distance from z axis
z = (r_n * (1 - e2) + height) * sin_lat
r_geocentric = np.sqrt(r ** 2 + z ** 2)
co_latitude_geocentric = np.pi / 2 - np.arctan(
(1 - e2 * r_n / (r_n + height)) * np.tan(lat)
) # geocentric colatitude
delta = co_latitude_geocentric - radians(
co_latitude
) # angle between geocentric and geodetic referentials
return r_geocentric, co_latitude_geocentric, delta
def geodetic_to_geocentric_IGRF13(ellipsoid, co_latitude, height):
"""conversion from geodetic to geocentric coordinates.
Translated from FORTRAN program IGRF13
ellipsoid = GRS80 or WGS84 according to the choice of world geodetic system
[1] Peddie, <NAME>. International Geomagnetic Reference Field : the third generation J. Geomag. Geolectr 34 p. 309-326
Arguments
ellipsoid (tuple): (a=semi major axis in metres, b=semi major axis in metres)
colatitude : geodetic colatitude in degree (0<= colatitude <=180)
height : elevation in meters above the geoid
Returns
r : geocentric radius
ct: cos(geocentric colatitude )
st: sin(geocentric colatitude )
cd: cos(delta ) delta is the angle between geocentric and geodetic colatitude (radians)
sd: sin(delta )"""
# 3rd Party dependencies
from math import radians
import numpy as np
theta = radians(co_latitude)
st = np.sin(theta)
ct = np.cos(theta)
a, b = ellipsoid # a,b semi major and semi minor axis
a2 = a * a
b2 = b * b
one = a2 * st * st
two = b2 * ct * ct
three = one + two
rho = np.sqrt(three) # a*a/r_n with r_n the prime vertical curvature radius
r = np.sqrt(
height * (height + 2.0 * rho) + (a2 * one + b2 * two) / three
) # geocentric radius [1](6)
cd = (height + rho) / r # cos(delta )
sd = (a2 - b2) / rho * ct * st / r # sin(delta )
one = ct
ct = ct * cd - st * sd # cos(geocentric colatitude )
st = st * cd + one * sd # sin(geocentric colatitude )
return r, ct, st, cd, sd
def Norm_Schimdt(m, n):
"""Norm_Schimdt buids the normalization matrix which coefficients can be found in
Winch D. E. et al. Geomagnetism and Schmidt quasi-normalization Geophys. J. Int. 160 p. 487-454 2005"""
# 3rd party dependencies
import math
import numpy as np
sgn = lambda m: 1 if m % 2 == 0 else -1
norm = (
lambda m, n: sgn(m)
* np.sqrt((2 - (m == 0)) * math.factorial(n - m) / math.factorial(n + m))
if m > 0
else 1
)
norm_schimdt = []
for m_ in range(m + 1):
norm_schimdt.append(
[norm(m_, n_) if (n_ - np.abs(m_) >= 0) else 0 for n_ in range(n + 1)]
)
return np.array(norm_schimdt)
def Norm_Stacey(m, n):
"""Norm_Stacey buids the normalization matrix which coefficients can be found in
Stracey F. D. et al. Physics of the earth Cambridge appendix C"""
# 3rd party dependencies
import math
import numpy as np
sgn = lambda m: 1 if m % 2 == 0 else -1
norm = (
lambda m, n: sgn(m)
* np.sqrt(
(2 - (m == 0)) * (2 * m + 1) * math.factorial(n - m) / math.factorial(n + m)
)
if m > 0
else 1
)
norm_stacey = []
for m_ in range(m + 1):
norm_stacey.append(
[norm(m_, n_) if (n_ - np.abs(m_) >= 0) else 0 for n_ in range(n + 1)]
)
return np.array(norm_stacey)
def decimal_year(year, month, day, hour, minute, second):
"""decimal_year converts a date (year,month,day,hour,minute,second) into a decimal date. credit : Kimvais
https://stackoverflow.com/questions/6451655/how-to-convert-python-datetime-dates-to-decimal-float-years"""
# Standard Library dependencies
from datetime import datetime
d = datetime(year, month, day, hour, minute, second)
year_ = (float(d.strftime("%j")) - 1) / 366 + float(d.strftime("%Y"))
return year_
def decdeg2dms(dd):
""" Tansform decimal degrees into degrees minutes seconds
Argument:
dd (float): decimal angle
Returns:
degrees, minutes, seconds"""
negative = dd < 0
dd = abs(dd)
minutes, seconds = divmod(dd * 3600, 60)
degrees, minutes = divmod(minutes, 60)
if negative:
if degrees > 0:
degrees = -degrees
elif minutes > 0:
minutes = -minutes
else:
seconds = -seconds
return degrees, minutes, seconds
def construct_xarray(intensities, angles, intensities_sv, angles_sv, longitudes, colatitudes):
"""
construct the xarray of a hyperspectrum
Arguments:
intensities (np array): geomagnetic field components intensity (nT)
angles (np array): geomagnetic field inclination and declination
intensities_sv (np array): secular variation of geomagnetic field components intensity (nT/year)
angles_sv (np array): secular variation of the geomagnetic field inclination and declination (°/year)
longitudes (np array): longitude (°)
colatitudes (np array): colatitude (°)
Returns:
dintensities (xarray): hyperspectrum containing the geomagnetic field components intensity
dangles (xarray): hyperspectrum containing the geomagnetic field declination and inclination
dintensities_sv (xarray): hyperspectrum containing the geomagnetic field components intensity secular variation
dangles_sv (xarray): hyperspectrum containing the geomagnetic field declination and inclination secular variation
"""
# 3rd party dependencies
import xarray as xr
import numpy as np
y = 90 - colatitudes
dintensities = xr.DataArray(
intensities,
dims=["typ", "lat", "long"],
name="Field intensity",
attrs={"units": "nT",},
coords={
"typ": xr.DataArray(["X", "Y", "Z", "H", "F",], name="typ", dims=["typ"]),
"lat": xr.DataArray(y, name="lat", dims=["lat"], attrs={"units": "°"}),
"long": xr.DataArray(
longitudes, name="long", dims=["long"], attrs={"units": "°"}
),
},
)
dangles = xr.DataArray(
angles,
dims=["typ", "lat", "long"],
name="Angle",
attrs={"units": "°",},
coords={
"typ": xr.DataArray(["D", "I",], name="typ", dims=["typ"]),
"lat": xr.DataArray(y, name="lat", dims=["lat"], attrs={"units": "°"}),
"long": xr.DataArray(
longitudes, name="long", dims=["long"], attrs={"units": "°"}
),
},
)
dintensities_sv = xr.DataArray(
intensities_sv,
dims=["typ", "lat", "long"],
name="Field intensity secular variation",
attrs={"units": "nT/year",},
coords={
"typ": xr.DataArray(["Xd", "Yd", "Zd", "Hd", "Fd",], name="typ", dims=["typ"]),
"lat": xr.DataArray(y, name="lat", dims=["lat"], attrs={"units": "°"}),
"long": xr.DataArray(
longitudes, name="long", dims=["long"], attrs={"units": "°"}
),
},
)
dangles_sv = xr.DataArray(
angles_sv,
dims=["typ", "lat", "long"],
name="Angle secular variation",
attrs={"units": "°/year",},
coords={
"typ": xr.DataArray(["Dd", "Id",], name="typ", dims=["typ"]),
"lat": xr.DataArray(y, name="lat", dims=["lat"], attrs={"units": "°"}),
"long": xr.DataArray(
longitudes, name="long", dims=["long"], attrs={"units": "°"}
),
},
)
return dintensities, dangles, dintensities_sv, dangles_sv
def grid_geomagnetic(colatitudes, longitudes, height=0, Date={"mode":"dec","year":2020.0}):
"""computes the geomagnetic field characteristics on a mesh of
colatitudes, latitudes
Arguments:
colatitudes (nparray): list of colatitudes
latitudes (nparray): list of latitudes
height (float): height (meters)
Returns:
da (xarray): containing the values of the geomagnetic field components,
declination and inclination
"""
# 3rd party dependencies
import numpy as np
from tqdm import trange
X,Y,Z,H,F,D,I = [],[],[],[],[],[],[]
Xd,Yd,Zd,Hd,Fd,Dd,Id = [],[],[],[],[],[],[]
for index in trange(len(colatitudes), desc="colatitude"):
colatitude = colatitudes[index]
for longitude in longitudes:
result = B_components(
longitude,
colatitude,
height,
Date,
referential="geodetic",
file="WMM_2020.COF",
SV=True,
)
X.append(result["X"])
Y.append(result["Y"])
Z.append(result["Z"])
H.append(result["H"])
F.append(result["F"])
D.append(result["D"])
I.append(result["I"])
Xd.append(result["Xd"])
Yd.append(result["Yd"])
Zd.append(result["Zd"])
Hd.append(result["Hd"])
Fd.append(result["Fd"])
Dd.append(result["Dd"])
Id.append(result["Id"])
intensities = [
np.array(X).reshape((len(colatitudes), len(longitudes))),
| np.array(Y) | numpy.array |
from numpy import loadtxt, degrees, arcsin, arctan2, sort, unique, ones, zeros_like, array
from mpl_toolkits.basemap import Basemap
import reverse_geocoder as rg
import randomcolor
def domino(lol):
# Takes a list (length n) of lists (length 2)
# and returns a list of indices order,
# such that lol[order[i]] and lol[order[i+1]]
# have at least one element in common.
# If that is not possible, multiple
# domino chains will be created.
# This works in a greedy way.
n = len(lol)
order = [0] # Greedy
link = lol[0][-1]
links = [lol[0][0],lol[0][1]]
while len(order)<n:
for i in [j for j in range(n) if not j in order]:
if link in lol[i]: # They connect
order.append(i) # Save the id of the "stone"
link = lol[i][0] if not(lol[i][0]==link) else lol[i][1] # The new link is the other element
links.append(link)
break
return order,links[:-1]
def getpatches(color,quadrature):
xyz,neighbours,triangles = quadrature["xyz"], quadrature["neighbours"], quadrature["triangles"]
nq = len(color)
patches = []
for center in range(nq):
lol = [] # list of lists
for i in neighbours[center,:]:
if i>-1:
lol.append(list(sort(triangles[i,triangles[i,:] != center])))
order,links = domino(lol)
neighx = [xyz[j,0] for j in links]
neighy = [xyz[j,1] for j in links]
neighz = [xyz[j,2] for j in links]
# Get the actual hexagon that surrounds a center point
x = []
y = []
z = []
for i in range(len(order)):
x.append((xyz[center,0]+neighx[i]) / 2)
x.append((xyz[center,0]+neighx[i]+neighx[(i+1)%len(order)])/3)
y.append((xyz[center,1]+neighy[i]) / 2)
y.append((xyz[center,1]+neighy[i]+neighy[(i+1)%len(order)])/3)
z.append((xyz[center,2]+neighz[i]) / 2)
z.append((xyz[center,2]+neighz[i]+neighz[(i+1)%len(order)])/3)
verts = [list(zip(x,y,z))]
patches.append(verts[0])
return patches
def getquadrature(nq):
quadrature = {}
quadrature["nq"] = nq
quadrature["xyz"] = loadtxt(f"quadrature/{nq}/points.txt")
quadrature["weights"] = loadtxt(f"quadrature/{nq}/weights.txt")
quadrature["neighbours"] = loadtxt(f"quadrature/{nq}/neighbours.txt",dtype=int)-1 # julia starts at 1
quadrature["triangles"] = loadtxt(f"quadrature/{nq}/triangles.txt",dtype=int)-1 # julia starts at 1
# Also convert to latitute, longitude
quadrature["lat"] = degrees(arcsin(quadrature["xyz"][:,2]/1))
quadrature["lon"] = degrees(arctan2(quadrature["xyz"][:,1], quadrature["xyz"][:,0]))
# Compute connectivity between nodes
connection = -100*ones((quadrature["nq"],6),dtype=int)
for qp in range(quadrature["nq"]):
attachedtriangles = quadrature["neighbours"][qp]
attachedtriangles = attachedtriangles[attachedtriangles>-1] # drop
lol = []
for at in attachedtriangles:
tmp = quadrature["triangles"][at]
tmp = tmp[tmp != qp ]
lol.append(list(tmp))
_,x = domino(lol)
connection[qp,:len(x)] = x
quadrature["connection"] = connection
return quadrature
def get_land(quadrature):
bm = Basemap()
island = []
for i,(ypt, xpt) in enumerate(zip(quadrature["lat"],quadrature["lon"])):
land = (bm.is_land(xpt,ypt))
island.append(land)
return array(island)
def color_land(quadrature):
island = get_land(quadrature)
colors = ["tab:green" if land else "tab:blue" for land in island]
return colors
def color_country(quadrature):
# uses reverse_geocoder
results = rg.search([(la,lo) for la,lo in zip(quadrature["lat"],quadrature["lon"])]) # default mode = 2
countries = []
for i in range(len(results)):
c = results[i]["cc"]
countries.append(c)
nunique = len(unique(countries))
raco = randomcolor.RandomColor()
randomcolors = raco.generate(luminosity="dark", count=nunique) # options: https://github.com/kevinwuhoo/randomcolor-py
colordict = dict(zip(unique(countries),randomcolors))
colorland = color_land(quadrature) # so we can color the ocean also in "tab:blue"
colorcountries = [colordict[country] if colorland[i]!="tab:blue" else "tab:blue" for i,country in enumerate(countries) ]
return colorcountries
def applyupdate(quadrature,rule,states):
nextstate = | zeros_like(states) | numpy.zeros_like |
# -*- coding: utf-8 -*-
import time
from datetime import datetime
import warnings
from textwrap import dedent, fill
import numpy as np
import pandas as pd
from numpy.linalg import norm, inv
from scipy.linalg import solve as spsolve, LinAlgError
from scipy.integrate import trapz
from scipy import stats
from lifelines.fitters import BaseFitter, Printer
from lifelines.plotting import set_kwargs_drawstyle
from lifelines.statistics import chisq_test, proportional_hazard_test, TimeTransformers, StatisticalResult
from lifelines.utils.lowess import lowess
from lifelines.utils.concordance import _concordance_summary_statistics, _concordance_ratio
from lifelines.utils import (
_get_index,
_to_list,
_to_tuple,
_to_1d_array,
inv_normal_cdf,
normalize,
qth_survival_times,
coalesce,
check_for_numeric_dtypes_or_raise,
check_low_var,
check_complete_separation,
check_nans_or_infs,
StatError,
ConvergenceWarning,
StatisticalWarning,
StepSizer,
ConvergenceError,
string_justify,
interpolate_at_times_and_return_pandas,
CensoringType,
interpolate_at_times,
format_p_value,
)
__all__ = ["CoxPHFitter"]
class BatchVsSingle:
@staticmethod
def decide(batch_mode, n_unique, n_total, n_vars):
frac_dups = n_unique / n_total
if batch_mode or (
# https://github.com/CamDavidsonPilon/lifelines/issues/591 for original issue.
# new values from from perf/batch_vs_single script.
(batch_mode is None)
and (
(
6.876218e-01
+ -1.796993e-06 * n_total
+ -1.204271e-11 * n_total ** 2
+ 1.912500e00 * frac_dups
+ -8.121036e-01 * frac_dups ** 2
+ 4.916605e-06 * n_total * frac_dups
+ -5.888875e-03 * n_vars
+ 5.473434e-09 * n_vars * n_total
)
< 1
)
):
return "batch"
return "single"
class CoxPHFitter(BaseFitter):
r"""
This class implements fitting Cox's proportional hazard model:
.. math:: h(t|x) = h_0(t) \exp((x - \overline{x})' \beta)
Parameters
----------
alpha: float, optional (default=0.05)
the level in the confidence intervals.
tie_method: string, optional
specify how the fitter should deal with ties. Currently only
'Efron' is available.
penalizer: float, optional (default=0.0)
Attach an L2 penalizer to the size of the coefficients during regression. This improves
stability of the estimates and controls for high correlation between covariates.
For example, this shrinks the absolute value of :math:`\beta_i`.
The penalty is :math:`\frac{1}{2} \text{penalizer} ||\beta||^2`.
strata: list, optional
specify a list of columns to use in stratification. This is useful if a
categorical covariate does not obey the proportional hazard assumption. This
is used similar to the `strata` expression in R.
See http://courses.washington.edu/b515/l17.pdf.
Examples
--------
>>> from lifelines.datasets import load_rossi
>>> from lifelines import CoxPHFitter
>>> rossi = load_rossi()
>>> cph = CoxPHFitter()
>>> cph.fit(rossi, 'week', 'arrest')
>>> cph.print_summary()
Attributes
----------
params_ : Series
The estimated coefficients. Changed in version 0.22.0: use to be ``.hazards_``
hazard_ratios_ : Series
The exp(coefficients)
confidence_intervals_ : DataFrame
The lower and upper confidence intervals for the hazard coefficients
durations: Series
The durations provided
event_observed: Series
The event_observed variable provided
weights: Series
The event_observed variable provided
variance_matrix_ : numpy array
The variance matrix of the coefficients
strata: list
the strata provided
standard_errors_: Series
the standard errors of the estimates
score_: float
the concordance index of the model.
baseline_hazard_: DataFrame
baseline_cumulative_hazard_: DataFrame
baseline_survival_: DataFrame
"""
_KNOWN_MODEL = True
def __init__(self, alpha=0.05, tie_method="Efron", penalizer=0.0, strata=None):
super(CoxPHFitter, self).__init__(alpha=alpha)
if penalizer < 0:
raise ValueError("penalizer parameter must be >= 0.")
if tie_method != "Efron":
raise NotImplementedError("Only Efron is available at the moment.")
self.alpha = alpha
self.tie_method = tie_method
self.penalizer = penalizer
self.strata = strata
@CensoringType.right_censoring
def fit(
self,
df,
duration_col=None,
event_col=None,
show_progress=False,
initial_point=None,
strata=None,
step_size=None,
weights_col=None,
cluster_col=None,
robust=False,
batch_mode=None,
):
"""
Fit the Cox proportional hazard model to a dataset.
Parameters
----------
df: DataFrame
a Pandas DataFrame with necessary columns `duration_col` and
`event_col` (see below), covariates columns, and special columns (weights, strata).
`duration_col` refers to
the lifetimes of the subjects. `event_col` refers to whether
the 'death' events was observed: 1 if observed, 0 else (censored).
duration_col: string
the name of the column in DataFrame that contains the subjects'
lifetimes.
event_col: string, optional
the name of thecolumn in DataFrame that contains the subjects' death
observation. If left as None, assume all individuals are uncensored.
weights_col: string, optional
an optional column in the DataFrame, df, that denotes the weight per subject.
This column is expelled and not used as a covariate, but as a weight in the
final regression. Default weight is 1.
This can be used for case-weights. For example, a weight of 2 means there were two subjects with
identical observations.
This can be used for sampling weights. In that case, use `robust=True` to get more accurate standard errors.
show_progress: boolean, optional (default=False)
since the fitter is iterative, show convergence
diagnostics. Useful if convergence is failing.
initial_point: (d,) numpy array, optional
initialize the starting point of the iterative
algorithm. Default is the zero vector.
strata: list or string, optional
specify a column or list of columns n to use in stratification. This is useful if a
categorical covariate does not obey the proportional hazard assumption. This
is used similar to the `strata` expression in R.
See http://courses.washington.edu/b515/l17.pdf.
step_size: float, optional
set an initial step size for the fitting algorithm. Setting to 1.0 may improve performance, but could also hurt convergence.
robust: boolean, optional (default=False)
Compute the robust errors using the Huber sandwich estimator, aka Wei-Lin estimate. This does not handle
ties, so if there are high number of ties, results may significantly differ. See
"The Robust Inference for the Cox Proportional Hazards Model", Journal of the American Statistical Association, Vol. 84, No. 408 (Dec., 1989), pp. 1074- 1078
cluster_col: string, optional
specifies what column has unique identifiers for clustering covariances. Using this forces the sandwich estimator (robust variance estimator) to
be used.
batch_mode: bool, optional
enabling batch_mode can be faster for datasets with a large number of ties. If left as None, lifelines will choose the best option.
Returns
-------
self: CoxPHFitter
self with additional new properties: ``print_summary``, ``hazards_``, ``confidence_intervals_``, ``baseline_survival_``, etc.
Note
----
Tied survival times are handled using Efron's tie-method.
Examples
--------
>>> from lifelines import CoxPHFitter
>>>
>>> df = pd.DataFrame({
>>> 'T': [5, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
>>> 'E': [1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0],
>>> 'var': [0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2],
>>> 'age': [4, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
>>> })
>>>
>>> cph = CoxPHFitter()
>>> cph.fit(df, 'T', 'E')
>>> cph.print_summary()
>>> cph.predict_median(df)
>>> from lifelines import CoxPHFitter
>>>
>>> df = pd.DataFrame({
>>> 'T': [5, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
>>> 'E': [1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0],
>>> 'var': [0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2],
>>> 'weights': [1.1, 0.5, 2.0, 1.6, 1.2, 4.3, 1.4, 4.5, 3.0, 3.2, 0.4, 6.2],
>>> 'month': [10, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
>>> 'age': [4, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
>>> })
>>>
>>> cph = CoxPHFitter()
>>> cph.fit(df, 'T', 'E', strata=['month', 'age'], robust=True, weights_col='weights')
>>> cph.print_summary()
>>> cph.predict_median(df)
"""
if duration_col is None:
raise TypeError("duration_col cannot be None.")
self._time_fit_was_called = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S") + " UTC"
self.duration_col = duration_col
self.event_col = event_col
self.robust = robust
self.cluster_col = cluster_col
self.weights_col = weights_col
self._n_examples = df.shape[0]
self._batch_mode = batch_mode
self.strata = coalesce(strata, self.strata)
X, T, E, weights, original_index, self._clusters = self._preprocess_dataframe(df)
self.durations = T.copy()
self.event_observed = E.copy()
self.weights = weights.copy()
if self.strata is not None:
self.durations.index = original_index
self.event_observed.index = original_index
self.weights.index = original_index
self._norm_mean = X.mean(0)
self._norm_std = X.std(0)
X_norm = normalize(X, self._norm_mean, self._norm_std)
params_ = self._fit_model(
X_norm, T, E, weights=weights, initial_point=initial_point, show_progress=show_progress, step_size=step_size
)
self.params_ = pd.Series(params_, index=X.columns, name="coef") / self._norm_std
self.hazard_ratios_ = pd.Series(np.exp(self.params_), index=X.columns, name="exp(coef)")
self.variance_matrix_ = -inv(self._hessian_) / np.outer(self._norm_std, self._norm_std)
self.standard_errors_ = self._compute_standard_errors(X_norm, T, E, weights)
self.confidence_intervals_ = self._compute_confidence_intervals()
self._predicted_partial_hazards_ = (
self.predict_partial_hazard(X)
.rename(columns={0: "P"})
.assign(T=self.durations.values, E=self.event_observed.values, W=self.weights.values)
.set_index(X.index)
)
self.baseline_hazard_ = self._compute_baseline_hazards()
self.baseline_cumulative_hazard_ = self._compute_baseline_cumulative_hazard()
self.baseline_survival_ = self._compute_baseline_survival()
if hasattr(self, "_concordance_score_"):
# we have already fit the model.
del self._concordance_score_
return self
def _preprocess_dataframe(self, df):
# this should be a pure function
df = df.copy()
if self.strata is not None:
df = df.sort_values(by=_to_list(self.strata) + [self.duration_col])
original_index = df.index.copy()
df = df.set_index(self.strata)
else:
df = df.sort_values(by=self.duration_col)
original_index = df.index.copy()
# Extract time and event
T = df.pop(self.duration_col)
E = (
df.pop(self.event_col)
if (self.event_col is not None)
else pd.Series(np.ones(self._n_examples), index=df.index, name="E")
)
W = (
df.pop(self.weights_col)
if (self.weights_col is not None)
else pd.Series(np.ones((self._n_examples,)), index=df.index, name="weights")
)
_clusters = df.pop(self.cluster_col).values if self.cluster_col else None
X = df.astype(float)
T = T.astype(float)
# we check nans here because converting to bools maps NaNs to True..
check_nans_or_infs(E)
E = E.astype(bool)
self._check_values(X, T, E, W)
return X, T, E, W, original_index, _clusters
def _check_values(self, X, T, E, W):
check_for_numeric_dtypes_or_raise(X)
check_nans_or_infs(T)
check_nans_or_infs(X)
check_low_var(X)
check_complete_separation(X, E, T, self.event_col)
# check to make sure their weights are okay
if self.weights_col:
if (W.astype(int) != W).any() and not self.robust:
warnings.warn(
"""It appears your weights are not integers, possibly propensity or sampling scores then?
It's important to know that the naive variance estimates of the coefficients are biased. Instead a) set `robust=True` in the call to `fit`, or b) use Monte Carlo to
estimate the variances. See paper "Variance estimation when using inverse probability of treatment weighting (IPTW) with survival analysis"
""",
StatisticalWarning,
)
if (W <= 0).any():
raise ValueError("values in weight column %s must be positive." % self.weights_col)
def _fit_model(
self,
X,
T,
E,
weights=None,
initial_point=None,
step_size=None,
precision=1e-07,
show_progress=True,
max_steps=50,
): # pylint: disable=too-many-statements,too-many-branches
"""
Newton Rhaphson algorithm for fitting CPH model.
Note
----
The data is assumed to be sorted on T!
Parameters
----------
X: (n,d) Pandas DataFrame of observations.
T: (n) Pandas Series representing observed durations.
E: (n) Pandas Series representing death events.
weights: (n) an iterable representing weights per observation.
initial_point: (d,) numpy array of initial starting point for
NR algorithm. Default 0.
step_size: float, optional
> 0.001 to determine a starting step size in NR algorithm.
precision: float, optional
the convergence halts if the norm of delta between
successive positions is less than epsilon.
show_progress: boolean, optional
since the fitter is iterative, show convergence
diagnostics.
max_steps: int, optional
the maximum number of iterations of the Newton-Rhaphson algorithm.
Returns
-------
beta: (1,d) numpy array.
"""
self.path = []
assert precision <= 1.0, "precision must be less than or equal to 1."
_, d = X.shape
# make sure betas are correct size.
if initial_point is not None:
assert initial_point.shape == (d,)
beta = initial_point
else:
beta = np.zeros((d,))
step_sizer = StepSizer(step_size)
step_size = step_sizer.next()
# Method of choice is just efron right now
if self.tie_method == "Efron":
decision = BatchVsSingle.decide(self._batch_mode, T.nunique(), X.shape[0], X.shape[1])
get_gradients = getattr(self, "_get_efron_values_%s" % decision)
self._batch_mode = decision == "batch"
else:
raise NotImplementedError("Only Efron is available.")
i = 0
converging = True
ll, previous_ll = 0, 0
start = time.time()
while converging:
self.path.append(beta.copy())
i += 1
if self.strata is None:
h, g, ll = get_gradients(X.values, T.values, E.values, weights.values, beta)
else:
g = np.zeros_like(beta)
h = np.zeros((beta.shape[0], beta.shape[0]))
ll = 0
for _h, _g, _ll in self._partition_by_strata_and_apply(X, T, E, weights, get_gradients, beta):
g += _g
h += _h
ll += _ll
if i == 1 and np.all(beta == 0):
# this is a neat optimization, the null partial likelihood
# is the same as the full partial but evaluated at zero.
# if the user supplied a non-trivial initial point, we need to delay this.
self._ll_null_ = ll
if self.penalizer > 0:
# add the gradient and hessian of the l2 term
g -= self.penalizer * beta
h.flat[:: d + 1] -= self.penalizer
# reusing a piece to make g * inv(h) * g.T faster later
try:
inv_h_dot_g_T = spsolve(-h, g, assume_a="pos", check_finite=False)
except ValueError as e:
if "infs or NaNs" in str(e):
raise ConvergenceError(
"""Hessian or gradient contains nan or inf value(s). Convergence halted. Please see the following tips in the lifelines documentation:
https://lifelines.readthedocs.io/en/latest/Examples.html#problems-with-convergence-in-the-cox-proportional-hazard-model
""",
e,
)
else:
# something else?
raise e
except LinAlgError as e:
raise ConvergenceError(
"""Convergence halted due to matrix inversion problems. Suspicion is high collinearity. Please see the following tips in the lifelines documentation:
https://lifelines.readthedocs.io/en/latest/Examples.html#problems-with-convergence-in-the-cox-proportional-hazard-model
""",
e,
)
delta = inv_h_dot_g_T
if np.any(np.isnan(delta)):
raise ConvergenceError(
"""delta contains nan value(s). Convergence halted. Please see the following tips in the lifelines documentation:
https://lifelines.readthedocs.io/en/latest/Examples.html#problems-with-convergence-in-the-cox-proportional-hazard-model
"""
)
# Save these as pending result
hessian, gradient = h, g
norm_delta = norm(delta)
# reusing an above piece to make g * inv(h) * g.T faster.
newton_decrement = g.dot(inv_h_dot_g_T) / 2
if show_progress:
print(
"\rIteration %d: norm_delta = %.5f, step_size = %.4f, ll = %.5f, newton_decrement = %.5f, seconds_since_start = %.1f"
% (i, norm_delta, step_size, ll, newton_decrement, time.time() - start),
end="",
)
# convergence criteria
if norm_delta < precision:
converging, completed = False, True
elif previous_ll != 0 and abs(ll - previous_ll) / (-previous_ll) < 1e-09:
# this is what R uses by default
converging, completed = False, True
elif newton_decrement < precision:
converging, completed = False, True
elif i >= max_steps:
# 50 iterations steps with N-R is a lot.
# Expected convergence is ~10 steps
converging, completed = False, False
elif step_size <= 0.00001:
converging, completed = False, False
elif abs(ll) < 0.0001 and norm_delta > 1.0:
warnings.warn(
"The log-likelihood is getting suspiciously close to 0 and the delta is still large. There may be complete separation in the dataset. This may result in incorrect inference of coefficients. \
See https://stats.stackexchange.com/q/11109/11867 for more.\n",
ConvergenceWarning,
)
converging, completed = False, False
beta += step_size * delta
previous_ll = ll
step_size = step_sizer.update(norm_delta).next()
self._hessian_ = hessian
self._score_ = gradient
self.log_likelihood_ = ll
if show_progress and completed:
print("Convergence completed after %d iterations." % (i))
elif show_progress and not completed:
print("Convergence failed. See any warning messages.")
# report to the user problems that we detect.
if completed and norm_delta > 0.1:
warnings.warn(
"Newton-Rhaphson convergence completed but norm(delta) is still high, %.3f. This may imply non-unique solutions to the maximum likelihood. Perhaps there is collinearity or complete separation in the dataset?\n"
% norm_delta,
ConvergenceWarning,
)
elif not completed:
warnings.warn(
"Newton-Rhaphson failed to converge sufficiently in %d steps.\n" % max_steps, ConvergenceWarning
)
return beta
def _get_efron_values_single(self, X, T, E, weights, beta):
"""
Calculates the first and second order vector differentials, with respect to beta.
Note that X, T, E are assumed to be sorted on T!
A good explanation for Efron. Consider three of five subjects who fail at the time.
As it is not known a priori that who is the first to fail, so one-third of
(φ1 + φ2 + φ3) is adjusted from sum_j^{5} φj after one fails. Similarly two-third
of (φ1 + φ2 + φ3) is adjusted after first two individuals fail, etc.
From https://cran.r-project.org/web/packages/survival/survival.pdf:
"Setting all weights to 2 for instance will give the same coefficient estimate but halve the variance. When
the Efron approximation for ties (default) is employed replication of the data will not give exactly the same coefficients as the
weights option, and in this case the weighted fit is arguably the correct one."
Parameters
----------
X: array
(n,d) numpy array of observations.
T: array
(n) numpy array representing observed durations.
E: array
(n) numpy array representing death events.
weights: array
(n) an array representing weights per observation.
beta: array
(1, d) numpy array of coefficients.
Returns
-------
hessian:
(d, d) numpy array,
gradient:
(1, d) numpy array
log_likelihood: float
"""
n, d = X.shape
hessian = np.zeros((d, d))
gradient = np.zeros((d,))
log_lik = 0
# Init risk and tie sums to zero
x_death_sum = np.zeros((d,))
risk_phi, tie_phi = 0, 0
risk_phi_x, tie_phi_x = np.zeros((d,)), np.zeros((d,))
risk_phi_x_x, tie_phi_x_x = np.zeros((d, d)), np.zeros((d, d))
# Init number of ties and weights
weight_count = 0.0
tied_death_counts = 0
scores = weights * np.exp(np.dot(X, beta))
phi_x_is = scores[:, None] * X
phi_x_x_i = np.empty((d, d))
# Iterate backwards to utilize recursive relationship
for i in range(n - 1, -1, -1):
# Doing it like this to preserve shape
ti = T[i]
ei = E[i]
xi = X[i]
w = weights[i]
# Calculate phi values
phi_i = scores[i]
phi_x_i = phi_x_is[i]
# https://stackoverflow.com/a/51481295/1895939
phi_x_x_i = np.multiply.outer(xi, phi_x_i)
# Calculate sums of Risk set
risk_phi = risk_phi + phi_i
risk_phi_x = risk_phi_x + phi_x_i
risk_phi_x_x = risk_phi_x_x + phi_x_x_i
# Calculate sums of Ties, if this is an event
if ei:
x_death_sum = x_death_sum + w * xi
tie_phi = tie_phi + phi_i
tie_phi_x = tie_phi_x + phi_x_i
tie_phi_x_x = tie_phi_x_x + phi_x_x_i
# Keep track of count
tied_death_counts += 1
weight_count += w
if i > 0 and T[i - 1] == ti:
# There are more ties/members of the risk set
continue
elif tied_death_counts == 0:
# Only censored with current time, move on
continue
# There was atleast one event and no more ties remain. Time to sum.
# This code is near identical to the _batch algorithm below. In fact, see _batch for comments.
weighted_average = weight_count / tied_death_counts
if tied_death_counts > 1:
increasing_proportion = np.arange(tied_death_counts) / tied_death_counts
denom = 1.0 / (risk_phi - increasing_proportion * tie_phi)
numer = risk_phi_x - np.outer(increasing_proportion, tie_phi_x)
a1 = np.einsum("ab,i->ab", risk_phi_x_x, denom) - np.einsum(
"ab,i->ab", tie_phi_x_x, increasing_proportion * denom
)
else:
denom = 1.0 / np.array([risk_phi])
numer = risk_phi_x
a1 = risk_phi_x_x * denom
summand = numer * denom[:, None]
a2 = summand.T.dot(summand)
gradient = gradient + x_death_sum - weighted_average * summand.sum(0)
log_lik = log_lik + np.dot(x_death_sum, beta) + weighted_average * np.log(denom).sum()
hessian = hessian + weighted_average * (a2 - a1)
# reset tie values
tied_death_counts = 0
weight_count = 0.0
x_death_sum = np.zeros((d,))
tie_phi = 0
tie_phi_x = np.zeros((d,))
tie_phi_x_x = np.zeros((d, d))
return hessian, gradient, log_lik
@staticmethod
def _trivial_log_likelihood_batch(T, E, weights):
# used for log-likelihood test
n = T.shape[0]
log_lik = 0
_, counts = np.unique(-T, return_counts=True)
risk_phi = 0
pos = n
for count_of_removals in counts:
slice_ = slice(pos - count_of_removals, pos)
weights_at_t = weights[slice_]
phi_i = weights_at_t
# Calculate sums of Risk set
risk_phi = risk_phi + phi_i.sum()
# Calculate the sums of Tie set
deaths = E[slice_]
tied_death_counts = deaths.astype(int).sum()
if tied_death_counts == 0:
# no deaths, can continue
pos -= count_of_removals
continue
weights_deaths = weights_at_t[deaths]
weight_count = weights_deaths.sum()
if tied_death_counts > 1:
tie_phi = phi_i[deaths].sum()
factor = np.log(risk_phi - np.arange(tied_death_counts) * tie_phi / tied_death_counts).sum()
else:
factor = np.log(risk_phi)
log_lik = log_lik - weight_count / tied_death_counts * factor
pos -= count_of_removals
return log_lik
@staticmethod
def _trivial_log_likelihood_single(T, E, weights):
# assumes sorted on T!
log_lik = 0
n = T.shape[0]
# Init risk and tie sums to zero
risk_phi, tie_phi = 0, 0
# Init number of ties and weights
weight_count = 0.0
tied_death_counts = 0
# Iterate backwards to utilize recursive relationship
for i in range(n - 1, -1, -1):
# Doing it like this to preserve shape
ti = T[i]
ei = E[i]
# Calculate phi values
phi_i = weights[i]
w = weights[i]
# Calculate sums of Risk set
risk_phi = risk_phi + phi_i
# Calculate sums of Ties, if this is an event
if ei:
tie_phi = tie_phi + phi_i
# Keep track of count
tied_death_counts += 1
weight_count += w
if i > 0 and T[i - 1] == ti:
# There are more ties/members of the risk set
continue
elif tied_death_counts == 0:
# Only censored with current time, move on
continue
if tied_death_counts > 1:
factor = np.log(risk_phi - np.arange(tied_death_counts) * tie_phi / tied_death_counts).sum()
else:
factor = np.log(risk_phi)
log_lik = log_lik - weight_count / tied_death_counts * factor
# reset tie values
tied_death_counts = 0
weight_count = 0.0
tie_phi = 0
return log_lik
def _get_efron_values_batch(self, X, T, E, weights, beta): # pylint: disable=too-many-locals
"""
Assumes sorted on ascending on T
Calculates the first and second order vector differentials, with respect to beta.
A good explanation for how Efron handles ties. Consider three of five subjects who fail at the time.
As it is not known a priori that who is the first to fail, so one-third of
(φ1 + φ2 + φ3) is adjusted from sum_j^{5} φj after one fails. Similarly two-third
of (φ1 + φ2 + φ3) is adjusted after first two individuals fail, etc.
Returns
-------
hessian: (d, d) numpy array,
gradient: (1, d) numpy array
log_likelihood: float
"""
n, d = X.shape
hessian = np.zeros((d, d))
gradient = np.zeros((d,))
log_lik = 0
# weights = weights[:, None]
# Init risk and tie sums to zero
risk_phi, tie_phi = 0, 0
risk_phi_x, tie_phi_x = np.zeros((d,)), np.zeros((d,))
risk_phi_x_x, tie_phi_x_x = np.zeros((d, d)), np.zeros((d, d))
# counts are sorted by -T
_, counts = np.unique(-T, return_counts=True)
scores = weights * np.exp(np.dot(X, beta))
pos = n
ZERO_TO_N = np.arange(counts.max())
for count_of_removals in counts:
slice_ = slice(pos - count_of_removals, pos)
X_at_t = X[slice_]
weights_at_t = weights[slice_]
deaths = E[slice_]
phi_i = scores[slice_, None]
phi_x_i = phi_i * X_at_t
phi_x_x_i = np.dot(X_at_t.T, phi_x_i)
# Calculate sums of Risk set
risk_phi = risk_phi + phi_i.sum()
risk_phi_x = risk_phi_x + (phi_x_i).sum(0)
risk_phi_x_x = risk_phi_x_x + phi_x_x_i
# Calculate the sums of Tie set
tied_death_counts = deaths.sum()
if tied_death_counts == 0:
# no deaths, can continue
pos -= count_of_removals
continue
"""
I think there is another optimization that can be made if we sort on
T and E. Using some accounting, we can skip all the [death] indexing below.
"""
xi_deaths = X_at_t[deaths]
weights_deaths = weights_at_t[deaths]
x_death_sum = np.einsum("a,ab->b", weights_deaths, xi_deaths)
weight_count = weights_deaths.sum()
weighted_average = weight_count / tied_death_counts
if tied_death_counts > 1:
# a lot of this is now in Einstein notation for performance, but see original "expanded" code here
# https://github.com/CamDavidsonPilon/lifelines/blob/e7056e7817272eb5dff5983556954f56c33301b1/lifelines/fitters/coxph_fitter.py#L755-L789
# it's faster if we can skip computing these when we don't need to.
phi_x_i_deaths = phi_x_i[deaths]
tie_phi = phi_i[deaths].sum()
tie_phi_x = (phi_x_i_deaths).sum(0)
tie_phi_x_x = np.dot(xi_deaths.T, phi_x_i_deaths)
increasing_proportion = ZERO_TO_N[:tied_death_counts] / tied_death_counts
denom = 1.0 / (risk_phi - increasing_proportion * tie_phi)
numer = risk_phi_x - np.outer(increasing_proportion, tie_phi_x)
# computes outer products and sums them together.
# Naive approach is to
# 1) broadcast tie_phi_x_x and increasing_proportion into a (tied_death_counts, d, d) matrix
# 2) broadcast risk_phi_x_x and denom into a (tied_death_counts, d, d) matrix
# 3) subtract them, and then sum to (d, d)
# Alternatively, we can sum earlier without having to explicitly create (_, d, d) matrices. This is used here.
#
a1 = | np.einsum("ab,i->ab", risk_phi_x_x, denom) | numpy.einsum |
"""
Test DOE Driver and Generators.
"""
import unittest
import os
import os.path
import glob
import csv
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.paraboloid import Paraboloid
from openmdao.test_suite.components.paraboloid_distributed import DistParab
from openmdao.test_suite.groups.parallel_groups import FanInGrouped
from openmdao.utils.assert_utils import assert_near_equal
from openmdao.utils.general_utils import run_driver, printoptions
from openmdao.utils.testing_utils import use_tempdirs
from openmdao.utils.mpi import MPI
try:
from openmdao.vectors.petsc_vector import PETScVector
except ImportError:
PETScVector = None
class ParaboloidArray(om.ExplicitComponent):
"""
Evaluates the equation f(x,y) = (x-3)^2 + x*y + (y+4)^2 - 3.
Where x and y are xy[0] and xy[1] respectively.
"""
def setup(self):
self.add_input('xy', val=np.array([0., 0.]))
self.add_output('f_xy', val=0.0)
def compute(self, inputs, outputs):
"""
f(x,y) = (x-3)^2 + xy + (y+4)^2 - 3
"""
x = inputs['xy'][0]
y = inputs['xy'][1]
outputs['f_xy'] = (x - 3.0)**2 + x * y + (y + 4.0)**2 - 3.0
class ParaboloidDiscrete(om.ExplicitComponent):
def setup(self):
self.add_discrete_input('x', val=10, tags='xx')
self.add_discrete_input('y', val=0, tags='yy')
self.add_discrete_output('f_xy', val=0, tags='ff')
def compute(self, inputs, outputs, discrete_inputs, discrete_outputs):
x = discrete_inputs['x']
y = discrete_inputs['y']
f_xy = (x - 3.0)**2 + x * y + (y + 4.0)**2 - 3.0
discrete_outputs['f_xy'] = int(f_xy)
class ParaboloidDiscreteArray(om.ExplicitComponent):
def setup(self):
self.add_discrete_input('x', val=np.ones((2, )), tags='xx')
self.add_discrete_input('y', val=np.ones((2, )), tags='yy')
self.add_discrete_output('f_xy', val=np.ones((2, )), tags='ff')
def compute(self, inputs, outputs, discrete_inputs, discrete_outputs):
x = discrete_inputs['x']
y = discrete_inputs['y']
f_xy = (x - 3.0)**2 + x * y + (y + 4.0)**2 - 3.0
discrete_outputs['f_xy'] = f_xy.astype(np.int)
class TestErrors(unittest.TestCase):
def test_generator_check(self):
prob = om.Problem()
with self.assertRaises(TypeError) as err:
prob.driver = om.DOEDriver(om.FullFactorialGenerator)
self.assertEqual(str(err.exception),
"DOEDriver requires an instance of DOEGenerator, "
"but a class object was found: FullFactorialGenerator")
with self.assertRaises(TypeError) as err:
prob.driver = om.DOEDriver(om.Problem())
self.assertEqual(str(err.exception),
"DOEDriver requires an instance of DOEGenerator, "
"but an instance of Problem was found.")
def test_lhc_criterion(self):
with self.assertRaises(ValueError) as err:
om.LatinHypercubeGenerator(criterion='foo')
self.assertEqual(str(err.exception),
"Invalid criterion 'foo' specified for LatinHypercubeGenerator. "
"Must be one of ['center', 'c', 'maximin', 'm', 'centermaximin', "
"'cm', 'correlation', 'corr', None].")
@use_tempdirs
class TestDOEDriver(unittest.TestCase):
def setUp(self):
self.expected_fullfact3 = [
{'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])},
{'x': np.array([.5]), 'y': np.array([0.]), 'f_xy': np.array([19.25])},
{'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])},
{'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])},
{'x': np.array([.5]), 'y': np.array([.5]), 'f_xy': np.array([23.75])},
{'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])},
{'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])},
{'x': np.array([.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])},
{'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])},
]
def test_no_generator(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 0.), promotes=['*'])
model.add_subsystem('p2', om.IndepVarComp('y', 0.), promotes=['*'])
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.add_design_var('x', lower=-10, upper=10)
model.add_design_var('y', lower=-10, upper=10)
model.add_objective('f_xy')
prob.driver = om.DOEDriver()
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 0)
def test_list(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', om.IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.setup()
# create a list of DOE cases
case_gen = om.FullFactorialGenerator(levels=3)
cases = list(case_gen(model.get_design_vars(recurse=True)))
# create DOEDriver using provided list of cases
prob.driver = om.DOEDriver(cases)
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.run_driver()
prob.cleanup()
expected = self.expected_fullfact3
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 9)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name], expected_case[name])
def test_list_errors(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', om.IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.setup()
# data does not contain a list
cases = {'desvar': 1.0}
with self.assertRaises(RuntimeError) as err:
prob.driver = om.DOEDriver(generator=om.ListGenerator(cases))
self.assertEqual(str(err.exception), "Invalid DOE case data, "
"expected a list but got a dict.")
# data contains a list of non-list
cases = [{'desvar': 1.0}]
prob.driver = om.DOEDriver(generator=om.ListGenerator(cases))
with self.assertRaises(RuntimeError) as err:
prob.run_driver()
self.assertEqual(str(err.exception), "Invalid DOE case found, "
"expecting a list of name/value pairs:\n{'desvar': 1.0}")
# data contains a list of list, but one has the wrong length
cases = [
[['p1.x', 0.], ['p2.y', 0.]],
[['p1.x', 1.], ['p2.y', 1., 'foo']]
]
prob.driver = om.DOEDriver(generator=om.ListGenerator(cases))
with self.assertRaises(RuntimeError) as err:
prob.run_driver()
self.assertEqual(str(err.exception), "Invalid DOE case found, "
"expecting a list of name/value pairs:\n"
"[['p1.x', 1.0], ['p2.y', 1.0, 'foo']]")
# data contains a list of list, but one case has an invalid design var
cases = [
[['p1.x', 0.], ['p2.y', 0.]],
[['p1.x', 1.], ['p2.z', 1.]]
]
prob.driver = om.DOEDriver(generator=om.ListGenerator(cases))
with self.assertRaises(RuntimeError) as err:
prob.run_driver()
self.assertEqual(str(err.exception), "Invalid DOE case found, "
"'p2.z' is not a valid design variable:\n"
"[['p1.x', 1.0], ['p2.z', 1.0]]")
# data contains a list of list, but one case has multiple invalid design vars
cases = [
[['p1.x', 0.], ['p2.y', 0.]],
[['p1.y', 1.], ['p2.z', 1.]]
]
prob.driver = om.DOEDriver(generator=om.ListGenerator(cases))
with self.assertRaises(RuntimeError) as err:
prob.run_driver()
self.assertEqual(str(err.exception), "Invalid DOE case found, "
"['p1.y', 'p2.z'] are not valid design variables:\n"
"[['p1.y', 1.0], ['p2.z', 1.0]]")
def test_csv(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.set_input_defaults('x', 0.0)
model.set_input_defaults('y', 0.0)
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.setup()
# create a list of DOE cases
case_gen = om.FullFactorialGenerator(levels=3)
cases = list(case_gen(model.get_design_vars(recurse=True)))
# generate CSV file with cases
header = [var for (var, val) in cases[0]]
with open('cases.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(header)
for case in cases:
writer.writerow([val for _, val in case])
# create DOEDriver using generated CSV file
prob.driver = om.DOEDriver(om.CSVGenerator('cases.csv'))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.run_driver()
prob.cleanup()
expected = self.expected_fullfact3
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 9)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name], expected_case[name])
def test_csv_array(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', [0., 1.]))
model.add_subsystem('p2', om.IndepVarComp('y', [0., 1.]))
model.add_subsystem('comp1', Paraboloid())
model.add_subsystem('comp2', Paraboloid())
model.connect('p1.x', 'comp1.x', src_indices=[0])
model.connect('p2.y', 'comp1.y', src_indices=[0])
model.connect('p1.x', 'comp2.x', src_indices=[1])
model.connect('p2.y', 'comp2.y', src_indices=[1])
model.add_design_var('p1.x', lower=0.0, upper=1.0)
model.add_design_var('p2.y', lower=0.0, upper=1.0)
prob.setup()
# create a list of DOE cases
case_gen = om.FullFactorialGenerator(levels=2)
cases = list(case_gen(model.get_design_vars(recurse=True)))
# generate CSV file with cases
header = [var for var, _ in cases[0]]
with open('cases.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(header)
for case in cases:
writer.writerow([val for _, val in case])
# create DOEDriver using generated CSV file
prob.driver = om.DOEDriver(om.CSVGenerator('cases.csv'))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.run_driver()
prob.cleanup()
expected = [
{'p1.x': np.array([0., 0.]), 'p2.y': np.array([0., 0.])},
{'p1.x': np.array([1., 0.]), 'p2.y': np.array([0., 0.])},
{'p1.x': np.array([0., 1.]), 'p2.y': np.array([0., 0.])},
{'p1.x': np.array([1., 1.]), 'p2.y': np.array([0., 0.])},
{'p1.x': np.array([0., 0.]), 'p2.y': np.array([1., 0.])},
{'p1.x': np.array([1., 0.]), 'p2.y': np.array([1., 0.])},
{'p1.x': np.array([0., 1.]), 'p2.y': np.array([1., 0.])},
{'p1.x': np.array([1., 1.]), 'p2.y': np.array([1., 0.])},
{'p1.x': np.array([0., 0.]), 'p2.y': np.array([0., 1.])},
{'p1.x': np.array([1., 0.]), 'p2.y': np.array([0., 1.])},
{'p1.x': np.array([0., 1.]), 'p2.y': np.array([0., 1.])},
{'p1.x': np.array([1., 1.]), 'p2.y': np.array([0., 1.])},
{'p1.x': np.array([0., 0.]), 'p2.y': np.array([1., 1.])},
{'p1.x': np.array([1., 0.]), 'p2.y': np.array([1., 1.])},
{'p1.x': np.array([0., 1.]), 'p2.y': np.array([1., 1.])},
{'p1.x': np.array([1., 1.]), 'p2.y': np.array([1., 1.])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 16)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
self.assertEqual(outputs['p1.x'][0], expected_case['p1.x'][0])
self.assertEqual(outputs['p2.y'][0], expected_case['p2.y'][0])
self.assertEqual(outputs['p1.x'][1], expected_case['p1.x'][1])
self.assertEqual(outputs['p2.y'][1], expected_case['p2.y'][1])
def test_csv_errors(self):
# test invalid file name
with self.assertRaises(RuntimeError) as err:
om.CSVGenerator(1.23)
self.assertEqual(str(err.exception),
"'1.23' is not a valid file name.")
# test file not found
with self.assertRaises(RuntimeError) as err:
om.CSVGenerator('nocases.csv')
self.assertEqual(str(err.exception),
"File not found: nocases.csv")
# create problem and a list of DOE cases
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', om.IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.setup()
case_gen = om.FullFactorialGenerator(levels=2)
cases = list(case_gen(model.get_design_vars(recurse=True)))
# test CSV file with an invalid design var
header = [var for var, _ in cases[0]]
header[-1] = 'foobar'
with open('cases.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(header)
for case in cases:
writer.writerow([val for _, val in case])
prob.driver = om.DOEDriver(om.CSVGenerator('cases.csv'))
with self.assertRaises(RuntimeError) as err:
prob.run_driver()
self.assertEqual(str(err.exception), "Invalid DOE case file, "
"'foobar' is not a valid design variable.")
# test CSV file with invalid design vars
header = [var + '_bad' for var, _ in cases[0]]
with open('cases.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(header)
for case in cases:
writer.writerow([val for _, val in case])
with self.assertRaises(RuntimeError) as err:
prob.run_driver()
self.assertEqual(str(err.exception), "Invalid DOE case file, "
"%s are not valid design variables." %
str(header))
# test CSV file with invalid values
header = [var for var, _ in cases[0]]
with open('cases.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(header)
for case in cases:
writer.writerow([np.ones((2, 2)) * val for _, val in case])
from distutils.version import LooseVersion
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts = {'legacy': '1.13'}
else:
opts = {}
with printoptions(**opts):
# have to use regex to handle differences in numpy print formats for shape
msg = f"Error assigning p1.x = \[ 0. 0. 0. 0.\]: could not broadcast " \
f"input array from shape \(4.*\) into shape \(1.*\)"
with self.assertRaisesRegex(ValueError, msg):
prob.run_driver()
def test_uniform(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.set_input_defaults('x', 0.0)
model.set_input_defaults('y', 0.0)
model.add_design_var('x', lower=-10, upper=10)
model.add_design_var('y', lower=-10, upper=10)
model.add_objective('f_xy')
prob.driver = om.DOEDriver(om.UniformGenerator(num_samples=5, seed=0))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
# all values should be between -10 and 10, check expected values for seed = 0
expected = [
{'x': np.array([0.97627008]), 'y': np.array([4.30378733])},
{'x': np.array([2.05526752]), 'y': np.array([0.89766366])},
{'x': np.array([-1.52690401]), 'y': np.array([2.91788226])},
{'x': np.array([-1.24825577]), 'y': np.array([7.83546002])},
{'x': np.array([9.27325521]), 'y': np.array([-2.33116962])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 5)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y'):
assert_near_equal(outputs[name], expected_case[name], 1e-4)
def test_full_factorial(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.set_input_defaults('x', 0.0)
model.set_input_defaults('y', 0.0)
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = om.DOEDriver(generator=om.FullFactorialGenerator(levels=3))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
expected = self.expected_fullfact3
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 9)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name], expected_case[name])
def test_full_factorial_factoring(self):
class Digits2Num(om.ExplicitComponent):
"""
Makes from two vectors with 2 elements a 4 digit number.
For singe digit integers always gives a unique output number.
"""
def setup(self):
self.add_input('x', val=np.array([0., 0.]))
self.add_input('y', val=np.array([0., 0.]))
self.add_output('f', val=0.0)
def compute(self, inputs, outputs):
x = inputs['x']
y = inputs['y']
outputs['f'] = x[0] * 1000 + x[1] * 100 + y[0] * 10 + y[1]
prob = om.Problem()
model = prob.model
model.set_input_defaults('x', np.array([0.0, 0.0]))
model.set_input_defaults('y', np.array([0.0, 0.0]))
model.add_subsystem('comp', Digits2Num(), promotes=['*'])
model.add_design_var('x', lower=0.0, upper=np.array([1.0, 2.0]))
model.add_design_var('y', lower=0.0, upper=np.array([3.0, 4.0]))
model.add_objective('f')
prob.driver = om.DOEDriver(generator=om.FullFactorialGenerator(levels=2))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
objs = [int(cr.get_case(case).outputs['f']) for case in cases]
self.assertEqual(len(objs), 16)
# Testing uniqueness. If all elements are unique, it should be the same length as the
# number of cases
self.assertEqual(len(set(objs)), 16)
def test_full_factorial_array(self):
prob = om.Problem()
model = prob.model
model.set_input_defaults('xy', np.array([0., 0.]))
model.add_subsystem('comp', ParaboloidArray(), promotes=['*'])
model.add_design_var('xy', lower=np.array([-10., -50.]), upper=np.array([10., 50.]))
model.add_objective('f_xy')
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
expected = [
{'xy': np.array([-10., -50.])},
{'xy': np.array([0., -50.])},
{'xy': np.array([10., -50.])},
{'xy': np.array([-10., 0.])},
{'xy': np.array([0., 0.])},
{'xy': np.array([10., 0.])},
{'xy': np.array([-10., 50.])},
{'xy': np.array([0., 50.])},
{'xy': np.array([10., 50.])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 9)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
self.assertEqual(outputs['xy'][0], expected_case['xy'][0])
self.assertEqual(outputs['xy'][1], expected_case['xy'][1])
def test_full_fact_dict_levels(self):
# Specifying levels only for one DV, the other is defaulted
prob = om.Problem()
model = prob.model
expected = [
{'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])},
{'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])},
{'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])},
{'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])},
{'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])},
{'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])},
]
# size = prob.comm.size
# rank = prob.comm.rank
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.set_input_defaults('x', 0.0)
model.set_input_defaults('y', 0.0)
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = om.DOEDriver(generator=om.FullFactorialGenerator(levels={"y": 3}))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 6)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
self.assertEqual(outputs['x'], expected_case['x'])
self.assertEqual(outputs['y'], expected_case['y'])
self.assertEqual(outputs['f_xy'], expected_case['f_xy'])
def test_generalized_subset(self):
# All DVs have the same number of levels
prob = om.Problem()
model = prob.model
model.set_input_defaults('x', 0.0)
model.set_input_defaults('y', 0.0)
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = om.DOEDriver(generator=om.GeneralizedSubsetGenerator(levels=2, reduction=2))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
expected = [
{'x': np.array([0.0]), 'y': np.array([0.0]), 'f_xy': np.array([22.0])},
{'x': np.array([1.0]), 'y': np.array([1.0]), 'f_xy': np.array([27.0])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver')
self.assertEqual(len(cases), 2)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name], expected_case[name])
def test_generalized_subset_dict_levels(self):
# Number of variables specified individually for all DVs (scalars).
prob = om.Problem()
model = prob.model
model.set_input_defaults('x', 0.0)
model.set_input_defaults('y', 0.0)
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = om.DOEDriver(generator=om.GeneralizedSubsetGenerator(levels={'x': 3, 'y': 6}, reduction=2))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
expected = [
{'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.])},
{'x': np.array([0.]), 'y': np.array([0.4]), 'f_xy': np.array([25.36])},
{'x': np.array([0.]), 'y': np.array([0.8]), 'f_xy': np.array([29.04])},
{'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.])},
{'x': np.array([1.]), 'y': np.array([0.4]), 'f_xy': np.array([20.76])},
{'x': np.array([1.]), 'y': np.array([0.8]), 'f_xy': np.array([24.84])},
{'x': np.array([0.5]), 'y': np.array([0.2]), 'f_xy': np.array([20.99])},
{'x': np.array([0.5]), 'y': np.array([0.6]), 'f_xy': np.array([24.71])},
{'x': np.array([0.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver')
self.assertEqual(len(cases), 9)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertAlmostEqual(outputs[name][0], expected_case[name][0])
def test_generalized_subset_array(self):
# Number of levels specified individually for all DVs (arrays).
class Digits2Num(om.ExplicitComponent):
"""
Makes from two vectors with 2 elements a 4 digit number.
For singe digit integers always gives a unique output number.
"""
def setup(self):
self.add_input('x', val=np.array([0., 0.]))
self.add_input('y', val=np.array([0., 0.]))
self.add_output('f', val=0.0)
def compute(self, inputs, outputs):
x = inputs['x']
y = inputs['y']
outputs['f'] = x[0] * 1000 + x[1] * 100 + y[0] * 10 + y[1]
prob = om.Problem()
model = prob.model
model.set_input_defaults('x', np.array([0.0, 0.0]))
model.set_input_defaults('y', np.array([0.0, 0.0]))
model.add_subsystem('comp', Digits2Num(), promotes=['*'])
model.add_design_var('x', lower=0.0, upper=np.array([1.0, 2.0]))
model.add_design_var('y', lower=0.0, upper=np.array([3.0, 4.0]))
model.add_objective('f')
prob.driver = om.DOEDriver(generator=om.GeneralizedSubsetGenerator(levels={'x': 5, 'y': 8}, reduction=14))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
objs = [int(cr.get_case(case).outputs['f']) for case in cases]
self.assertEqual(len(objs), 104) # The number can be verified with standalone pyDOE2
# Testing uniqueness. If all elements are unique, it should be the same length as the number of cases
self.assertEqual(len(set(objs)), 104)
def test_plackett_burman(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', om.IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = om.DOEDriver(om.PlackettBurmanGenerator())
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
expected = [
{'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])},
{'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])},
{'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])},
{'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 4)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name], expected_case[name])
def test_box_behnken(self):
upper = 10.
center = 1
prob = om.Problem()
model = prob.model
indep = model.add_subsystem('indep', om.IndepVarComp(), promotes=['*'])
indep.add_output('x', 0.0)
indep.add_output('y', 0.0)
indep.add_output('z', 0.0)
model.add_subsystem('comp', om.ExecComp('a = x**2 + y - z'), promotes=['*'])
model.add_design_var('x', lower=0., upper=upper)
model.add_design_var('y', lower=0., upper=upper)
model.add_design_var('z', lower=0., upper=upper)
model.add_objective('a')
prob.driver = om.DOEDriver(om.BoxBehnkenGenerator(center=center))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
# The Box-Behnken design for 3 factors involves three blocks, in each of
# which 2 factors are varied thru the 4 possible combinations of high & low.
# It also includes centre points (all factors at their central values).
# ref: https://en.wikipedia.org/wiki/Box-Behnken_design
self.assertEqual(len(cases), (3*4)+center)
expected = [
{'x': np.array([0.]), 'y': np.array([0.]), 'z': np.array([5.])},
{'x': np.array([10.]), 'y': np.array([0.]), 'z': np.array([5.])},
{'x': np.array([0.]), 'y': np.array([10.]), 'z': np.array([5.])},
{'x': np.array([10.]), 'y': np.array([10.]), 'z': np.array([5.])},
{'x': np.array([0.]), 'y': np.array([5.]), 'z': np.array([0.])},
{'x': np.array([10.]), 'y': np.array([5.]), 'z': np.array([0.])},
{'x': np.array([0.]), 'y': np.array([5.]), 'z': np.array([10.])},
{'x': np.array([10.]), 'y': np.array([5.]), 'z': np.array([10.])},
{'x': np.array([5.]), 'y': np.array([0.]), 'z': np.array([0.])},
{'x': np.array([5.]), 'y': np.array([10.]), 'z': np.array([0.])},
{'x': np.array([5.]), 'y': np.array([0.]), 'z': np.array([10.])},
{'x': np.array([5.]), 'y': np.array([10.]), 'z': np.array([10.])},
{'x': np.array([5.]), 'y': np.array([5.]), 'z': np.array([5.])},
]
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'z'):
self.assertEqual(outputs[name], expected_case[name])
def test_latin_hypercube(self):
samples = 4
bounds = np.array([
[-1, -10], # lower bounds for x and y
[1, 10] # upper bounds for x and y
])
xlb, xub = bounds[0][0], bounds[1][0]
ylb, yub = bounds[0][1], bounds[1][1]
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', om.IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=xlb, upper=xub)
model.add_design_var('y', lower=ylb, upper=yub)
model.add_objective('f_xy')
prob.driver = om.DOEDriver()
prob.driver.options['generator'] = om.LatinHypercubeGenerator(samples=4, seed=0)
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
# the sample space for each variable should be divided into equal
# size buckets and each variable should have a value in each bucket
all_buckets = set(range(samples))
x_offset = - xlb
x_bucket_size = xub - xlb
x_buckets_filled = set()
y_offset = - ylb
y_bucket_size = yub - ylb
y_buckets_filled = set()
# expected values for seed = 0
expected = [
{'x': np.array([-0.19861831]), 'y': np.array([-6.42405317])},
{'x': np.array([0.2118274]), 'y': np.array([9.458865])},
{'x': np.array([0.71879361]), 'y': np.array([3.22947057])},
{'x': np.array([-0.72559325]), 'y': np.array([-2.27558409])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 4)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
x = outputs['x']
y = outputs['y']
bucket = int((x + x_offset) / (x_bucket_size / samples))
x_buckets_filled.add(bucket)
bucket = int((y + y_offset) / (y_bucket_size / samples))
y_buckets_filled.add(bucket)
assert_near_equal(x, expected_case['x'], 1e-4)
assert_near_equal(y, expected_case['y'], 1e-4)
self.assertEqual(x_buckets_filled, all_buckets)
self.assertEqual(y_buckets_filled, all_buckets)
def test_latin_hypercube_array(self):
samples = 4
bounds = np.array([
[-10, -50], # lower bounds for x and y
[10, 50] # upper bounds for x and y
])
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('xy', np.array([50., 50.])), promotes=['*'])
model.add_subsystem('comp', ParaboloidArray(), promotes=['*'])
model.add_design_var('xy', lower=bounds[0], upper=bounds[1])
model.add_objective('f_xy')
prob.driver = om.DOEDriver(om.LatinHypercubeGenerator(samples=4, seed=0))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
# the sample space for each variable should be divided into equal
# size buckets and each variable should have a value in each bucket
all_buckets = set(range(samples))
xlb, xub = bounds[0][0], bounds[1][0]
x_offset = - xlb
x_bucket_size = xub - xlb
x_buckets_filled = set()
ylb, yub = bounds[0][1], bounds[1][1]
y_offset = - ylb
y_bucket_size = yub - ylb
y_buckets_filled = set()
# expected values for seed = 0
expected = [
{'xy': np.array([-1.98618312, -32.12026584])},
{'xy': np.array([2.118274, 47.29432502])},
{'xy': np.array([7.18793606, 16.14735283])},
{'xy': np.array([-7.25593248, -11.37792043])},
]
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), 4)
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
x = outputs['xy'][0]
y = outputs['xy'][1]
bucket = int((x + x_offset) / (x_bucket_size / samples))
x_buckets_filled.add(bucket)
bucket = int((y + y_offset) / (y_bucket_size / samples))
y_buckets_filled.add(bucket)
assert_near_equal(x, expected_case['xy'][0], 1e-4)
assert_near_equal(y, expected_case['xy'][1], 1e-4)
self.assertEqual(x_buckets_filled, all_buckets)
self.assertEqual(y_buckets_filled, all_buckets)
def test_latin_hypercube_center(self):
samples = 4
upper = 10.
prob = om.Problem()
model = prob.model
indep = model.add_subsystem('indep', om.IndepVarComp())
indep.add_output('x', 0.0)
indep.add_output('y', 0.0)
model.add_subsystem('comp', Paraboloid())
model.connect('indep.x', 'comp.x')
model.connect('indep.y', 'comp.y')
model.add_design_var('indep.x', lower=0., upper=upper)
model.add_design_var('indep.y', lower=0., upper=upper)
model.add_objective('comp.f_xy')
prob.driver = om.DOEDriver(om.LatinHypercubeGenerator(samples=samples, criterion='c'))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
self.assertEqual(len(cases), samples)
# the sample space for each variable (0 to upper) should be divided into
# equal size buckets and each variable should have a value in each bucket
bucket_size = upper / samples
all_buckets = set(range(samples))
x_buckets_filled = set()
y_buckets_filled = set()
# with criterion of 'center', each value should be in the center of it's bucket
valid_values = [round(bucket_size * (bucket + 1 / 2), 3) for bucket in all_buckets]
for case in cases:
outputs = cr.get_case(case).outputs
x = float(outputs['indep.x'])
y = float(outputs['indep.y'])
x_buckets_filled.add(int(x/bucket_size))
y_buckets_filled.add(int(y/bucket_size))
self.assertTrue(round(x, 3) in valid_values, '%f not in %s' % (x, valid_values))
self.assertTrue(round(y, 3) in valid_values, '%f not in %s' % (y, valid_values))
self.assertEqual(x_buckets_filled, all_buckets)
self.assertEqual(y_buckets_filled, all_buckets)
def test_record_bug(self):
# There was a bug that caused values to be recorded in driver_scaled form.
prob = om.Problem()
model = prob.model
ivc = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
ivc.add_output('x', val=1.)
model.add_subsystem('obj_comp', om.ExecComp('y=2*x'), promotes=['*'])
model.add_subsystem('con_comp', om.ExecComp('z=3*x'), promotes=['*'])
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.driver.recording_options['includes'] = ['*']
model.add_design_var('x', lower=0., upper=10., ref=3.0)
model.add_constraint('z', lower=2.0, scaler=13.0)
model.add_objective('y', scaler=-1)
prob.setup(check=True)
prob.run_driver()
cr = om.CaseReader("cases.sql")
final_case = cr.list_cases('driver', out_stream=None)[-1]
outputs = cr.get_case(final_case).outputs
assert_near_equal(outputs['x'], 10.0, 1e-7)
assert_near_equal(outputs['y'], 20.0, 1e-7)
assert_near_equal(outputs['z'], 30.0, 1e-7)
def test_discrete_desvar_list(self):
prob = om.Problem()
model = prob.model
# Add independent variables
indeps = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
indeps.add_discrete_output('x', 4)
indeps.add_discrete_output('y', 3)
# Add components
model.add_subsystem('parab', ParaboloidDiscrete(), promotes=['*'])
# Specify design variable range and objective
model.add_design_var('x')
model.add_design_var('y')
model.add_objective('f_xy')
samples = [[('x', 5), ('y', 1)],
[('x', 3), ('y', 6)],
[('x', -1), ('y', 3)],
]
# Setup driver for 3 cases at a time
prob.driver = om.DOEDriver(om.ListGenerator(samples))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
expected = [{'x': 5, 'y': 1, 'f_xy': 31},
{'x': 3, 'y': 6, 'f_xy': 115},
{'x': -1, 'y': 3, 'f_xy': 59},
]
self.assertEqual(len(cases), len(expected))
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name], expected_case[name])
self.assertTrue(isinstance(outputs[name], int))
def test_discrete_desvar_alltypes(self):
# Make sure we can handle any allowed type for discrete variables.
class PassThrough(om.ExplicitComponent):
def setup(self):
self.add_discrete_input('x', val='abc')
self.add_discrete_output('y', val='xyz')
def compute(self, inputs, outputs, discrete_inputs, discrete_outputs):
discrete_outputs['y'] = discrete_inputs['x']
prob = om.Problem()
model = prob.model
indeps = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
indeps.add_discrete_output('x', 'abc')
model.add_subsystem('parab', PassThrough(), promotes=['*'])
model.add_design_var('x')
model.add_constraint('y')
my_obj = Paraboloid()
samples = [[('x', 'abc'), ],
[('x', None), ],
[('x', my_obj, ), ]
]
prob.driver = om.DOEDriver(om.ListGenerator(samples))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
expected = ['abc', None]
for case, expected_value in zip(cases, expected):
outputs = cr.get_case(case).outputs
self.assertEqual(outputs['x'], expected_value)
# Can't read/write objects through SQL case.
self.assertEqual(prob['y'], my_obj)
def test_discrete_array_output(self):
prob = om.Problem()
model = prob.model
# Add independent variables
indeps = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
indeps.add_discrete_output('x', np.ones((2, ), dtype=np.int))
indeps.add_discrete_output('y', np.ones((2, ), dtype=np.int))
# Add components
model.add_subsystem('parab', ParaboloidDiscreteArray(), promotes=['*'])
# Specify design variable range and objective
model.add_design_var('x', np.array([5, 1]))
model.add_design_var('y', np.array([1, 4]))
model.add_objective('f_xy')
recorder = om.SqliteRecorder("cases.sql")
prob.driver.add_recorder(recorder)
prob.add_recorder(recorder)
prob.recording_options['record_inputs'] = True
prob.setup()
prob.run_driver()
prob.record("end")
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('problem', out_stream=None)
case = cr.get_case('end')
inputs = case.inputs
outputs = case.outputs
for name in ('x', 'y'):
self.assertTrue(isinstance(inputs[name], np.ndarray))
self.assertTrue(inputs[name].shape, (2,))
self.assertTrue(isinstance(outputs[name], np.ndarray))
self.assertTrue(outputs[name].shape, (2,))
def test_discrete_arraydesvar_list(self):
prob = om.Problem()
model = prob.model
# Add components
model.add_subsystem('parab', ParaboloidDiscreteArray(), promotes=['*'])
# Specify design variable range and objective
model.add_design_var('x')
model.add_design_var('y')
model.add_objective('f_xy')
samples = [[('x', np.array([5, 1])), ('y', np.array([1, 4]))],
[('x', np.array([3, 2])), ('y', np.array([6, -3]))],
[('x', np.array([-1, 0])), ('y', np.array([3, 5]))],
]
# Setup driver for 3 cases at a time
prob.driver = om.DOEDriver(om.ListGenerator(samples))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.set_val('x', np.ones((2, ), dtype=np.int))
prob.set_val('y', np.ones((2, ), dtype=np.int))
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
expected = [{'x': np.array([5, 1]), 'y': np.array([1, 4]), 'f_xy': np.array([31, 69])},
{'x': np.array([3, 2]), 'y': np.array([6, -3]), 'f_xy': np.array([115, -7])},
{'x': np.array([-1, 0]), 'y': np.array([3, 5]), 'f_xy': np.array([59, 87])},
]
self.assertEqual(len(cases), len(expected))
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name][0], expected_case[name][0])
self.assertEqual(outputs[name][1], expected_case[name][1])
def test_discrete_desvar_csv(self):
prob = om.Problem()
model = prob.model
# Add independent variables
indeps = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
indeps.add_discrete_output('x', 4)
indeps.add_discrete_output('y', 3)
# Add components
model.add_subsystem('parab', ParaboloidDiscrete(), promotes=['*'])
# Specify design variable range and objective
model.add_design_var('x')
model.add_design_var('y')
model.add_objective('f_xy')
samples = '\n'.join([" x , y",
"5, 1",
"3, 6",
"-1, 3",
])
# this file contains design variable inputs in CSV format
with open('cases.csv', 'w') as f:
f.write(samples)
# Setup driver for 3 cases at a time
prob.driver = om.DOEDriver(om.CSVGenerator('cases.csv'))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver', out_stream=None)
expected = [{'x': 5, 'y': 1, 'f_xy': 31},
{'x': 3, 'y': 6, 'f_xy': 115},
{'x': -1, 'y': 3, 'f_xy': 59},
]
self.assertEqual(len(cases), len(expected))
for case, expected_case in zip(cases, expected):
outputs = cr.get_case(case).outputs
for name in ('x', 'y', 'f_xy'):
self.assertEqual(outputs[name], expected_case[name])
self.assertTrue(isinstance(outputs[name], int))
def test_desvar_indices(self):
prob = om.Problem()
prob.model.add_subsystem('comp', om.ExecComp('y=x**2',
x=np.array([1., 2., 3.]),
y=np.zeros(3)), promotes=['*'])
prob.model.add_design_var('x', lower=7.0, upper=11.0, indices=[0])
prob.model.add_objective('y', index=0)
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.setup()
prob.run_driver()
# Last value in fullfactorial DOE is 11, which gives 121.
assert_near_equal(prob.get_val('y'), np.array([121., 4., 9.]))
def test_multidimensional_inputs(self):
# Create a subsystem with multidimensional array inputs
matmul_comp = om.ExecComp('z = matmul(x,y)',
x=np.ones((3, 3)),
y=np.ones((3, 3)),
z=np.ones((3, 3)))
# Single execution test
prob = om.Problem()
prob.model.add_subsystem('matmul', matmul_comp, promotes=['*'])
prob.setup()
prob['x'] = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
prob['y'] = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
prob.run_model()
# DOE test
prob2 = om.Problem()
prob2.model.add_subsystem('matmul', matmul_comp, promotes=['*'])
prob2.model.add_design_var('x')
prob2.model.add_design_var('y')
prob2.model.add_objective('z')
prob2.setup()
case_list = [
[('x', prob['x']), ('y', prob['y'])]
]
prob2.driver = om.DOEDriver(case_list)
prob2.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob2.run_driver()
prob2.cleanup()
cr = om.CaseReader("cases.sql")
outputs = cr.get_case(0).outputs
for name in ('x', 'y', 'z'):
assert_near_equal(outputs[name], prob[name])
def test_multi_constraint_doe(self):
prob = om.Problem()
prob.model.add_subsystem('comp', om.ExecComp('y=x**2 + b',
x=np.array([1., 2., 3.]),
b=np.array([1., 2., 3.]),
y=np.zeros(3)), promotes=['*'])
prob.model.add_design_var('x', lower=7.0, upper=11.0, indices=[0])
prob.model.add_constraint('b', lower=7., indices=[0])
prob.model.add_constraint('b', upper=11., indices=[-1], alias='TEST')
prob.model.add_objective('y', index=0)
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
cr = om.CaseReader("cases.sql")
cases = cr.list_cases('driver')
for case in cases:
outputs = cr.get_case(case).outputs
assert_near_equal(outputs['b'], np.array([1., 2, 3]))
@use_tempdirs
class TestDOEDriverListVars(unittest.TestCase):
def test_list_problem_vars(self):
# this passes if no exception is raised
prob = om.Problem()
model = prob.model
# Add independent variables
indeps = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
indeps.add_discrete_output('x', 4)
indeps.add_discrete_output('y', 3)
# Add components
model.add_subsystem('parab', ParaboloidDiscrete(), promotes=['*'])
# Specify design variable range and objective
model.add_design_var('x')
model.add_design_var('y')
model.add_objective('f_xy')
samples = [[('x', 5), ('y', 1)],
[('x', 3), ('y', 6)],
[('x', -1), ('y', 3)],
]
# Setup driver for 3 cases at a time
prob.driver = om.DOEDriver(om.ListGenerator(samples))
prob.setup(derivatives=False)
prob.run_driver()
prob.cleanup()
prob.list_problem_vars()
@use_tempdirs
class TestDOEDriverListVars(unittest.TestCase):
def test_list_problem_vars(self):
# this passes if no exception is raised
prob = om.Problem()
model = prob.model
# Add independent variables
indeps = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
indeps.add_discrete_output('x', 4)
indeps.add_discrete_output('y', 3)
# Add components
model.add_subsystem('parab', ParaboloidDiscrete(), promotes=['*'])
# Specify design variable range and objective
model.add_design_var('x')
model.add_design_var('y')
model.add_objective('f_xy')
samples = [[('x', 5), ('y', 1)],
[('x', 3), ('y', 6)],
[('x', -1), ('y', 3)],
]
# Setup driver for 3 cases at a time
prob.driver = om.DOEDriver(om.ListGenerator(samples))
prob.setup(derivatives=False)
prob.run_driver()
prob.cleanup()
prob.list_problem_vars()
@unittest.skipUnless(MPI and PETScVector, "MPI and PETSc are required.")
@use_tempdirs
class TestParallelDOE4Proc(unittest.TestCase):
N_PROCS = 4
def setUp(self):
self.expected_fullfact3 = [
{'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])},
{'x': np.array([.5]), 'y': np.array([0.]), 'f_xy': np.array([19.25])},
{'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])},
{'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])},
{'x': np.array([.5]), 'y': np.array([.5]), 'f_xy': np.array([23.75])},
{'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])},
{'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])},
{'x': np.array([.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])},
{'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])},
]
def test_indivisible_error(self):
prob = om.Problem()
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.options['run_parallel'] = True
prob.driver.options['procs_per_model'] = 3
with self.assertRaises(RuntimeError) as context:
prob.setup()
self.assertEqual(str(context.exception),
"The total number of processors is not evenly divisible by the "
"specified number of processors per model.\n Provide a number of "
"processors that is a multiple of 3, or specify a number "
"of processors per model that divides into 4.")
def test_minprocs_error(self):
prob = om.Problem(FanInGrouped())
# require 2 procs for the ParallelGroup
prob.model._proc_info['sub'] = (2, None, 1.0)
# run cases on all procs
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.options['run_parallel'] = True
prob.driver.options['procs_per_model'] = 1
with self.assertRaises(RuntimeError) as context:
prob.setup()
self.assertEqual(str(context.exception),
"<model> <class FanInGrouped>: MPI process allocation failed: can't meet "
"min_procs required for the following subsystems: ['sub']")
def test_full_factorial(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', om.IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3), procs_per_model=1,
run_parallel=True)
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.setup()
failed, output = run_driver(prob)
self.assertFalse(failed)
prob.cleanup()
expected = self.expected_fullfact3
size = prob.comm.size
rank = prob.comm.rank
# cases will be split across files for each proc
filename = "cases.sql_%d" % rank
expect_msg = "Cases from rank %d are being written to %s." % (rank, filename)
self.assertTrue(expect_msg in output)
cr = om.CaseReader(filename)
cases = cr.list_cases('driver', out_stream=None)
# cases recorded on this proc
num_cases = len(cases)
self.assertEqual(num_cases, len(expected) // size + (rank < len(expected) % size))
for n in range(num_cases):
outputs = cr.get_case(cases[n]).outputs
idx = n * size + rank # index of expected case
self.assertEqual(outputs['x'], expected[idx]['x'])
self.assertEqual(outputs['y'], expected[idx]['y'])
self.assertEqual(outputs['f_xy'], expected[idx]['f_xy'])
# total number of cases recorded across all procs
num_cases = prob.comm.allgather(num_cases)
self.assertEqual(sum(num_cases), len(expected))
def test_fan_in_grouped_parallel_2x2(self):
# run cases in parallel with 2 procs per model
# (cases will be split between the 2 parallel model instances)
run_parallel = True
procs_per_model = 2
prob = om.Problem(FanInGrouped())
model = prob.model
model.add_design_var('x1', lower=0.0, upper=1.0)
model.add_design_var('x2', lower=0.0, upper=1.0)
model.add_objective('c3.y')
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.driver.options['run_parallel'] = run_parallel
prob.driver.options['procs_per_model'] = procs_per_model
prob.setup()
failed, output = run_driver(prob)
from openmdao.utils.mpi import multi_proc_exception_check
with multi_proc_exception_check(prob.comm):
self.assertFalse(failed)
prob.cleanup()
expected = [
{'x1': np.array([0.]), 'x2': np.array([0.]), 'c3.y': np.array([0.0])},
{'x1': np.array([.5]), 'x2': np.array([0.]), 'c3.y': np.array([-3.0])},
{'x1': np.array([1.]), 'x2': np.array([0.]), 'c3.y': np.array([-6.0])},
{'x1': np.array([0.]), 'x2': np.array([.5]), 'c3.y': np.array([17.5])},
{'x1': np.array([.5]), 'x2': np.array([.5]), 'c3.y': np.array([14.5])},
{'x1': np.array([1.]), 'x2': np.array([.5]), 'c3.y': np.array([11.5])},
{'x1': np.array([0.]), 'x2': np.array([1.]), 'c3.y': np.array([35.0])},
{'x1': np.array([.5]), 'x2': np.array([1.]), 'c3.y': np.array([32.0])},
{'x1': np.array([1.]), 'x2': np.array([1.]), 'c3.y': np.array([29.0])},
]
num_cases = 0
# we can run two models in parallel on our 4 procs
num_models = prob.comm.size // procs_per_model
# a separate case file will be written by rank 0 of each parallel model
# (the top two global ranks)
rank = prob.comm.rank
filename = "cases.sql_%d" % rank
if rank < num_models:
expect_msg = "Cases from rank %d are being written to %s." % (rank, filename)
self.assertTrue(expect_msg in output)
cr = om.CaseReader(filename)
cases = cr.list_cases('driver')
# cases recorded on this proc
num_cases = len(cases)
self.assertEqual(num_cases, len(expected) // num_models+(rank < len(expected) % num_models))
for n, case in enumerate(cases):
idx = n * num_models + rank # index of expected case
outputs = cr.get_case(case).outputs
for name in ('x1', 'x2', 'c3.y'):
self.assertEqual(outputs[name], expected[idx][name])
else:
self.assertFalse("Cases from rank %d are being written" % rank in output)
self.assertFalse(os.path.exists(filename))
# total number of cases recorded across all requested procs
num_cases = prob.comm.allgather(num_cases)
self.assertEqual(sum(num_cases), len(expected))
def test_fan_in_grouped_parallel_4x1(self):
# run cases in parallel with 1 proc per model
# (cases will be split between the 4 serial model instances)
run_parallel = True
procs_per_model = 1
prob = om.Problem(FanInGrouped())
model = prob.model
model.add_design_var('x1', lower=0.0, upper=1.0)
model.add_design_var('x2', lower=0.0, upper=1.0)
model.add_objective('c3.y')
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.driver.options['run_parallel'] = run_parallel
prob.driver.options['procs_per_model'] = procs_per_model
prob.setup()
failed, output = run_driver(prob)
self.assertFalse(failed)
prob.cleanup()
expected = [
{'x1': np.array([0.]), 'x2': np.array([0.]), 'c3.y': np.array([0.0])},
{'x1': np.array([.5]), 'x2': np.array([0.]), 'c3.y': np.array([-3.0])},
{'x1': np.array([1.]), 'x2': np.array([0.]), 'c3.y': np.array([-6.0])},
{'x1': np.array([0.]), 'x2': np.array([.5]), 'c3.y': np.array([17.5])},
{'x1': np.array([.5]), 'x2': np.array([.5]), 'c3.y': np.array([14.5])},
{'x1': np.array([1.]), 'x2': np.array([.5]), 'c3.y': np.array([11.5])},
{'x1': np.array([0.]), 'x2': np.array([1.]), 'c3.y': np.array([35.0])},
{'x1': np.array([.5]), 'x2': np.array([1.]), 'c3.y': np.array([32.0])},
{'x1': np.array([1.]), 'x2': np.array([1.]), 'c3.y': np.array([29.0])},
]
rank = prob.comm.rank
# there will be a separate case file for each proc, containing the cases
# run by the instance of the model that runs in serial mode on that proc
filename = "cases.sql_%d" % rank
expect_msg = "Cases from rank %d are being written to %s." % (rank, filename)
self.assertTrue(expect_msg in output)
# we are running 4 models in parallel, each using 1 proc
num_models = prob.comm.size // procs_per_model
cr = om.CaseReader(filename)
cases = cr.list_cases('driver', out_stream=None)
# cases recorded on this proc
num_cases = len(cases)
self.assertEqual(num_cases, len(expected) // num_models + (rank < len(expected) % num_models))
for n, case in enumerate(cases):
idx = n * num_models + rank # index of expected case
outputs = cr.get_case(case).outputs
self.assertEqual(outputs['x1'], expected[idx]['x1'])
self.assertEqual(outputs['x2'], expected[idx]['x2'])
self.assertEqual(outputs['c3.y'], expected[idx]['c3.y'])
# total number of cases recorded across all requested procs
num_cases = prob.comm.allgather(num_cases)
self.assertEqual(sum(num_cases), len(expected))
def test_fan_in_grouped_serial_2x2(self):
# do not run cases in parallel, but with 2 procs per model
# (all cases will run on each of the 2 model instances)
run_parallel = False
procs_per_model = 2
prob = om.Problem(FanInGrouped())
model = prob.model
model.add_design_var('x1', lower=0.0, upper=1.0)
model.add_design_var('x2', lower=0.0, upper=1.0)
model.add_objective('c3.y')
prob.driver = om.DOEDriver(om.FullFactorialGenerator(levels=3))
prob.driver.add_recorder(om.SqliteRecorder("cases.sql"))
prob.driver.options['run_parallel'] = run_parallel
prob.driver.options['procs_per_model'] = procs_per_model
prob.setup()
failed, output = run_driver(prob)
self.assertFalse(failed)
prob.cleanup()
expected = [
{'x1': | np.array([0.]) | numpy.array |
# Lint as: python3
# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for lingvo Jax linear layers."""
from absl import logging
from absl.testing import absltest
from absl.testing import parameterized
import jax
from jax import numpy as jnp
from jax import test_util
from lingvo.core import layers as lingvo_layers
from lingvo.jax import py_utils
from lingvo.jax import test_utils
from lingvo.jax.layers import linears
import numpy as np
import tensorflow.compat.v2 as tf
ToNp = test_utils.ToNp
ToTfNmap = test_utils.ToTfNmap
class LinearsTest(test_util.JaxTestCase):
def setUp(self):
super().setUp()
| np.random.seed(123456) | numpy.random.seed |
"""
File with trajectory written to file: /users/srio/Oasys/tmp.traj
wiggler_cdf: Electron beam energy (from velocities) = 3.000355 GeV
wiggler_cdf: gamma (from velocities) = 5870.853556 GeV
wiggler_cdf: Curvature (min)) = 0.000000 m^-1
wiggler_cdf: (max) 0.199920 m^-1
wiggler_cdf: Radius of curvature (max) = 81689012171814624.000000 m
wiggler_cdf: (min) = 5.002009 m
wiggler_cdf: Critical Energy (max.) = 11973.937061 eV
wiggler_cdf: (min.) = 0.000000 eV
wiggler_cdf: Total no.of photons = 1.690471e+17 (in DE=99900.000 eV)
wiggler_cdf: File with wiggler cdf written to file: b'/users/srio/Oasys/xshwig.sha'
Electron beam energy (from velocities) = 3.000355 GeV
gamma (from velocities) = 5870.851896
curvature (max) = 0.199920 m
(min) = 0.000000 m
Radius of curvature (max) = 81689012171830928.000000 m
(min) = 5.002009 m
Critical Energy (max.) = 11973.926903 eV
(min.) = 0.000000 eV
File with wiggler spectrum written to file: spectrum.dat
Total power (from integral of spectrum): 10106.973910 W
Total number of photons (from integral of spectrum): 1.62115e+19
"""
#
# script to run the wiggler preprocessor (created by ShadowOui:Wiggler)
#
from srxraylib.sources import srfunc
from srxraylib.plot.gol import plot, plot_image, plot_scatter, plot_show
import numpy
from srxraylib.util.h5_simple_writer import H5SimpleWriter
from srxraylib.plot.gol import set_qt
from scipy.interpolate import interp1d
set_qt()
def P(u):
return 2 * numpy.pi / | numpy.sqrt(3) | numpy.sqrt |
# -*- coding: utf-8 -*-
"""Storage selection (SAS) functions: example with three solutes
Runs the rSAS model for a synthetic dataset with two fluxes out
and three solutes
Theory is presented in:
<NAME>. (2014), Time-variable transit time distributions and transport:
Theory and application to storage-dependent transport of chloride in a watershed,
Water Resour. Res., 51, doi:10.1002/2014WR015707.
"""
from __future__ import division
import rsas
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Initializes the random number generator so we always get the same result
np.random.seed(0)
# =====================================
# Generate the input timeseries
# =====================================
# length of the dataset
N = 100
S_0 = 10. # <-- volume of the uniformly sampled store
Q_0 = 1. # <-- steady-state flow rate
T_0 = S_0 / (2 * Q_0)
# Note that the analytical solution for the cumulative TTD is
T = np.arange(N+1)
PQ_exact = 1 - np.exp(-T/T_0)
# Steady-state flow in and out for N timesteps
J = np.ones(N) * Q_0 * 2
Q = np.ones((N, 2)) * Q_0
# Three random timeseries of concentrations
C_J = np.tile(-np.log(np.random.rand(N,1)), (1,3))
# =========================
# Parameters needed by rsas
# =========================
# The concentration of water older than the start of observations
C_old = [0., 0., 0.]
alpha = np.ones((N,2,3))
alpha[:,0,1] = 0.5
alpha[:,1,1] = 0.5
alpha[:,0,2] = 0.5
alpha[:,1,2] = 1.0
# =========================
# Create the rsas functions
# =========================
# Parameters for the rSAS function
# The uniform distribution extends between S_T=a and S_T=b.
Q_rSAS_fun_type = 'uniform'
ST_min = np.ones(N) * 0.
ST_max = np.ones(N) * S_0
Q_rSAS_fun_parameters = np.c_[ST_min, ST_max]
rSAS_fun_Q1 = rsas.create_function(Q_rSAS_fun_type, Q_rSAS_fun_parameters)
Q_rSAS_fun_type = 'uniform'
ST_min = np.ones(N) * 0.
ST_max = np.ones(N) * S_0
Q_rSAS_fun_parameters = np.c_[ST_min, ST_max]
rSAS_fun_Q2 = rsas.create_function(Q_rSAS_fun_type, Q_rSAS_fun_parameters)
# =================
# Initial condition
# =================
# Unknown initial age distribution, so just set this to zeros
ST_init = np.zeros(N + 1)
MS_init = np.zeros((N + 1, 1))
# =============
# Run the model
# =============
# Run it
#TODO check PQ with n_substeps>1
outputs = rsas.solve(J, Q, [rSAS_fun_Q1, rSAS_fun_Q2], ST_init=ST_init, MS_init=MS_init,
mode='RK4', dt = 1., n_substeps=10, C_J=C_J, C_old=C_old, alpha=alpha, verbose=False, debug=False)
# Let's pull these out to make the outputs from rsas crystal clear
# State variables: age-ranked storage of water and solutes
# ROWS of ST, MS are T - ages
# COLUMNS of ST, MS are t - times
# LAYERS of MS are s - solutes
ST = outputs['ST']
MS1 = outputs['MS'][:,:,0]
#MS2 = outputs['MS'][:,:,1]
#MS3 = outputs['MS'][:,:,2]
# Timestep-averaged backwards TTD
# ROWS of PQ are T - ages
# COLUMNS of PQ are t - times
# LAYERS of PQ are q - fluxes
PQ1m = outputs['PQ'][:,:,0]
PQ2m = outputs['PQ'][:,:,1]
# Timestep-averaged outflow concentration
# ROWS of C_Q are t - times
# COLUMNS of C_Q are q - fluxes
# LAYERS of C_Q are s - solutes
C1_Q1m1 = outputs['C_Q'][:,0,0]
C1_Q2m1 = outputs['C_Q'][:,1,0]
C2_Q1m1 = outputs['C_Q'][:,0,1]
C2_Q2m1 = outputs['C_Q'][:,1,1]
C3_Q1m1 = outputs['C_Q'][:,0,2]
C3_Q2m1 = outputs['C_Q'][:,1,2]
# Timestep averaged solute load out
# ROWS of MQ are T - ages
# COLUMNS of MQ are t - times
# LAYERS of MQ are q - fluxes
# Last dimension of MS are s - solutes
#M11m = outputs['MQ'][:,:,0,0]
#M12m = outputs['MQ'][:,:,1,0]
#M21m = outputs['MQ'][:,:,0,1]
#M22m = outputs['MQ'][:,:,1,1]
#M31m = outputs['MQ'][:,:,0,2]
#M32m = outputs['MQ'][:,:,1,2]
# ==================================
# Plot the age-ranked storage
# ==================================
# The analytical solution for the age-ranked storage is
T = np.arange(N+1)
ST_exact = S_0 * (1 - np.exp(-T/T_0))
# plot this with the rsas estimate
fig = plt.figure(1)
plt.clf()
plt.plot(ST[:,-1], 'b-', label='rsas model', lw=2)
plt.plot(ST_exact, 'r-.', label='analytical solution', lw=2)
plt.ylim((0,S_0))
plt.legend(loc=0)
plt.ylabel('$S_T(T)$')
plt.xlabel('age $T$')
plt.title('Age-ranked storage')
#%%
# =====================================================================
# Outflow concentration estimated using several different TTD
# =====================================================================
# Lets get the instantaneous value of the TTD at the end of each timestep
PQ1i = np.zeros((N+1, N+1))
PQ1i[:,0] = rSAS_fun_Q1.cdf_i(ST[:,0],0)
PQ1i[:,1:] = np.r_[[rSAS_fun_Q1.cdf_i(ST[:,i+1],i) for i in range(N)]].T
# Lets also get the exact TTD for the combined flux out
n=100
T=np.arange(N*n+1.)/n
PQ1e = np.tile(1-np.exp(-T/T_0), (N*n+1., 1)).T
# Use the transit time distribution and input timeseries to estimate
# the output timeseries for the exact, instantaneous and timestep-averaged cases
C1_Q1m2, C_mod_raw, observed_fraction = rsas.transport(PQ1m, C_J[:,0], C_old[0])
C1_Q1i, C_mod_raw, observed_fraction = rsas.transport(PQ1i, C_J[:,0], C_old[0])
C1_Q1ei, C_mod_raw, observed_fraction = rsas.transport(PQ1e, C_J[:,0].repeat(n), C_old[0])
# This calculates an exact timestep-averaged value
C1_Q1em = np.reshape(C1_Q1ei,(N,n)).mean(axis=1)
# Plot the results
fig = plt.figure(2)
plt.clf()
plt.step(np.arange(N), C1_Q1em, 'r', ls='-', label='mean exact, C1', lw=2, where='post')
plt.step(np.arange(N), C1_Q1m2, 'b', ls=':', label='mean rsas.transport, C1', lw=2, where='post')
plt.plot((np.arange(N*n) + 1.)/n, C1_Q1ei, 'r-', label='inst. exact, C1', lw=1)
plt.plot(np.arange(N)+1, C1_Q1i, 'b:o', label='inst. rsas.transport, C1', lw=1)
plt.step(np.arange(N), C1_Q1m1, 'g', ls='-', label='mean rsas internal, C1', lw=2, where='post')
plt.step(np.arange(N), C2_Q1m1, 'g', ls='--', label='mean rsas internal, C2', lw=2, where='post')
plt.step( | np.arange(N) | numpy.arange |
'''
Created on Nov 12, 2018
@author: <NAME> (<EMAIL>)
'''
import os
import glob
import argparse
import time
import pandas as pd
import numpy as np
import scipy.io as io
from keras.models import Model
from keras.layers import GRU, Dense, Dropout, Input
from keras import optimizers
from keras.utils import multi_gpu_model
import keras
import ipyparallel as ipp
# Constant.
MODEL_FILE_NAME = 'yaw_misalignment_calibrator.h5'
RESULT_FILE_NAME = 'ymc_result.csv'
dt = pd.Timedelta(10.0, 'm')
testTimeRanges = [(pd.Timestamp('2018-05-19'), pd.Timestamp('2018-05-26') - dt)
, (pd.Timestamp('2018-05-26'), pd.Timestamp('2018-06-02') - dt)
, (pd.Timestamp('2018-06-02'), pd.Timestamp('2018-06-09') - dt)
, (pd.Timestamp('2018-06-09'), pd.Timestamp('2018-06-16') - dt)
, (pd.Timestamp('2018-08-24'), pd.Timestamp('2018-08-31') - dt)
, (pd.Timestamp('2018-08-28'), pd.Timestamp('2018-09-04') - dt)]
testTimeRangeStrings = ['19/05/2018 to 25/05/2018'
, '26/05/2018 to 01/06/2018'
, '02/06/2018 to 08/06/2018'
, '09/06/2018 to 15/06/2018'
, '24/08/2018 to 30/08/2018'
, '28/08/2018 to 03/09/2018']
WIND_BIN_SIZE = 1
WIND_BIN_MAX = 20
ACTIVE_POWER_MAX = 1800.
WIND_SPEED_MAX = 16.
WIND_DIRECTION_NORMAL_FACTOR = 2 * np.pi
DELTA_TIME = 1
IS_MULTI_GPU = False
NUM_GPUS = 4
IS_DEBUG = False
def applyKalmanFilter(data, q=1e-5):
'''
Apply Kalman filter.
@param data: Data.
'''
# Apply Kalman filter.
# Check exception.
if data.shape[0] == 1:
r = 1.0
else:
r = data.std()**2
vals = []
x_pre = data.mean()
p_pre = r
for i in range(data.shape[0]):
xhat = x_pre
phat = p_pre + q
k = phat/(phat + r)
x = xhat + k * (data[i] - xhat)
p = (1 - k) * phat
vals.append(x)
x_pre = x
p_pre = p
vals = np.asarray(vals)
return vals
class YawMisalignmentCalibrator(object):
'''
Yaw misalignment calibrator.
'''
def __init__(self, rawDataPath):
'''
Constructor.
'''
# Initialize.
self.rawDataPath = rawDataPath
def train(self, hps, trainDataLoading = True, modelLoading = False):
'''
Train.
@param hps: Hyper-parameters.
@param trainDataLoading: Train data loading flag.
@param modelLoading: Model loading flag.
'''
self.hps = hps
if modelLoading == True:
print('Load the pre-trained model...')
if IS_MULTI_GPU == True:
self.model = multi_gpu_model(keras.models.load_model(MODEL_FILE_NAME), gpus = NUM_GPUS)
else:
self.model = keras.models.load_model(MODEL_FILE_NAME)
else:
# Design the model.
print('Design the model.')
# Input1: n (n sequence) x 2 (calibrated c_avg_ws1, avg_a_power)
input1 = Input(shape=(self.hps['num_seq1'], 2))
_, c = GRU(self.hps['gru1_dim'], return_state = True, name='gru1')(input1)
# Input2: ywe value sequence.
input2 = Input(shape=(self.hps['num_seq2'], 1))
x, _ = GRU(self.hps['gru2_dim']
, return_sequences = True
, return_state = True
, name='gru2')(input2, initial_state = c)
for i in range(1, hps['num_layers'] + 1):
x = Dense(self.hps['dense1_dim'], activation='relu', name='dense1_' + str(i))(x)
x = Dropout(hps['dropout1_rate'])(x)
output = Dense(1, activation='linear', name='dense1_last')(x)
# Create the model.
if IS_MULTI_GPU == True:
self.model = multi_gpu_model(Model(inputs=[input1, input2]
, outputs=[output]), gpus = NUM_GPUS)
else:
self.model = Model(inputs=[input1, input2], outputs=[output])
# Compile the model.
optimizer = optimizers.Adam(lr=self.hps['lr']
, beta_1=self.hps['beta_1']
, beta_2=self.hps['beta_2']
, decay=self.hps['decay'])
self.model.compile(optimizer=optimizer, loss='mse')
self.model.summary()
# Create training and validation data.
tr, val = self.__createTrValData__(hps, trainDataLoading = True, dataLoading = False)
trInput1M, trInput2M, trOutputM = tr
#valInput1M, valInput2M, valOutputM = val
# Train the model.
hists = []
hist = self.model.fit([trInput1M, trInput2M], [trOutputM]
, epochs=self.hps['epochs']
, batch_size=self.hps['batch_size']
#, validation_data = ([valInput1M, valInput2M], [valOutputM])
, verbose=1)
hists.append(hist)
# Print loss.
print(hist.history['loss'][-1])
print('Save the model.')
self.model.save(MODEL_FILE_NAME)
# Make the prediction model.
self.__makePredictionModel__();
# Calculate loss.
lossList = list()
for h in hists:
lossList.append(h.history['loss'][-1])
lossArray = np.asarray(lossList)
lossMean = lossArray.mean()
print('Each mean loss: {0:f} \n'.format(lossMean))
with open('losses.csv', 'a') as f:
f.write('{0:f} \n'.format(lossMean))
with open('loss.csv', 'w') as f:
f.write(str(lossMean) + '\n') #?
return lossMean
def __makePredictionModel__(self):
'''
Make the prediction model.
'''
# Affecting factor sequence model.
input1 = Input(shape=(self.hps['num_seq1'], 2))
_, c = self.model.get_layer('gru1')(input1)
self.afModel = Model([input1], [c])
# Target factor prediction model.
input2 = Input(shape=(1,1))
recurState = Input(shape=(self.hps['gru1_dim'],)) #?
x, c2 = self.model.get_layer('gru2')(input2, initial_state = recurState) #?
for i in range(1, self.hps['num_layers'] + 1):
x = self.model.get_layer('dense1_' + str(i))(x)
output = self.model.get_layer('dense1_last')(x)
self.predModel = Model([input2, recurState], [output, c2])
def __createTrValData__(self, hps, trainDataLoading = True, dataLoading = False):
'''
Create training and validation data.
@param hps: Hyper-parameters.
@param trainDataLoading: Train data loading flag.
@param dataLoading: Data loading flag.
'''
if dataLoading:
trValMs_mat = io.loadmat('trValMs.mat')
trInput1M = trValMs_mat['trInput1M']
trInput2M = trValMs_mat['trInput2M']
trOutputM = trValMs_mat['trOutputM']
valInput1M = trValMs_mat['valInput1M']
valInput2M = trValMs_mat['valInput2M']
valOutputM = trValMs_mat['valOutputM']
tr = (trInput1M, trInput2M, trOutputM)
val = (valInput1M, valInput2M, valOutputM)
return tr, val
pClient = ipp.Client()
pView = pClient[:]
# Load raw data.
if trainDataLoading:
rawDatasDF = pd.read_csv('train.csv')
else:
rawDatasDF = self.trValDataDF
num_seq1 = hps['num_seq1']
num_seq2 = hps['num_seq2']
# Training data.
trRawDatasDF = rawDatasDF.iloc[:int(rawDatasDF.shape[0]*(1.0 - hps['val_ratio'])), :]
#trRawDatasDF = trRawDatasDF.iloc[:3000,:]
numSample = trRawDatasDF.shape[0]
t = 1 # One based time index.
# Input 1.
trInput1 = []
trOutput = []
trInput2 = []
pView.push({'num_seq1': num_seq1, 'num_seq2': num_seq2, 'trRawDatasDF': trRawDatasDF})
ts = []
while ((t + num_seq1 + num_seq2 - 1) <= numSample):
ts.append(t - 1)
t += 1 + DELTA_TIME # One based time index.
res = pView.map(getInputOutput, ts, block=True)
for i in range(len(res)):
trInput1.append(res[i][0])
trOutput.append(res[i][1])
trInput2.append(res[i][2])
trInput1M = np.asarray(trInput1)
trOutputM = np.expand_dims(np.asarray(trOutput), 2)
trInput2M = np.expand_dims(np.asarray(trInput2), 2)
tr = (trInput1M, trInput2M, trOutputM)
# Validation data.
valRawDatasDF = rawDatasDF.iloc[:int(rawDatasDF.shape[0]*(1.0 - hps['val_ratio'])), :]
#valRawDatasDF = valRawDatasDF.iloc[:3000,:]
numSample = valRawDatasDF.shape[0]
t = 1 # One based time index.
# Input 1.
valInput1 = []
valOutput = []
valInput2 = []
pView.push({'num_seq1': num_seq1, 'num_seq2': num_seq2, 'trRawDatasDF': valRawDatasDF})
ts = []
while ((t + num_seq1 + num_seq2 - 1) <= numSample):
ts.append(t - 1)
t += 1 + DELTA_TIME # One based time index.
res = pView.map(getInputOutput, ts, block=True)
for i in range(len(res)):
valInput1.append(res[i][0])
valOutput.append(res[i][1])
valInput2.append(res[i][2])
valInput1M = np.asarray(valInput1)
valOutputM = np.expand_dims(np.asarray(valOutput), 2)
valInput2M = np.expand_dims(np.asarray(valInput2), 2)
val = (valInput1M, valInput2M, valOutputM)
# Save data.
io.savemat('trValMs.mat', mdict={'trInput1M': trInput1M
, 'trInput2M': trInput2M
, 'trOutputM': trOutputM
, 'valInput1M': valInput1M
, 'valInput2M': valInput2M
, 'valOutputM': valOutputM}
, oned_as='row') #?
return tr, val
def evaluate(self, hps, modelLoading = True, evalDataLoading = False):
'''
Evaluate.
@param hps: Hyper-parameters.
@param modelLoading: Model loading flag.
'''
self.hps = hps
if modelLoading == True:
print('Load the pre-trained model...')
if IS_MULTI_GPU == True:
self.model = multi_gpu_model(keras.models.load_model(MODEL_FILE_NAME), gpus = NUM_GPUS)
else:
self.model = keras.models.load_model(MODEL_FILE_NAME)
# Make the prediction model.
self.__makePredictionModel__();
# Load evaluation data.
valid_columns = ['avg_a_power'
, 'avg_rwd1'
, 'avg_ws1'
, 'corr_factor_anem1'
, 'corr_offset_anem1'
, 'offset_anem1'
, 'slope_anem1'
, 'g_status'
, 'Turbine_no']
if evalDataLoading:
evalDF = pd.read_csv('evalDF.csv')
else:
# B08 data.
b8DF = pd.read_excel(os.path.join(self.rawDataPath, 'SCADA_B8_19May_1June.xlsx'))
b8DF = b8DF.append(pd.read_excel(os.path.join(self.rawDataPath,'SCADA_B8_2june_15june.xlsx'))
, ignore_index=True)
b8DF.index = pd.to_datetime(b8DF.Timestamp)
b8DF = b8DF[valid_columns]
# Relevant lidar data.
lidarDF = pd.read_excel(os.path.join(self.rawDataPath, 'Lidar_data 19May2018_to_15june2018_TurbineB8.xlsx'))
lidarDF.index = pd.to_datetime(lidarDF.Date_time)
lidarDF = lidarDF[lidarDF.columns[1:]]
# Evaluation data.
evalDF = pd.concat([lidarDF, b8DF], axis=1)
evalDF = evalDF.dropna(how='any')
evalDF.index.name = 'Timestamp'
evalDF.sort_values(by='Timestamp')
# Save evaluation data.
evalDF.to_csv('evalDF.csv')
teDataDF = pd.DataFrame(columns=['Turbine_no', 'avg_a_power', 'YMA(deg)', 'c_avg_ws1', 'avg_rwd1'])
# Apply Kalman filtering to avg_rwd1 for each wind turbine and reduce yaw misalignment
# and calibrate avg_ws1 with coefficients.
avg_rwd1s = np.asarray(evalDF.avg_rwd1) #- applyKalmanFilter(np.asarray(evalDF.avg_rwd1))
# Calibrate avg_ws1 with coefficients.
c_avg_ws1s = np.asarray(evalDF.corr_offset_anem1 + evalDF.corr_factor_anem1 * evalDF.avg_ws1 \
+ evalDF.slope_anem1 * evalDF.avg_rwd1 + evalDF.offset_anem1) #?
teData = {'Timestamp': list(pd.to_datetime(evalDF.Timestamp))
, 'Turbine_no': list(evalDF.Turbine_no)
, 'avg_a_power': | np.asarray(evalDF.avg_a_power) | numpy.asarray |
# coding: utf-8
# ## Importing, Exporting, Basic Slicing and Indexing.
# In terms of the importing and exporting files I would not go depth on it. You can refer the docstring for complete information on the various ways it can be used. A few examples will be given here in regard to this. I would spent sometime on the slicing and indexing arrays.
# ### Here are the main steps we will go through
# * How to use loadtxt, genfromtxt, and savetxt?
# * How to slice and index array?
#
# This is just little illustration.
# <img src="http://www.bogotobogo.com/python/images/python_strings/string_diagram.png">
# #### How to use loadtxt, genfromtxt, and savetxt??
# * <b>numpy.loadtxt()</b> : Load data from a text file. This function aims to be a fast reader for simply formatted files.
# * <b>numpy.genfromtxt()</b>: Load data from a text file, with missing values handled as specified. When spaces are used as delimiters, or when no delimiter has been given as input, there should not be any missing data between two fields. When the variables are named (either by a flexible dtype or with names, there must not be any header in the file (else a ValueError exception is raised). Individual values are not stripped of spaces by default. When using a custom converter, make sure the function does remove spaces.
# * <b>numpy.savetxt()</b>: Save an array to a text file. Further explanation of the fmt parameter (%[flag]width[.precision]specifier):
#
# ##### Example
# Here is the general idea, I'll come back to it.
# In[2]:
import numpy as np
# using numpy you can load text file
| np.loadtxt('file_name.txt') | numpy.loadtxt |
'''
From https://github.com/tsc2017/inception-score
Code derived from https://github.com/openai/improved-gan/blob/master/inception_score/model.py
Args:
images: A numpy array with values ranging from -1 to 1 and shape in the form [N, 3, HEIGHT, WIDTH] where N, HEIGHT and WIDTH can be arbitrary.
splits: The number of splits of the images, default is 10.
Returns:
mean and standard deviation of the inception across the splits.
'''
import tensorflow as tf
import os, sys
import functools
import numpy as np
import math
import time
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import functional_ops
tfgan = tf.contrib.gan
BATCH_SIZE=256
session = tf.InteractiveSession()
# Run images through Inception.
inception_images=tf.placeholder(tf.float32,[BATCH_SIZE,3,None,None])
def inception_logits(images=inception_images, num_splits=1):
images=tf.transpose(images,[0,2,3,1])
size = 299
images = tf.image.resize_bilinear(images, [size, size])
generated_images_list = array_ops.split(
images, num_or_size_splits=num_splits)
logits = functional_ops.map_fn(
fn=functools.partial(tfgan.eval.run_inception, output_tensor='logits:0'),
elems=array_ops.stack(generated_images_list),
parallel_iterations=1,
back_prop=False,
swap_memory=True,
name='RunClassifier')
logits = array_ops.concat(array_ops.unstack(logits), 0)
return logits
logits=inception_logits()
def get_inception_probs(inps):
preds = []
n_batches = len(inps)//BATCH_SIZE
for i in range(n_batches):
inp = inps[i * BATCH_SIZE:(i + 1) * BATCH_SIZE]
pred = logits.eval({inception_images:inp})[:,:1000]
preds.append(pred)
preds = np.concatenate(preds, 0)
preds=np.exp(preds)/np.sum(np.exp(preds),1,keepdims=True)
return preds
def preds2score(preds,splits):
scores = []
for i in range(splits):
part = preds[(i * preds.shape[0] // splits):((i + 1) * preds.shape[0] // splits), :]
kl = part * (np.log(part) - np.log(np.expand_dims(np.mean(part, 0), 0)))
kl = np.mean( | np.sum(kl, 1) | numpy.sum |
import json
import cv2
import numpy as np
import os
from joblib import Parallel, delayed
import argparse
import sys
sys.path.append('../')
import Rect
#input original image and page bbox, output ROI (text region) bbox
def ExpandCol(rect,n):
rect = [list(rect[0]), list(rect[1]), rect[2]]
if n>1:
if rect[1][0] > rect[1][1]:
rect[1][1] = rect[1][1] * (n+1) / (n-1)
else:
rect[1][0] = rect[1][0] * (n+1) / (n-1)
else:
if rect[1][0] > rect[1][1]:
rect[1][1] = rect[1][1] + rect[1][0] * 0.1325 * 2
else:
rect[1][0] = rect[1][0] + rect[1][1] * 0.1325 * 2
return tuple(rect)
def GetImgFilename(jsonfile):
book, p , _ = jsonfile.split('.')[0].split('_')
p = p[0] + str(int(p[1:]))
return book + '_' + p + '.png'
def main(pagefilename,args):
'''
:return: rect(s) of detected ROI
estimate the ROI by finding the vertical lines
'''
print("processing "+pagefilename)
imgfilename=GetImgFilename(pagefilename)
img = cv2.imread(os.path.join(args.imgdir,imgfilename), 0)
with open(os.path.join(args.pagedir,pagefilename)) as file:
rect = json.load(file)
warped, M = Rect.CropRect(img, rect)
warped = cv2.pyrDown(warped)
scale = 2 ** 1
#remove salt-and-pepper noise, reduce the number of CCL areas
warped = cv2.medianBlur(warped, 3)
warped = cv2.medianBlur(warped, 3)
#local binarization
warped = cv2.adaptiveThreshold(warped, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 15, 4)
#filling small holes on vertical lines
kernel = np.ones([7,1], np.uint8)
warped = cv2.morphologyEx(warped, cv2.MORPH_CLOSE, kernel)
# CCL
ret, labels = cv2.connectedComponents(warped) # CCL
features = {}
#find candidate of the four vertical lines
for i in range(1, ret + 1): # O(n^3), that's why we need downsampling
if labels[labels == i].shape[0] > warped.shape[0]: # remove words (small CCL regions)
HRange, WRange = np.where(labels == i)
if (max(HRange) - min(HRange)) > 0.4 * warped.shape[0] and (max(HRange) - min(HRange)) / (
max(WRange) - min(WRange)) > 15 and min(WRange)>0.1*warped.shape[1] and max(WRange)<0.9*warped.shape[1]:
w = (max(WRange) + min(WRange)) / 2
features[i] = min(w, warped.shape[1] - w)
# import pdb;pdb.set_trace()
# find the four lines that are most far away from the two sides (some simple classifier)
if len(features) > 4:
features = sorted(features.items(), key=lambda kv: kv[1])
features = features[-4:]
else:
if len(features)>0:
features = sorted(features.items(), key=lambda kv: kv[1])
if len(features)<4:
print("warning: less than four vertical lines detected for page "+pagefilename)
else:
print("warning: no vertical line detected for page " + pagefilename)
return 0
index = [item[0] for item in features]
lines = np.zeros(labels.shape) # mask for lines
for i in index:
lines = lines + (labels == i).astype(int)
#import pdb;pdb.set_trace()
_ , cnts , _ = cv2.findContours(lines.astype(np.uint8), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
lines = | np.concatenate(cnts, axis=0) | numpy.concatenate |
'''
Created on Mar 23, 2012
@author: <NAME> (<EMAIL>)
'''
from run_rmhd2d import rmhd2d
import numpy as np
from numpy import abs
import time
from petsc4py import PETSc
from rmhd.solvers.common.PETScDerivatives import PETScDerivatives
from rmhd.solvers.linear.PETScPoissonCFD2 import PETScPoisson
from rmhd.solvers.nonlinear.PETScNonlinearSolverArakawaJ1CFD2 import PETScSolver
from rmhd.solvers.nonlinear.PETScNonlinearSolverArakawaJ1CFD2DOF2 import PETScSolverDOF2
from rmhd.solvers.preconditioner.PETScPreconditionerArakawaJ1CFD2DOF2Vec import PETScPreconditioner
class rmhd2d_split(rmhd2d):
'''
PETSc/Python Reduced MHD Solver in 2D using split solver.
'''
def __init__(self, cfgfile):
'''
Constructor
'''
super().__init__(cfgfile, mode = "split")
OptDB = PETSc.Options()
# OptDB.setValue('ksp_monitor', '')
# OptDB.setValue('snes_monitor', '')
#
# OptDB.setValue('log_info', '')
# OptDB.setValue('log_summary', '')
OptDB.setValue('ksp_rtol', self.cfg['solver']['petsc_ksp_rtol'])
OptDB.setValue('ksp_atol', self.cfg['solver']['petsc_ksp_atol'])
OptDB.setValue('ksp_max_it', self.cfg['solver']['petsc_ksp_max_iter'])
# OptDB.setValue('ksp_initial_guess_nonzero', 1)
OptDB.setValue('pc_type', 'hypre')
OptDB.setValue('pc_hypre_type', 'boomeramg')
OptDB.setValue('pc_hypre_boomeramg_max_iter', 2)
# OptDB.setValue('pc_hypre_boomeramg_max_levels', 6)
# OptDB.setValue('pc_hypre_boomeramg_tol', 1e-7)
# create DA (dof = 2 for A, P)
self.da2 = PETSc.DA().create(dim=2, dof=2,
sizes=[self.nx, self.ny],
proc_sizes=[PETSc.DECIDE, PETSc.DECIDE],
boundary_type=('periodic', 'periodic'),
stencil_width=1,
stencil_type='box')
# create solution and RHS vector
self.dx2 = self.da2.createGlobalVec()
self.dy2 = self.da2.createGlobalVec()
self.b = self.da2.createGlobalVec()
self.Ad = self.da1.createGlobalVec()
self.Jd = self.da1.createGlobalVec()
self.Pd = self.da1.createGlobalVec()
self.Od = self.da1.createGlobalVec()
# create Jacobian, Function, and linear Matrix objects
self.petsc_precon = PETScPreconditioner(self.da1, self.da2, self.nx, self.ny, self.ht, self.hx, self.hy)
# self.petsc_solver2 = PETScSolverDOF2(self.da1, self.da2, self.nx, self.ny, self.ht, self.hx, self.hy)
self.petsc_solver2 = PETScSolverDOF2(self.da1, self.da2, self.nx, self.ny, self.ht, self.hx, self.hy, self.petsc_precon)
self.petsc_solver = PETScSolver(self.da1, self.da4, self.nx, self.ny, self.ht, self.hx, self.hy)
self.petsc_precon.set_tolerances(poisson_rtol=self.cfg['solver']['pc_poisson_rtol'],
poisson_atol=self.cfg['solver']['pc_poisson_atol'],
poisson_max_it=self.cfg['solver']['pc_poisson_max_iter'],
parabol_rtol=self.cfg['solver']['pc_parabol_rtol'],
parabol_atol=self.cfg['solver']['pc_parabol_atol'],
parabol_max_it=self.cfg['solver']['pc_parabol_max_iter'],
jacobi_max_it=self.cfg['solver']['pc_jacobi_max_iter'])
# initialise matrixfree Jacobian
self.Jmf = PETSc.Mat().createPython([self.b.getSizes(), self.b.getSizes()],
context=self.petsc_solver2,
comm=PETSc.COMM_WORLD)
self.Jmf.setUp()
# create linear solver
self.ksp = PETSc.KSP().create()
self.ksp.setFromOptions()
self.ksp.setOperators(self.Jmf)
self.ksp.setInitialGuessNonzero(True)
self.ksp.setType('fgmres')
self.ksp.getPC().setType('none')
# update solution history
self.petsc_solver.update_previous(self.x)
self.petsc_solver2.update_previous(self.A, self.J, self.P, self.O)
def __del__(self):
self.ksp.destroy()
self.Jmf.destroy()
def run(self):
run_time = time.time()
alpha = 1.5 # 64x64
# alpha = 1.1 # 128x128
# alpha = 1.5 # 256x256
gamma = 0.9
# ksp_max = 1E-1 # 64x64, 128x128
ksp_max = 1E-3 # 256x256
for itime in range(1, self.nt+1):
if PETSc.COMM_WORLD.getRank() == 0:
localtime = time.asctime( time.localtime(time.time()) )
print("\nit = %4d, t = %10.4f, %s" % (itime, self.ht*itime, localtime) )
print
# calculate initial guess
self.calculate_initial_guess(initial=itime==1)
# self.calculate_initial_guess(initial=True)
# update history
self.petsc_solver.update_history()
self.petsc_solver2.update_history()
# copy initial guess to x
x_arr = self.da4.getVecArray(self.x)
x_arr[:,:,0] = self.da1.getVecArray(self.A)[:,:]
x_arr[:,:,1] = self.da1.getVecArray(self.J)[:,:]
x_arr[:,:,2] = self.da1.getVecArray(self.P)[:,:]
x_arr[:,:,3] = self.da1.getVecArray(self.O)[:,:]
# solve
i = 0
self.petsc_solver.update_previous(self.x)
self.petsc_solver2.update_previous(self.A, self.J, self.P, self.O)
self.petsc_solver.function(self.f)
pred_norm = self.f.norm()
prev_norm = pred_norm
tolerance = self.tolerance + self.cfg['solver']['petsc_snes_rtol'] * pred_norm
# print("tolerance:", self.tolerance, self.cfg['solver']['petsc_snes_rtol'] * pred_norm, tolerance)
if PETSc.COMM_WORLD.getRank() == 0:
print(" Nonlinear Solver Iteration %i: residual = %22.16E" % (i, pred_norm))
while True:
i+=1
f_arr = self.da4.getVecArray(self.f)
b_arr = self.da2.getVecArray(self.b)
b_arr[:,:,0] = -f_arr[:,:,0]
b_arr[:,:,1] = -f_arr[:,:,3]
self.da1.getVecArray(self.FA)[...] = f_arr[:,:,0]
self.da1.getVecArray(self.FJ)[...] = f_arr[:,:,1]
self.da1.getVecArray(self.FP)[...] = f_arr[:,:,2]
self.da1.getVecArray(self.FO)[...] = f_arr[:,:,3]
self.petsc_solver2.update_function(self.FA, self.FJ, self.FP, self.FO)
self.dy2.set(0.)
# self.b.copy(self.dy2)
if i == 1:
zeta_A = 0.
zeta_B = 0.
zeta_C = 0.
zeta_D = 0.
ksp_tol = self.cfg['solver']['petsc_ksp_rtol']
# self.ksp.setTolerances(rtol=ksp_tol, max_it=3)
else:
zeta_A = gamma * np.power(pred_norm / prev_norm , alpha)
zeta_B = np.power(ksp_tol, alpha)
zeta_C = min(ksp_max, max(zeta_A, zeta_B))
zeta_D = gamma * tolerance / pred_norm
ksp_tol = min(ksp_max, max(zeta_C, zeta_D))
# self.ksp.setTolerances(rtol=ksp_tol, max_it=5)
# self.ksp.setTolerances(rtol=ksp_tol)
self.ksp.solve(self.b, self.dy2)
self.petsc_precon.solve(self.dy2, self.dx2)
# self.dy2.copy(self.dx2)
dx_arr = self.da2.getVecArray(self.dx2)
self.da1.getVecArray(self.Ad)[...] = dx_arr[:,:,0]
self.da1.getVecArray(self.Pd)[...] = dx_arr[:,:,1]
self.derivatives.laplace_vec(self.Pd, self.Od, -1.)
self.derivatives.laplace_vec(self.Ad, self.Jd, -1.)
self.Od.axpy(-1., self.FP)
self.Jd.axpy(-1., self.FJ)
dx_arr = self.da4.getVecArray(self.dx)
dx_arr[:,:,0] = self.da1.getVecArray(self.Ad)[...]
dx_arr[:,:,1] = self.da1.getVecArray(self.Jd)[...]
dx_arr[:,:,2] = self.da1.getVecArray(self.Pd)[...]
dx_arr[:,:,3] = self.da1.getVecArray(self.Od)[...]
self.x.axpy(1., self.dx)
self.A.axpy(1., self.Ad)
self.J.axpy(1., self.Jd)
self.P.axpy(1., self.Pd)
self.O.axpy(1., self.Od)
self.petsc_solver.update_previous(self.x)
self.petsc_solver2.update_previous(self.A, self.J, self.P, self.O)
prev_norm = pred_norm
self.petsc_solver.function(self.f)
pred_norm = self.f.norm()
if PETSc.COMM_WORLD.getRank() == 0:
print(" Nonlinear Solver Iteration %i: %5i GMRES iterations, residual = %22.16E, tolerance = %22.16E" % (i, self.ksp.getIterationNumber(), pred_norm, self.ksp.getTolerances()[0]) )
if | abs(prev_norm - pred_norm) | numpy.abs |
'''
Simple sanity check for all four Hidden Markov Models' implementations.
'''
import jax.numpy as jnp
from jax.random import PRNGKey
import matplotlib.pyplot as plt
import numpy as np
import distrax
from distrax import HMM
from jsl.hmm.hmm_numpy_lib import HMMNumpy, hmm_forwards_backwards_numpy, hmm_viterbi_numpy
from jsl.hmm.hmm_lib import HMMJax, hmm_viterbi_jax, hmm_forwards_backwards_jax
import jsl.hmm.hmm_logspace_lib as hmm_logspace_lib
def plot_inference(inference_values, z_hist, ax, state=1, map_estimate=False):
"""
Plot the estimated smoothing/filtering/map of a sequence of hidden states.
"Vertical gray bars denote times when the hidden
state corresponded to state 1. Blue lines represent the
posterior probability of being in that state given different subsets
of observed data." See Markov and Hidden Markov models section for more info
Parameters
----------
inference_values: array(n_samples, state_size)
Result of runnig smoothing method
z_hist: array(n_samples)
Latent simulation
ax: matplotlib.axes
state: int
Decide which state to highlight
map_estimate: bool
Whether to plot steps (simple plot if False)
"""
n_samples = len(inference_values)
xspan = np.arange(1, n_samples + 1)
spans = find_dishonest_intervals(z_hist)
if map_estimate:
ax.step(xspan, inference_values, where="post")
else:
ax.plot(xspan, inference_values[:, state])
for span in spans:
ax.axvspan(*span, alpha=0.5, facecolor="tab:gray", edgecolor="none")
ax.set_xlim(1, n_samples)
# ax.set_ylim(0, 1)
ax.set_ylim(-0.1, 1.1)
ax.set_xlabel("Observation number")
def find_dishonest_intervals(z_hist):
"""
Find the span of timesteps that the
simulated systems turns to be in state 1
Parameters
----------
z_hist: array(n_samples)
Result of running the system with two
latent states
Returns
-------
list of tuples with span of values
"""
spans = []
x_init = 0
for t, _ in enumerate(z_hist[:-1]):
if z_hist[t + 1] == 0 and z_hist[t] == 1:
x_end = t
spans.append((x_init, x_end))
elif z_hist[t + 1] == 1 and z_hist[t] == 0:
x_init = t + 1
return spans
# state transition matrix
A = jnp.array([
[0.95, 0.05],
[0.10, 0.90]
])
# observation matrix
B = jnp.array([
[1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6], # fair die
[1 / 10, 1 / 10, 1 / 10, 1 / 10, 1 / 10, 5 / 10] # loaded die
])
n_samples = 300
init_state_dist = jnp.array([1, 1]) / 2
hmm_numpy = HMMNumpy(np.array(A), np.array(B), np.array(init_state_dist))
hmm_jax = HMMJax(A, B, init_state_dist)
hmm = HMM(trans_dist=distrax.Categorical(probs=A),
init_dist=distrax.Categorical(probs=init_state_dist),
obs_dist=distrax.Categorical(probs=B))
hmm_log = hmm_logspace_lib.HMM(trans_dist=distrax.Categorical(probs=A),
init_dist=distrax.Categorical(probs=init_state_dist),
obs_dist=distrax.Categorical(probs=B))
seed = 314
z_hist, x_hist = hmm.sample(seed=PRNGKey(seed), seq_len=n_samples)
z_hist_str = "".join((np.array(z_hist) + 1).astype(str))[:60]
x_hist_str = "".join((np.array(x_hist) + 1).astype(str))[:60]
print("Printing sample observed/latent...")
print(f"x: {x_hist_str}")
print(f"z: {z_hist_str}")
# Do inference
alpha_numpy, _, gamma_numpy, loglik_numpy = hmm_forwards_backwards_numpy(hmm_numpy,
np.array(x_hist),
len(x_hist))
alpha_jax, _, gamma_jax, loglik_jax = hmm_forwards_backwards_jax(hmm_jax,
x_hist,
len(x_hist))
alpha_log, _, gamma_log, loglik_log = hmm_logspace_lib.hmm_forwards_backwards_log(hmm_log,
x_hist,
len(x_hist))
alpha, beta, gamma, loglik = hmm.forward_backward(x_hist)
assert np.allclose(alpha_numpy, alpha)
assert np.allclose(alpha_jax, alpha)
assert np.allclose(jnp.exp(alpha_log), alpha)
assert np.allclose(gamma_numpy, gamma)
assert | np.allclose(gamma_jax, gamma) | numpy.allclose |
import pickle
import numpy as np
import pandas as pd
import pytask
from scipy.stats import pearsonr as pear
from src.config import BLD
def get_column(res, spec):
"""
Creates Columns for table 2 for each specification.
For each estimated parameter the authors compute the mean,
median and standard error across individuals and list them
in a table.
Args:
res(list): list of arrays containing individual-specific paramater estimates
spec(int): specification parameter
Returns:
column(Pd.Dataframe): column spec of table 2
"""
if spec != 4:
param = pd.DataFrame(
res, columns=["beta", "betahat", "delta", "gamma", "phi", "sigma"]
)
column = np.round(
[
np.mean(param["beta"]),
np.median(param["beta"]),
np.std(param["beta"]),
np.mean(param["betahat"]),
np.median(param["betahat"]),
np.std(param["betahat"]),
np.mean(param["delta"]),
np.median(param["delta"]),
np.std(param["delta"]),
| np.mean(param["gamma"]) | numpy.mean |
# !/usr/bin/env python
# Copyright (c) 2016-2017, wradlib developers.
# Distributed under the MIT License. See LICENSE.txt for more info.
import sys
import unittest
import wradlib.georef as georef
import wradlib.util as util
from wradlib.io import read_generic_hdf5, open_raster, gdal_create_dataset
import numpy as np
from osgeo import gdal, osr, ogr
from deprecation import fail_if_not_removed
np.set_printoptions(edgeitems=3, infstr='inf', linewidth=75, nanstr='nan',
precision=8, suppress=False, threshold=1000,
formatter=None)
class CoordinateTransformTest(unittest.TestCase):
def setUp(self):
self.r = np.array([0., 0., 111., 111., 111., 111.]) * 1000
self.az = np.array([0., 180., 0., 90., 180., 270.])
self.th = np.array([0., 0., 0., 0., 0., 0.5])
self.csite = (9.0, 48.0)
self.result_xyz = tuple(
(np.array([0., 0., 0., 110993.6738, 0., -110976.7856]),
np.array([0., -0., 110993.6738, 0., -110976.7856, -0.]),
np.array([0., 0., 725.7159843, 725.7159843, 725.7159843,
1694.22337134])))
self.result = tuple(
(np.array([9., 9., 9., 10.49189531, 9., 7.50810469]),
np.array([48., 48., 48.99839742, 47.99034027, 47.00160258,
47.99034027]),
np.array([0., 0., 967.03198482, 967.03198482, 967.03198482,
1935.45679527])))
self.result_n = tuple(
(np.array([9., 9., 9., 10.48716091, 9., 7.51306531]),
np.array([48., 48., 48.99814438, 47.99037251, 47.00168131,
47.99037544]),
np.array([0., 0., 725.7159843, 725.7159843, 725.7159843,
1694.22337134])))
@fail_if_not_removed
def test_hor2aeq(self):
self.assertTrue(np.allclose(georef.misc.hor2aeq(0.25, 0.5, 0.75),
(-0.29983281824238966,
0.22925926995789672)))
@fail_if_not_removed
def test_aeq2hor(self):
self.assertTrue(np.allclose(georef.misc.aeq2hor(0.22925926995789672,
-0.29983281824238966,
0.75),
(0.25, 0.5)))
@fail_if_not_removed
def test_polar2lonlat(self):
self.assertTrue(
np.allclose(georef.polar2lonlat(self.r, self.az, self.csite),
self.result[:2]))
@fail_if_not_removed
def test_polar2lonlatalt(self):
self.assertTrue(np.allclose(
georef.polar2lonlatalt(self.r, self.az, self.th, self.csite),
self.result, rtol=1e-03))
def test_spherical_to_xyz(self):
coords, rad = georef.spherical_to_xyz(self.r, self.az,
self.th, self.csite)
self.assertTrue(np.allclose(coords[..., 0], self.result_xyz[0],
rtol=1e-03))
self.assertTrue(np.allclose(coords[..., 1], self.result_xyz[1],
rtol=1e-03))
self.assertTrue(np.allclose(coords[..., 2], self.result_xyz[2],
rtol=1e-03))
def test_bin_altitude(self):
altitude = georef.bin_altitude(np.arange(10., 101., 10.)
* 1000., 2., 0, 6370040.)
altref = np.array([354.87448647, 721.50702113, 1099.8960815,
1490.04009656, 1891.93744678, 2305.58646416,
2730.98543223, 3168.13258613, 3617.02611263,
4077.66415017])
np.testing.assert_allclose(altref, altitude)
def test_bin_distance(self):
distance = georef.bin_distance(np.arange(10., 101., 10.) * 1000., 2.,
0, 6370040.)
distref = np.array([9993.49302358, 19986.13717891, 29977.90491409,
39968.76869178, 49958.70098959, 59947.6743006,
69935.66113377, 79922.63401441, 89908.5654846,
99893.4281037])
np.testing.assert_allclose(distref, distance)
def test_site_distance(self):
altitude = georef.bin_altitude(np.arange(10., 101., 10.) * 1000., 2.,
0, 6370040.)
distance = georef.site_distance(np.arange(10., 101., 10.) * 1000., 2.,
altitude, 6370040.)
distref = np.array([9993.49302358, 19986.13717891, 29977.90491409,
39968.76869178, 49958.70098959, 59947.6743006,
69935.66113377, 79922.63401441, 89908.5654846,
99893.4281037])
np.testing.assert_allclose(distref, distance)
def test_spherical_to_proj(self):
coords = georef.spherical_to_proj(self.r, self.az,
self.th, self.csite)
self.assertTrue(np.allclose(coords[..., 0], self.result_n[0]))
self.assertTrue(np.allclose(coords[..., 1], self.result_n[1]))
self.assertTrue(np.allclose(coords[..., 2], self.result_n[2]))
@fail_if_not_removed
def test_polar2lonlatalt_n(self):
lon, lat, alt = georef.polar2lonlatalt_n(self.r, self.az,
self.th, self.csite)
self.assertTrue(np.allclose(lon, self.result_n[0]))
self.assertTrue(np.allclose(lat, self.result_n[1]))
self.assertTrue(np.allclose(alt, self.result_n[2]))
@fail_if_not_removed
def test__latscale(self):
self.assertEqual(georef.polar._latscale(), 111178.17148373958)
@fail_if_not_removed
def test__lonscale(self):
self.assertTrue(
np.allclose(georef.polar._lonscale(np.arange(-90., 90., 10.)),
np.array(
[6.80769959e-12, 1.93058869e+04, 3.80251741e+04,
5.55890857e+04,
7.14639511e+04, 8.51674205e+04, 9.62831209e+04,
1.04473307e+05,
1.09489125e+05, 1.11178171e+05, 1.09489125e+05,
1.04473307e+05,
9.62831209e+04, 8.51674205e+04, 7.14639511e+04,
5.55890857e+04,
3.80251741e+04, 1.93058869e+04])))
@fail_if_not_removed
def test_beam_height_n(self):
self.assertTrue(np.allclose(
georef.beam_height_n(np.arange(10., 101., 10.) * 1000., 2.),
np.array([354.87448647, 721.50702113, 1099.8960815,
1490.04009656, 1891.93744678, 2305.58646416,
2730.98543223, 3168.13258613, 3617.02611263,
4077.66415017])))
@fail_if_not_removed
def test_arc_distance_n(self):
self.assertTrue(np.allclose(
georef.arc_distance_n(np.arange(10., 101., 10.) * 1000., 2.),
np.array(
[9993.49302358, 19986.13717891, 29977.90491409, 39968.76869178,
49958.70098959, 59947.6743006, 69935.66113377, 79922.63401441,
89908.5654846, 99893.4281037])))
class CoordinateHelperTest(unittest.TestCase):
def test_centroid2polyvert(self):
self.assertTrue(
np.allclose(georef.centroid2polyvert([0., 1.], [0.5, 1.5]),
np.array([[-0.5, -0.5],
[-0.5, 2.5],
[0.5, 2.5],
[0.5, -0.5],
[-0.5, -0.5]])))
self.assertTrue(np.allclose(
georef.centroid2polyvert(np.arange(4).reshape((2, 2)), 0.5),
np.array([[[-0.5, 0.5],
[-0.5, 1.5],
[0.5, 1.5],
[0.5, 0.5],
[-0.5, 0.5]],
[[1.5, 2.5],
[1.5, 3.5],
[2.5, 3.5],
[2.5, 2.5],
[1.5, 2.5]]])))
@fail_if_not_removed
def test_polar2polyvert(self):
self.assertTrue(np.allclose(
georef.polar2polyvert(np.array([10000., 10100.]),
np.array([45., 90.]), (9., 48.)),
np.array([[[9.05100794, 48.08225674],
[9.051524, 48.0830875],
[9.12427234, 48.03435375],
[9.12302879, 48.03401088],
[9.05100794, 48.08225674]],
[[9.051524, 48.0830875],
[9.05204008, 48.08391826],
[9.12551589, 48.03469661],
[9.12427234, 48.03435375],
[9.051524, 48.0830875]],
[[9.12302879, 48.03401088],
[9.12427234, 48.03435375],
[9.051524, 48.0830875],
[9.05100794, 48.08225674],
[9.12302879, 48.03401088]],
[[9.12427234, 48.03435375],
[9.12551589, 48.03469661],
[9.05204008, 48.08391826],
[9.051524, 48.0830875],
[9.12427234, 48.03435375]]])))
def test_spherical_to_polyvert(self):
sph = georef.get_default_projection()
polyvert = georef.spherical_to_polyvert(np.array([10000., 10100.]),
np.array([45., 90.]), 0,
(9., 48.), proj=sph)
arr = np.asarray([[[9.05084865, 48.08224715, 6.],
[9.05136309, 48.0830778, 6.],
[9.1238846, 48.03435008, 6.],
[9.12264494, 48.03400725, 6.],
[9.05084865, 48.08224715, 6.]],
[[9.05136309, 48.0830778, 6.],
[9.05187756, 48.08390846, 6.],
[9.12512428, 48.03469291, 6.],
[9.1238846, 48.03435008, 6.],
[9.05136309, 48.0830778, 6.]],
[[9.12264494, 48.03400725, 6.],
[9.1238846, 48.03435008, 6.],
[9.05136309, 48.0830778, 6.],
[9.05084865, 48.08224715, 6.],
[9.12264494, 48.03400725, 6.]],
[[9.1238846, 48.03435008, 6.],
[9.12512428, 48.03469291, 6.],
[9.05187756, 48.08390846, 6.],
[9.05136309, 48.0830778, 6.],
[9.1238846, 48.03435008, 6.]]])
self.assertTrue(np.allclose(polyvert, arr, rtol=1e-12))
@fail_if_not_removed
def test_polar2centroids(self):
r = np.array([10000., 10100.])
az = np.array([45., 90.])
sitecoords = (9., 48.)
self.assertTrue(np.allclose(georef.polar2centroids(r, az, sitecoords),
tuple((np.array([[9.09469143, 9.09564428],
[9.13374952,
9.13509373]]),
np.array(
[[48.06324434, 48.06387957],
[47.99992237, 47.9999208]])))))
def test_spherical_to_centroids(self):
r = np.array([10000., 10100.])
az = np.array([45., 90.])
sitecoords = (9., 48., 0.)
sph = georef.get_default_projection()
centroids = georef.spherical_to_centroids(r, az, 0, sitecoords,
proj=sph)
arr = np.asarray([[[9.09439583, 48.06323717, 6.],
[9.09534571, 48.06387232, 6.]],
[[9.1333325, 47.99992262, 6.],
[9.13467253, 47.99992106, 6.]]])
self.assertTrue(np.allclose(centroids, arr))
def test_sweep_centroids(self):
self.assertTrue(np.allclose(georef.sweep_centroids(1, 100., 1, 2.0),
np.array([[[50., 3.14159265, 2.]]])))
def test__check_polar_coords(self):
r = np.array([50., 100., 150., 200.])
az = np.array([0., 45., 90., 135., 180., 225., 270., 315., 360.])
self.assertRaises(ValueError,
lambda: georef.polar._check_polar_coords(r, az))
r = np.array([0, 50., 100., 150., 200.])
az = np.array([0., 45., 90., 135., 180., 225., 270., 315.])
self.assertRaises(ValueError,
lambda: georef.polar._check_polar_coords(r, az))
r = np.array([100., 50., 150., 200.])
az = np.array([0., 45., 90., 135., 180., 225., 270., 315.])
self.assertRaises(ValueError,
lambda: georef.polar._check_polar_coords(r, az))
r = np.array([50., 100., 125., 200.])
az = np.array([0., 45., 90., 135., 180., 225., 270., 315.])
self.assertRaises(ValueError,
lambda: georef.polar._check_polar_coords(r, az))
r = np.array([50., 100., 150., 200.])
az = np.array([0., 45., 90., 135., 180., 225., 270., 315., 361.])
self.assertRaises(ValueError,
lambda: georef.polar._check_polar_coords(r, az))
r = np.array([50., 100., 150., 200.])
az = np.array([225., 270., 315., 0., 45., 90., 135., 180.])[::-1]
self.assertRaises(ValueError,
lambda: georef.polar._check_polar_coords(r, az))
@unittest.skipIf(sys.version_info < (3, 5),
"not supported in this python version")
def test__check_polar_coords_py3k(self):
r = np.array([50., 100., 150., 200.])
az = np.array([10., 45., 90., 135., 180., 225., 270., 315.])
self.assertWarns(UserWarning,
lambda: georef.polar._check_polar_coords(r, az))
class ProjectionsTest(unittest.TestCase):
def test_create_osr(self):
self.maxDiff = None
radolan_wkt = ('PROJCS["Radolan projection",'
'GEOGCS["Radolan Coordinate System",'
'DATUM["Radolan Kugel",'
'SPHEROID["Erdkugel",6370040.0,0.0]],'
'PRIMEM["Greenwich",0.0,AUTHORITY["EPSG","8901"]],'
'UNIT["degree",0.017453292519943295],'
'AXIS["Longitude",EAST],'
'AXIS["Latitude",NORTH]],'
'PROJECTION["polar_stereographic"],'
'PARAMETER["central_meridian",10.0],'
'PARAMETER["latitude_of_origin",60.0],'
'PARAMETER["scale_factor",{0:8.10f}],'
'PARAMETER["false_easting",0.0],'
'PARAMETER["false_northing",0.0],'
'UNIT["m*1000.0",1000.0],'
'AXIS["X",EAST],'
'AXIS["Y",NORTH]]'.
format((1. + np.sin(np.radians(60.))) /
(1. + np.sin(np.radians(90.)))))
self.assertEqual(georef.create_osr('dwd-radolan').ExportToWkt(),
radolan_wkt)
def test_proj4_to_osr(self):
srs = georef.proj4_to_osr('+proj=lcc +lat_1=46.8 +lat_0=46.8 +lon_0=0 '
'+k_0=0.99987742 +x_0=600000 +y_0=2200000 '
'+a=6378249.2 +b=6356515 '
'+towgs84=-168,-60,320,0,0,0,0 '
'+pm=paris +units=m +no_defs')
p4 = srs.ExportToProj4()
srs2 = osr.SpatialReference()
srs2.ImportFromProj4(p4)
self.assertTrue(srs.IsSame(srs2))
def test_get_earth_radius(self):
self.assertEqual(georef.get_earth_radius(50.), 6365631.51753728)
def test_reproject(self):
proj_gk = osr.SpatialReference()
proj_gk.ImportFromEPSG(31466)
proj_wgs84 = osr.SpatialReference()
proj_wgs84.ImportFromEPSG(4326)
x, y = georef.reproject(7., 53., projection_source=proj_wgs84,
projection_target=proj_gk)
lon, lat = georef.reproject(x, y, projection_source=proj_gk,
projection_target=proj_wgs84)
self.assertAlmostEqual(lon, 7.0)
self.assertAlmostEqual(lat, 53.0)
def test_get_default_projection(self):
self.assertEqual(georef.get_default_projection().ExportToWkt(),
('GEOGCS["WGS 84",DATUM["WGS_1984",'
'SPHEROID["WGS 84",6378137,298.257223563,'
'AUTHORITY["EPSG","7030"]],'
'AUTHORITY["EPSG","6326"]],'
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
'UNIT["degree",0.0174532925199433,'
'AUTHORITY["EPSG","9122"]],'
'AUTHORITY["EPSG","4326"]]'))
def test_epsg_to_osr(self):
self.assertEqual(georef.epsg_to_osr(4326).ExportToWkt(),
('GEOGCS["WGS 84",DATUM["WGS_1984",'
'SPHEROID["WGS 84",6378137,298.257223563,'
'AUTHORITY["EPSG","7030"]],'
'AUTHORITY["EPSG","6326"]],'
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
'UNIT["degree",0.0174532925199433,'
'AUTHORITY["EPSG","9122"]],'
'AUTHORITY["EPSG","4326"]]'))
self.assertEqual(georef.epsg_to_osr().ExportToWkt(),
('GEOGCS["WGS 84",DATUM["WGS_1984",'
'SPHEROID["WGS 84",6378137,298.257223563,'
'AUTHORITY["EPSG","7030"]],'
'AUTHORITY["EPSG","6326"]],'
'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
'UNIT["degree",0.0174532925199433,'
'AUTHORITY["EPSG","9122"]],'
'AUTHORITY["EPSG","4326"]]'))
def test_wkt_to_osr(self):
self.assertTrue(georef.wkt_to_osr('GEOGCS["WGS 84",DATUM["WGS_1984",'
'SPHEROID["WGS 84",6378137,'
'298.257223563,'
'AUTHORITY["EPSG","7030"]],'
'AUTHORITY["EPSG","6326"]],'
'PRIMEM["Greenwich",0,'
'AUTHORITY["EPSG","8901"]],'
'UNIT["degree",0.0174532925199433,'
'AUTHORITY["EPSG","9122"]],'
'AUTHORITY["EPSG","4326"]]').IsSame(
georef.get_default_projection()))
self.assertTrue(
georef.wkt_to_osr().IsSame(georef.get_default_projection()))
class PixMapTest(unittest.TestCase):
def test_pixel_coordinates(self):
pass
def test_pixel_to_map(self):
pass
def test_pixel_to_map3d(self):
pass
class GdalTests(unittest.TestCase):
def setUp(self):
filename = 'geo/bonn_new.tif'
geofile = util.get_wradlib_data_file(filename)
self.ds = open_raster(geofile)
(self.data,
self.coords,
self.proj) = georef.extract_raster_dataset(self.ds)
def test_read_gdal_coordinates(self):
georef.read_gdal_coordinates(self.ds)
def test_read_gdal_projection(self):
georef.read_gdal_projection(self.ds)
def test_read_gdal_values(self):
georef.read_gdal_values(self.ds)
def test_reproject_raster_dataset(self):
georef.reproject_raster_dataset(self.ds, spacing=0.005,
resample=gdal.GRA_Bilinear,
align=True)
def test_create_raster_dataset(self):
data, coords = georef.set_raster_origin(self.data.copy(),
self.coords.copy(),
'upper')
ds = georef.create_raster_dataset(data,
coords,
projection=self.proj,
nodata=-32768)
data, coords, proj = georef.extract_raster_dataset(ds)
np.testing.assert_array_equal(data, self.data)
np.testing.assert_array_almost_equal(coords, self.coords)
self.assertEqual(proj.ExportToWkt(), self.proj.ExportToWkt())
def test_set_raster_origin(self):
data, coords = georef.set_raster_origin(self.data.copy(),
self.coords.copy(), 'upper')
np.testing.assert_array_equal(data, self.data)
np.testing.assert_array_equal(coords, self.coords)
data, coords = georef.set_raster_origin(self.data.copy(),
self.coords.copy(), 'lower')
np.testing.assert_array_equal(data, np.flip(self.data, axis=-2))
np.testing.assert_array_equal(coords, np.flip(self.coords, axis=-3))
def test_extract_raster_dataset(self):
data, coords, proj = georef.extract_raster_dataset(self.ds)
class GetGridsTest(unittest.TestCase):
def setUp(self):
# calculate xy and lonlat grids with georef function
self.radolan_grid_xy = georef.get_radolan_grid(900, 900, trig=True)
self.radolan_grid_ll = georef.get_radolan_grid(900, 900, trig=True,
wgs84=True)
def test_get_radolan_grid_equality(self):
# create radolan projection osr object
scale = (1. + np.sin(np.radians(60.))) / (1. + np.sin(np.radians(90.)))
dwd_string = ('+proj=stere +lat_0=90 +lat_ts=90 +lon_0=10 '
'+k={0:10.8f} +x_0=0 +y_0=0 +a=6370040 +b=6370040 '
'+to_meter=1000 +no_defs'.format(scale))
proj_stereo = georef.proj4_to_osr(dwd_string)
# create wgs84 projection osr object
proj_wgs = osr.SpatialReference()
proj_wgs.ImportFromEPSG(4326)
# transform radolan polar stereographic projection to wgs84 and wgs84
# to polar stereographic
# using osr transformation routines
radolan_grid_ll = georef.reproject(self.radolan_grid_xy,
projection_source=proj_stereo,
projection_target=proj_wgs)
radolan_grid_xy = georef.reproject(self.radolan_grid_ll,
projection_source=proj_wgs,
projection_target=proj_stereo)
# check source and target arrays for equality
self.assertTrue(np.allclose(radolan_grid_ll, self.radolan_grid_ll))
self.assertTrue(np.allclose(radolan_grid_xy, self.radolan_grid_xy))
def test_get_radolan_grid_raises(self):
self.assertRaises(TypeError,
lambda: georef.get_radolan_grid('900', '900'))
self.assertRaises(ValueError,
lambda: georef.get_radolan_grid(2000, 2000))
def test_get_radolan_grid_shape(self):
radolan_grid_xy = georef.get_radolan_grid()
self.assertEqual((900, 900, 2), radolan_grid_xy.shape)
def test_radolan_coords(self):
x, y = georef.get_radolan_coords(7.0, 53.0)
self.assertAlmostEqual(x, -208.15159184860158)
self.assertAlmostEqual(y, -3971.7689758313813)
# Also test with trigonometric approach
x, y = georef.get_radolan_coords(7.0, 53.0, trig=True)
self.assertEqual(x, -208.15159184860175)
self.assertEqual(y, -3971.7689758313832)
def test_xyz_to_spherical(self):
xyz = np.array([[1000, 1000, 1000]])
r, phi, theta = georef.xyz_to_spherical(xyz)
self.assertAlmostEqual(r[0], 1732.11878135)
self.assertAlmostEqual(phi[0], 45.)
self.assertAlmostEqual(theta[0], 35.25802956)
class SatelliteTest(unittest.TestCase):
def setUp(self):
f = 'gpm/2A-CS-151E24S154E30S.GPM.Ku.V7-20170308.20141206-S095002-E095137.004383.V05A.HDF5' # noqa
gpm_file = util.get_wradlib_data_file(f)
pr_data = read_generic_hdf5(gpm_file)
pr_lon = pr_data['NS/Longitude']['data']
pr_lat = pr_data['NS/Latitude']['data']
zenith = pr_data['NS/PRE/localZenithAngle']['data']
wgs84 = georef.get_default_projection()
a = wgs84.GetSemiMajor()
b = wgs84.GetSemiMinor()
rad = georef.proj4_to_osr(('+proj=aeqd +lon_0={lon:f} ' +
'+lat_0={lat:f} +a={a:f} +b={b:f}' +
'').format(lon=pr_lon[68, 0],
lat=pr_lat[68, 0],
a=a, b=b))
pr_x, pr_y = georef.reproject(pr_lon, pr_lat,
projection_source=wgs84,
projection_target=rad)
self.re = georef.get_earth_radius(pr_lat[68, 0], wgs84) * 4. / 3.
self.pr_xy = np.dstack((pr_x, pr_y))
self.alpha = zenith
self.zt = 407000.
self.dr = 125.
self.bw_pr = 0.71
self.nbin = 176
self.nray = pr_lon.shape[1]
self.pr_out = np.array([[[[-58533.78453556, 124660.60390174],
[-58501.33048429, 124677.58873852]],
[[-53702.13393133, 127251.83656509],
[-53670.98686161, 127268.11882882]]],
[[[-56444.00788528, 120205.5374491],
[-56411.55421163, 120222.52300741]],
[[-51612.2360682, 122796.78620764],
[-51581.08938314, 122813.06920719]]]])
self.r_out = np.array([0., 125., 250., 375., 500., 625., 750., 875.,
1000., 1125.])
self.z_out = np.array([0., 119.51255112, 239.02510224, 358.53765337,
478.05020449, 597.56275561, 717.07530673,
836.58785786, 956.10040898, 1075.6129601])
def test_correct_parallax(self):
xy, r, z = georef.correct_parallax(self.pr_xy, self.nbin,
self.dr, self.alpha)
self.xyz = | np.concatenate((xy, z[..., np.newaxis]), axis=-1) | numpy.concatenate |
# USAGE
# python opencv-optical-flow.py
# python opencv-optical-flow.py --video PATH/example_01.mp4
import numpy
import cv2
import argparse
import time
import random
import math
import imutils
from collections import Counter
TRACKER_POINTS = 500 # How many points will be used to track the optical flow
CRAZY_LINE_DISTANCE = 50 # Distance value to detect crazy lines
CRAZY_LINE_LIMIT = 100 * TRACKER_POINTS / 1000 # Amount of crazy lines are indication of different shots
ABSDIFF_ANGLE = 20 # To determine the inconsistency between tangent values in degrees
LINE_THICKNESS = 3 # Lines thickness that we will use for mask delta
CONTOUR_LIMIT = 10 # Contour limit for detecting ZOOM, ZOOM + PAN, ZOOM + TILT, ZOOM + ROLL (Not just PAN, TILT, ROLL)
TARGET_HEIGHT = 360 # Number of horizontal lines for target video and processing. Like 720p, 360p etc.
DELTA_LIMIT_DIVISOR = 3 # Divisor for detecting too much motion. Like: ( height * width / X )
# Construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-v", "--video", help="path to the video file")
ap.add_argument("-a", "--min-area", type=int, default=500, help="minimum area size")
args = vars(ap.parse_args())
if args.get("video", None) is None: # If the video argument is None, then we are reading from webcam
cap = cv2.VideoCapture(0)
time.sleep(0.25)
else: # Otherwise, we are reading from a video file
cap = cv2.VideoCapture(args["video"])
# Parameters for Lucas Kanade Optical Flow
lk_params = dict( winSize = (15,15),
maxLevel = 2,
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
while True: # On this level it gets only one frame
color = numpy.random.randint(0,255,(TRACKER_POINTS,3)) # Create some random colors
ret, old_frame = cap.read() # Take first frame
old_frame = imutils.resize(old_frame, height=TARGET_HEIGHT) # Resize frame to 360p. Alternative resizing method:
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY) # Convert previous frame to grayscale
height, width = old_frame.shape[:2] # Get video height and width (size)
# Create random points on frame
p1 = numpy.random.randint(width, size=(TRACKER_POINTS, 1, 2))
for y in p1: # Get y values one by one
if y[0][1] > height: # If there is a y value that greater than max height
y[0][1] = numpy.random.random_integers(height) # Random again this time with max height value
p1 = p1.astype(numpy.float32) # Change numpy array's data type to float32
mask = numpy.zeros_like(old_frame) # Create a mask image for drawing purposes (original frame)
mask_delta = numpy.zeros_like(old_frame) # Create a mask image for drawing purposes (delta frame)
mask_white = numpy.ones_like(old_frame) # Create a white mask image for cloning original frame
white_color = | numpy.array([255,255,255]) | numpy.array |
"""Code for setting up, and running, and collecting data from PV-DER simulations."""
from __future__ import division
import numpy as np
import math
import cmath
import time
import pdb
import six
from pvder.utility_classes import Utilities
from pvder.grid_components import Grid
from pvder.simulation_utilities import SimulationUtilities
#from pvder.simulation_utilities_experimental import SimulationUtilitiesExperimental
from pvder import utility_functions
from pvder import defaults,templates
from pvder.logutil import LogUtil
class DynamicSimulation(Grid,SimulationUtilities,Utilities):
""" Utility class for running simulations."""
count = 0
tStart = 0.0
tInc = defaults.DEFAULT_DELTA_T
DEBUG_SOLVER = False
DEBUG_SIMULATION = False
DEBUG_CONTROLLERS = False
DEBUG_VOLTAGES = False
DEBUG_CURRENTS = False
DEBUG_POWER = False
DEBUG_PLL = False
jac_list = ['SolarPVDERThreePhase','SolarPVDERSinglePhase','SolarPVDERThreePhaseBalanced']
def __init__(self,PV_model,events,gridModel = None,tStop = 0.5,
LOOP_MODE = False,COLLECT_SOLUTION = True,jacFlag = False,
verbosity ='INFO',solverType ='odeint',identifier = None):
"""Creates an instance of `GridSimulation`.
Args:
PV_model: An instance of `SolarPV_DER`.
events: An instance of `SimulationEvents`.
grid_model: An instance of `GridModel` (only need to be suppled in stand alone simulation).
tStop: A scalar specifying the end time for simulation.
tInc: A scalar specifying the time step for simulation.
LOOP_MODE: A boolean specifying whether simulation is run in loop.
"""
try:
DynamicSimulation.count = DynamicSimulation.count + 1 #Increment count to keep track of number of simulation instances
self.name_instance(identifier) #Generate a name for the instance
self.tStop = tStop
self.t = self.t_calc()
self.PV_model = PV_model
self.DER_model_type = type(self.PV_model).__name__
self.simulation_events = events
self.simulation_events.del_t_event = self.tInc
self.initialize_solver(solver_type=solverType)
self.SOLVER_CONVERGENCE = False
self.convergence_failure_list =[]
self.LOOP_MODE = LOOP_MODE
self.COLLECT_SOLUTION = COLLECT_SOLUTION
self.jacFlag = jacFlag
self.check_jac_availability()
if self.PV_model.standAlone and gridModel is not None:
self.grid_model = gridModel
elif self.PV_model.standAlone and gridModel is None:
raise ValueError('`Grid` instance need to provided in stand alone mode for creating `GridSimulation` instance!')
#Remove existing simulation events
#self.simulation_events.remove_solar_event(3.0)
#self.simulation_events.remove_load_event(4.0)
#self.simulation_events.remove_grid_event(5.0)
self.solution_time = None #Always reset solution time to None
if self.LOOP_MODE:
self.reset_stored_trajectories()
self.initialize_y0_t()
except:
LogUtil.exception_handler()
@property
def y0(self):
""" Combine all initial conditions from solution."""
try:
if type(self.PV_model).__name__ == 'SolarPVDERThreePhase':
y0 = [self.iaR_t[-1], self.iaI_t[-1], self.xaR_t[-1], self.xaI_t[-1], self.uaR_t[-1],self.uaI_t[-1],\
self.ibR_t[-1], self.ibI_t[-1], self.xbR_t[-1], self.xbI_t[-1], self.ubR_t[-1],self.ubI_t[-1],\
self.icR_t[-1], self.icI_t[-1], self.xcR_t[-1], self.xcI_t[-1], self.ucR_t[-1],self.ucI_t[-1],\
self.Vdc_t[-1],
self.xDC_t[-1],self.xQ_t[-1],
self.xPLL_t[-1],self.wte_t[-1]]
elif type(self.PV_model).__name__ == 'SolarPVDERSinglePhase':
y0 =[self.iaR_t[-1], self.iaI_t[-1], self.xaR_t[-1], self.xaI_t[-1], self.uaR_t[-1],self.uaI_t[-1],\
self.Vdc_t[-1],
self.xDC_t[-1],self.xQ_t[-1],
self.xPLL_t[-1],self.wte_t[-1]]
elif type(self.PV_model).__name__ == 'SolarPVDERSinglePhaseConstantVdc':
y0 =[self.iaR_t[-1], self.iaI_t[-1], self.xaR_t[-1], self.xaI_t[-1], self.uaR_t[-1],self.uaI_t[-1],\
self.xP_t[-1],self.xQ_t[-1],
self.xPLL_t[-1],self.wte_t[-1]]
elif type(self.PV_model).__name__ == 'SolarPVDERThreePhaseConstantVdc':
y0 =[self.iaR_t[-1], self.iaI_t[-1], self.xaR_t[-1], self.xaI_t[-1], self.uaR_t[-1],self.uaI_t[-1],
self.ibR_t[-1], self.ibI_t[-1], self.xbR_t[-1], self.xbI_t[-1], self.ubR_t[-1],self.ubI_t[-1],
self.icR_t[-1], self.icI_t[-1], self.xcR_t[-1], self.xcI_t[-1], self.ucR_t[-1],self.ucI_t[-1],
self.xP_t[-1],self.xQ_t[-1],
self.xPLL_t[-1],self.wte_t[-1]]
elif self.DER_model_type == 'SolarPVDERThreePhaseBalanced':
y0 =[self.iaR_t[-1], self.iaI_t[-1], self.xaR_t[-1], self.xaI_t[-1], self.uaR_t[-1],self.uaI_t[-1],
self.Vdc_t[-1],
self.xDC_t[-1],self.xQ_t[-1],
self.xPLL_t[-1],self.wte_t[-1]]
elif self.DER_model_type == 'SolarPVDERThreePhaseNumba':
y0 = [self.iaR_t[-1], self.iaI_t[-1], self.xaR_t[-1], self.xaI_t[-1], self.uaR_t[-1],self.uaI_t[-1],\
self.ibR_t[-1], self.ibI_t[-1], self.xbR_t[-1], self.xbI_t[-1], self.ubR_t[-1],self.ubI_t[-1],\
self.icR_t[-1], self.icI_t[-1], self.xcR_t[-1], self.xcI_t[-1], self.ucR_t[-1],self.ucI_t[-1],\
self.Vdc_t[-1],
self.xDC_t[-1],self.xQ_t[-1],
self.xPLL_t[-1],self.wte_t[-1]]
return y0
except:
LogUtil.exception_handler()
#@property
def t_calc(self):
"""Vector of time steps for simulation"""
try:
#if (self.tStop - self.tStart) <= self.tInc:
# self.tStop = self.tStart + 1e-6 #+ self.tInc
return np.arange(self.tStart, self.tStop + self.tInc, self.tInc)
except:
LogUtil.exception_handler()
def check_jac_availability(self):
"""Check if Jacobian matrix is available."""
try:
if self.jacFlag:
if not self.DER_model_type in self.jac_list:
raise ValueError('{}:Jacobian matrix is not available for DER model:{}'.format(self.name,self.DER_model_type))
except:
LogUtil.exception_handler()
def initialize_y0_t(self):
"""Initialize y0_t."""
try:
self.iaR_t = np.array([self.PV_model.y0[0]])
self.iaI_t = np.array([self.PV_model.y0[1]])
self.xaR_t = np.array([self.PV_model.y0[2]])
self.xaI_t = np.array([self.PV_model.y0[3]])
self.uaR_t = np.array([self.PV_model.y0[4]])
self.uaI_t = np.array([self.PV_model.y0[5]])
if type(self.PV_model).__name__ == 'SolarPVDERSinglePhase':
self.Vdc_t = np.array([self.PV_model.y0[6]]) #DC link voltage variable
self.xDC_t = np.array([self.PV_model.y0[7]]) #DC link voltage control variable
self.xQ_t = np.array([self.PV_model.y0[8]]) #Reactive power control variable
self.xPLL_t = np.array([self.PV_model.y0[9]]) #PLL variables
self.wte_t = np.array([self.PV_model.y0[10]]) #Frequency integration to get angle
elif (self.DER_model_type == 'SolarPVDERThreePhase') or (self.DER_model_type == 'SolarPVDERThreePhaseNumba'):
self.ibR_t = np.array([self.PV_model.y0[6]])
self.ibI_t = np.array([self.PV_model.y0[7]])
self.xbR_t = np.array([self.PV_model.y0[8]])
self.xbI_t = np.array([self.PV_model.y0[9]])
self.ubR_t = np.array([self.PV_model.y0[10]])
self.ubI_t = np.array([self.PV_model.y0[11]])
self.icR_t = np.array([self.PV_model.y0[12]])
self.icI_t = np.array([self.PV_model.y0[13]])
self.xcR_t = np.array([self.PV_model.y0[14]])
self.xcI_t = np.array([self.PV_model.y0[15]])
self.ucR_t = np.array([self.PV_model.y0[16]])
self.ucI_t = np.array([self.PV_model.y0[17]])
self.Vdc_t = np.array([self.PV_model.y0[18]])
self.xDC_t = np.array([self.PV_model.y0[19]])
self.xQ_t = np.array([self.PV_model.y0[20]])
self.xPLL_t = np.array([self.PV_model.y0[21]])
self.wte_t = np.array([self.PV_model.y0[22]])
elif type(self.PV_model).__name__ == 'SolarPVDERThreePhaseConstantVdc':
self.ibR_t = np.array([self.PV_model.y0[6]])
self.ibI_t = np.array([self.PV_model.y0[7]])
self.xbR_t = np.array([self.PV_model.y0[8]])
self.xbI_t = np.array([self.PV_model.y0[9]])
self.ubR_t = np.array([self.PV_model.y0[10]])
self.ubI_t = np.array([self.PV_model.y0[11]])
self.icR_t = np.array([self.PV_model.y0[12]])
self.icI_t = np.array([self.PV_model.y0[13]])
self.xcR_t = np.array([self.PV_model.y0[14]])
self.xcI_t = np.array([self.PV_model.y0[15]])
self.ucR_t = np.array([self.PV_model.y0[16]])
self.ucI_t = np.array([self.PV_model.y0[17]])
self.Vdc_t = np.array([self.PV_model.Vdc]) #Voltage is constant
self.xP_t = np.array([self.PV_model.y0[18]]) #Active power control variable
self.xQ_t = np.array([self.PV_model.y0[19]]) #Reactive power control variable
self.xPLL_t = np.array([self.PV_model.y0[20]]) #PLL variables
self.wte_t = np.array([self.PV_model.y0[21]]) #Frequency integration to get angle
elif type(self.PV_model).__name__ == 'SolarPVDERThreePhaseBalanced':
ia_t = self.iaR_t+self.iaI_t*1j
xa_t = self.xaR_t+self.xaI_t*1j
ua_t = self.uaR_t+self.uaI_t*1j
ib_t = utility_functions.Ub_calc(ia_t)
xb_t = utility_functions.Ub_calc(xa_t)
ub_t = utility_functions.Ub_calc(ua_t)
ic_t = utility_functions.Uc_calc(ia_t)
xc_t = utility_functions.Uc_calc(xa_t)
uc_t = utility_functions.Uc_calc(ua_t)
self.ibR_t = ib_t.real
self.ibI_t = ib_t.imag
self.xbR_t = xb_t.real
self.xbI_t = xb_t.imag
self.ubR_t = ub_t.real
self.ubI_t = ub_t.imag
self.icR_t = ic_t.real
self.icI_t = ic_t.imag
self.xcR_t = xc_t.real
self.xcI_t = xc_t.imag
self.ucR_t = uc_t.real
self.ucI_t = uc_t.imag
self.Vdc_t = np.array([self.PV_model.y0[6]]) #DC link voltage variable
self.xDC_t = np.array([self.PV_model.y0[7]]) #DC link voltage control variable
self.xQ_t = np.array([self.PV_model.y0[8]]) #Reactive power control variable
self.xPLL_t = np.array([self.PV_model.y0[9]]) #PLL variables
self.wte_t = np.array([self.PV_model.y0[10]]) #Frequency integration to get angle
elif type(self.PV_model).__name__ == 'SolarPVDERSinglePhaseConstantVdc':
self.Vdc_t = np.array([self.PV_model.Vdc]) #Voltage is constant
self.xP_t = np.array([self.PV_model.y0[6]]) #Active power control variable
self.xQ_t = np.array([self.PV_model.y0[7]]) #Reactive power control variable
self.xPLL_t = np.array([self.PV_model.y0[8]]) #PLL variables
self.wte_t = np.array([self.PV_model.y0[9]]) #Frequency integration to get angle
except:
LogUtil.exception_handler()
def reset_stored_trajectories(self):
"""Reset for plotting."""
try:
self._t_t = np.array(0.0)
self.Vdc_t = self._Vdc_t = np.array(self.PV_model.Vdc)
self.ia_t = self._ia_t = np.array(self.PV_model.ia)
self.ma_t = self._ma_t = np.array(self.PV_model.ma)
self.vta_t = self._vta_t = np.array(self.PV_model.vta)
self.va_t = self._va_t = np.array(self.PV_model.va)
self.ma_absolute_t = self._ma_absolute_t = np.array(abs(self.PV_model.ma))
self.Varms_t = self._Varms_t = np.array(abs(self.PV_model.va)/math.sqrt(2))
if type(self.PV_model).__name__ in templates.three_phase_models:
self.mb_absolute_t = self._mb_absolute_t = np.array(abs(self.PV_model.mb))
self.mc_absolute_t = self._mc_absolute_t = np.array(abs(self.PV_model.mc))
self.Vbrms_t = self._Vbrms_t = np.array(abs(self.PV_model.vb)/math.sqrt(2))
self.Vcrms_t = self._Vcrms_t = np.array(abs(self.PV_model.vc)/math.sqrt(2))
self.ib_t = self._ib_t = np.array(self.PV_model.ib)
self.mb_t = self._mb_t = np.array(self.PV_model.mb)
self.vtb_t = self._vtb_t = np.array(self.PV_model.vtb)
self.vb_t = self._vb_t = np.array(self.PV_model.vb)
self.ic_t = self._ic_t = np.array(self.PV_model.ic)
self.mc_t = self._mc_t = np.array(self.PV_model.mc)
self.vtc_t = self._vtc_t = np.array(self.PV_model.vtc)
self.vc_t = self._vc_t = np.array(self.PV_model.vc)
self.Irms_t = self._Irms_t = np.array(self.PV_model.Irms)
self.Ppv_t = self._Ppv_t = np.array(self.PV_model.Ppv)
self.S_PCC_t = self._S_PCC_t = np.array(self.PV_model.S_PCC)
self.S_t = self._S_t = np.array(self.PV_model.S)
self.Vtrms_t = self._Vtrms_t = np.array(self.PV_model.Vtrms)
self.Vrms_t = self._Vrms_t = np.array(self.PV_model.Vrms)
except:
LogUtil.exception_handler()
def ODE_model(self,y,t):
""" Combine all derivatives."""
try:
y1 = y[0:self.PV_model.n_ODE]
if self.PV_model.standAlone:
self.grid_model.steady_state_model(t)
y = self.PV_model.ODE_model(y1,t)
if self.DEBUG_SIMULATION:
self.debug_simulation(t)
return y
except:
LogUtil.exception_handler()
def jac_ODE_model(self,y,t):
""" Combine all derivatives."""
try:
y1 = y[0:self.PV_model.n_ODE]
if self.PV_model.standAlone:
self.grid_model.steady_state_model(t)
y = self.PV_model.jac_ODE_model(y1,t)
return y
except:
LogUtil.exception_handler()
def debug_simulation(self,t):
""" Print to terminal for debugging."""
try:
utility_functions.print_to_terminal('t:{:.4f}'.format(t))
if self.DEBUG_VOLTAGES:
utility_functions.print_to_terminal('Vdc_ref:{:.3f},Vdc:{:.3f},Vat:{:.3f},Va:{:.3f},Vag:{:.3f},Vagrid:{:.3f},Vagrid_setpoint:{:.3f}'. format(self.PV_model.Vdc_ref,self.PV_model.Vdc,self.PV_model.Vtrms,self.PV_model.Vrms,self.grid_model.Vgrms,abs(self.grid_model.Vagrid_no_conversion)/math.sqrt(2),abs(self.grid_model.Vagrid)/math.sqrt(2)))
if self.DEBUG_CURRENTS:
utility_functions.print_to_terminal('ia_ref:{:.3f},ia:{:.3f},iload1:{:.3f}'. format(self.PV_model.ia_ref,self.PV_model.ia,self.PV_model.iaload1))
if self.DEBUG_POWER:
utility_functions.print_to_terminal('Sinsol:{:.3f},Q_ref:{:.3f},Ppv:{:.3f},S:{:.3f},S_PCC:{:.3f},S_load1:{:.3f},S_G:{:.3f}'.format(self.PV_model.Sinsol,self.PV_model.Q_ref,self.PV_model.Ppv,self.PV_model.S,self.PV_model.S_PCC,self.PV_model.S_load1,self.PV_model.S_G))
if self.DEBUG_CONTROLLERS:
utility_functions.print_to_terminal('xDC:{:.3f},xQ:{:.3f},ua:{:.3f},xa:{:.3f},ma:{:.3f}'. format(self.PV_model.xdc,self.PV_model.xQ,self.PV_model.ua,self.PV_model.xa,self.PV_model.ma))
if self.DEBUG_PLL:
utility_functions.print_to_terminal("we:{:.3f}, wte:{:.3f} rad, vd: {:.3f} V, vq {:.3f} V".format(self.PV_model.we,self.PV_model.wte,self.PV_model.vd,self.PV_model.vq))
except:
LogUtil.exception_handler()
def time_series_PCC_HV_side_voltage(self):
"""Calculate time series PCC voltage."""
try:
assert len(self.ia_t) == len(self.vag_t) != None, "States must be available from simulation."
self.vaHV_t = self.vag_t + (self.ia_t/self.PV_model.a)*self.grid_model.Z2 - (self.va_t/self.PV_model.a)*(self.grid_model.Z2/self.Zload1_t)
if type(self.PV_model).__name__ in templates.single_phase_models:
self.vbHV_t = self.vbg_t
self.vcHV_t = self.vcg_t
elif type(self.PV_model).__name__ in templates.three_phase_models:
self.vbHV_t = self.vbg_t + (self.ib_t/self.PV_model.a)*self.grid_model.Z2 - (self.vb_t/self.PV_model.a)*(self.grid_model.Z2/self.Zload1_t)
self.vcHV_t = self.vcg_t + (self.ic_t/self.PV_model.a)*self.grid_model.Z2 - (self.vc_t/self.PV_model.a)*(self.grid_model.Z2/self.Zload1_t)
except:
LogUtil.exception_handler()
def time_series_duty_cycle(self):
"""Calculate time series PCC voltage."""
try:
self.ma_t = utility_functions.m_time_series(self.ua_t,self.xa_t,self.PV_model.Kp_GCC)
self.maR_t = self.ma_t.real
self.maI_t = self.ma_t.imag
self.ma_absolute_t = utility_functions.Uabsolute_time_series(self.ma_t)
if type(self.PV_model).__name__ in templates.three_phase_models:
self.mb_t = utility_functions.m_time_series(self.ub_t,self.xb_t,self.PV_model.Kp_GCC)
self.mc_t = utility_functions.m_time_series(self.uc_t,self.xc_t,self.PV_model.Kp_GCC)
self.mbR_t = self.mb_t.real
self.mbI_t = self.mb_t.imag
self.mcR_t = self.mc_t.real
self.mcI_t = self.mc_t.imag
self.mb_absolute_t = utility_functions.Uabsolute_time_series(self.mb_t)
self.mc_absolute_t = utility_functions.Uabsolute_time_series(self.mc_t)
except:
LogUtil.exception_handler()
def time_series_PCC_LV_side_voltage(self):
"""Calculate time series PCC voltage."""
try:
if self.PV_model.standAlone:
self.va_t = ((self.vag_t+(self.ia_t/self.PV_model.a)*self.grid_model.Z2)/(self.PV_model.a) +self.ia_t*self.PV_model.Z1)*((self.Zload1_t*self.PV_model.a*self.PV_model.a)/((self.PV_model.a*self.PV_model.a*(self.PV_model.Z1+self.Zload1_t))+self.grid_model.Z2))
else:
self.va_t = np.repeat(self.PV_model.gridVoltagePhaseA,len(self.t))
self.vaR_t = self.va_t.real
self.vaI_t = self.va_t.imag
if type(self.PV_model).__name__ in templates.three_phase_models:
if self.PV_model.standAlone:
self.vb_t = ((self.vbg_t+(self.ib_t/self.PV_model.a)*self.grid_model.Z2)/(self.PV_model.a) +self.ib_t*self.PV_model.Z1)*((self.Zload1_t*self.PV_model.a*self.PV_model.a)/((self.PV_model.a*self.PV_model.a*(self.PV_model.Z1+self.Zload1_t))+self.grid_model.Z2))
self.vc_t = ((self.vcg_t+(self.ic_t/self.PV_model.a)*self.grid_model.Z2)/(self.PV_model.a) +self.ic_t*self.PV_model.Z1)*((self.Zload1_t*self.PV_model.a*self.PV_model.a)/((self.PV_model.a*self.PV_model.a*(self.PV_model.Z1+self.Zload1_t))+self.grid_model.Z2))
else:
self.vb_t = np.repeat(self.PV_model.gridVoltagePhaseB,len(self.t))
self.vc_t = np.repeat(self.PV_model.gridVoltagePhaseC,len(self.t))
self.vbR_t = self.vb_t.real
self.vbI_t = self.vb_t.imag
self.vcR_t = self.vc_t.real
self.vcI_t = self.vc_t.imag
except:
LogUtil.exception_handler()
def time_series_inv_terminal_voltage(self):
"""Calculate time series inverter terminal voltage."""
try:
self.vta_t = utility_functions.Vinv_terminal_time_series(self.ma_t,self.Vdc_t)
if type(self.PV_model).__name__ in templates.three_phase_models:
self.vtb_t = utility_functions.Vinv_terminal_time_series(self.mb_t,self.Vdc_t)
self.vtc_t = utility_functions.Vinv_terminal_time_series(self.mc_t,self.Vdc_t)
except:
LogUtil.exception_handler()
def time_series_RMS(self):
"""Calculate time series RMS quantities."""
try:
if type(self.PV_model).__name__ in templates.single_phase_models:
self.Vtrms_t = utility_functions.Urms_time_series(self.vta_t,self.vta_t,self.vta_t)
self.Vrms_t = utility_functions.Urms_time_series(self.va_t,self.va_t,self.va_t)
self.Irms_t = utility_functions.Urms_time_series(self.ia_t,self.ia_t,self.ia_t)
self.Varms_t = self.Vrms_t
elif type(self.PV_model).__name__ in templates.three_phase_models:
self.Vtrms_t = utility_functions.Urms_time_series(self.vta_t,self.vtb_t,self.vtc_t)
self.Vrms_t = utility_functions.Urms_time_series(self.va_t,self.vb_t,self.vc_t)
self.Irms_t = utility_functions.Urms_time_series(self.ia_t,self.ib_t,self.ic_t)
self.Varms_t = utility_functions.Uphrms_time_series(self.va_t)
self.Vbrms_t = utility_functions.Uphrms_time_series(self.vb_t)
self.Vcrms_t = utility_functions.Uphrms_time_series(self.vc_t)
if self.PV_model.standAlone:
self.Vgrms_t = utility_functions.Urms_time_series(self.vag_t,self.vbg_t,self.vcg_t)
self.Vhvrms_t= utility_functions.Urms_time_series(self.vaHV_t,self.vbHV_t,self.vcHV_t)
except:
LogUtil.exception_handler()
def time_series_standalone_grid(self):
"""Time series grid voltage and frequency for standalone model."""
try:
self.vag_t = []
self.vbg_t = []
self.vcg_t = []
self.wgrid_t = []
for i,t in enumerate(self.t): #Loop through grid events and calculate wgrid at each time step
Vagrid_new,self.grid_model.wgrid = self.simulation_events.grid_events(t)
#Conversion of grid voltage setpoint
self.grid_model.vag = Vagrid_new*(self.grid_model.Vgridrated/self.Vbase)
self.grid_model.vbg = utility_functions.Ub_calc(self.grid_model.vag*self.grid_model.unbalance_ratio_b)
self.grid_model.vcg = utility_functions.Uc_calc(self.grid_model.vag*self.grid_model.unbalance_ratio_c)
self.vag_t.append(self.grid_model.vag)
self.vbg_t.append(self.grid_model.vbg)
self.vcg_t.append(self.grid_model.vcg)
self.wgrid_t.append(self.grid_model.wgrid)
self.vag_t = np.asarray(self.vag_t)
self.vbg_t = | np.asarray(self.vbg_t) | numpy.asarray |
from sklearn.metrics.pairwise import rbf_kernel
from scipy.stats import ks_2samp
from scipy.stats import wilcoxon
import numpy as np
import random
from scipy import stats
import time
from collections import defaultdict
import numpy as np
import warnings
from scipy.stats import rankdata
def same(x):
return x
def cube(x):
return np.power(x, 3)
def negexp(x):
return np.exp(-np.abs(x))
def generate_samples_random(size=1000, sType='CI', dx=1, dy=1, dz=20, nstd=1, fixed_function='linear',
debug=False, normalize = True, seed = None, dist_z = 'gaussian'):
'''Generate CI,I or NI post-nonlinear samples
1. Z is independent Gaussian or Laplace
2. X = f1(<a,Z> + b + noise) and Y = f2(<c,Z> + d + noise) in case of CI
Arguments:
size : number of samples
sType: CI, I, or NI
dx: Dimension of X
dy: Dimension of Y
dz: Dimension of Z
nstd: noise standard deviation
f1, f2 to be within {x,x^2,x^3,tanh x, e^{-|x|}, cos x}
Output:
Samples X, Y, Z
'''
if seed == None:
np.random.seed()
else:
np.random.seed(seed)
if fixed_function == 'linear':
f1 = same
f2 = same
else:
I1 = random.randint(2, 6)
I2 = random.randint(2, 6)
if I1 == 2:
f1 = np.square
elif I1 == 3:
f1 = cube
elif I1 == 4:
f1 = np.tanh
elif I1 == 5:
f1 = negexp
else:
f1 = np.cos
if I2 == 2:
f2 = np.square
elif I2 == 3:
f2 = cube
elif I2 == 4:
f2 = np.tanh
elif I2 == 5:
f2 = negexp
else:
f2 = np.cos
if debug:
print(f1, f2)
num = size
if dist_z =='gaussian':
cov = np.eye(dz)
mu = np.ones(dz)
Z = np.random.multivariate_normal(mu, cov, num)
Z = np.matrix(Z)
elif dist_z == 'laplace':
Z = np.random.laplace(loc=0.0, scale=1.0, size=num*dz)
Z = np.reshape(Z,(num,dz))
Z = np.matrix(Z)
Ax = np.random.rand(dz, dx)
for i in range(dx):
Ax[:, i] = Ax[:, i] / np.linalg.norm(Ax[:, i], ord=1)
Ax = np.matrix(Ax)
Ay = np.random.rand(dz, dy)
for i in range(dy):
Ay[:, i] = Ay[:, i] / np.linalg.norm(Ay[:, i], ord=1)
Ay = np.matrix(Ay)
Axy = np.random.rand(dx, dy)
for i in range(dy):
Axy[:, i] = Axy[:, i] / np.linalg.norm(Axy[:, i], ord=1)
Axy = np.matrix(Axy)
temp = Z * Ax
m = np.mean(np.abs(temp))
nstd = nstd * m
if sType == 'CI':
X = f1(Z * Ax + nstd * np.random.multivariate_normal(np.zeros(dx), np.eye(dx), num))
Y = f2(Z * Ay + nstd * np.random.multivariate_normal(np.zeros(dy), np.eye(dy), num))
elif sType == 'I':
X = f1(nstd * np.random.multivariate_normal(np.zeros(dx), np.eye(dx), num))
Y = f2(nstd * np.random.multivariate_normal(np.zeros(dy), np.eye(dy), num))
else:
X = np.random.multivariate_normal(np.zeros(dx), np.eye(dx), num)
Y = f2(2 * X * Axy + Z * Ay)
if normalize == True:
Z = (Z - Z.min()) / (Z.max() - Z.min())
X = (X - X.min()) / (X.max() - X.min())
Y = (Y - Y.min()) / (Y.max() - Y.min())
return np.array(X), np.array(Y), np.array(Z)
def pc_ks(pvals):
""" Compute the area under power curve and the Kolmogorov-Smirnoff
test statistic of the hypothesis that pvals come from the uniform
distribution with support (0, 1).
"""
if pvals.size == 0:
return [-1, -1]
if -1 in pvals or -2 in pvals:
return [-1, -1]
pvals = np.sort(pvals)
cdf = ecdf(pvals)
auc = 0
for (pv1, pv2) in zip(pvals[:-1], pvals[1:]):
auc += integrate.quad(cdf, pv1, pv2)[0]
auc += integrate.quad(cdf, pvals[-1], 1)[0]
_, ks = kstest(pvals, 'uniform')
return auc, ks
def np2r(x):
""" Convert a numpy array to an R matrix.
Args:
x (dim0, dim1): A 2d numpy array.
Returns:
x_r: An rpy2 object representing an R matrix isometric to x.
"""
if 'rpy2' not in sys.modules:
raise ImportError(("rpy2 is not installed.",
" Cannot convert a numpy array to an R vector."))
try:
dim0, dim1 = x.shape
except IndexError:
raise IndexError("Only 2d arrays are supported")
return R.r.matrix(R.FloatVector(x.flatten()), nrow=dim0, ncol=dim1)
def fdr(truth, pred, axis=None):
""" Computes False discovery rate
"""
return ((pred==1) & (truth==0)).sum(axis=axis) / pred.sum(axis=axis).astype(float).clip(1,np.inf)
def tpr(truth, pred, axis=None):
""" Computes true positive rate
"""
return ((pred==1) & (truth==1)).sum(axis=axis) / truth.sum(axis=axis).astype(float).clip(1,np.inf)
def true_positives(truth, pred, axis=None):
""" Computes number of true positive
"""
return ((pred==1) & (truth==1)).sum(axis=axis)
def false_positives(truth, pred, axis=None):
""" Computes number of false positive
"""
return ((pred==1) & (truth==0)).sum(axis=axis)
def bh(p, fdr):
""" From vector of p-values and desired false positive rate,
returns significant p-values with Benjamini-Hochberg correction
"""
p_orders = np.argsort(p)
discoveries = []
m = float(len(p_orders))
for k, s in enumerate(p_orders):
if p[s] <= (k+1) / m * fdr:
discoveries.append(s)
else:
break
return np.array(discoveries, dtype=int)
def mmd_squared(X, Y, gamma = 1):
X = X.reshape((len(X)), 1)
Y = Y.reshape((len(Y)), 1)
K_XX = rbf_kernel(X, gamma=gamma)
K_YY = rbf_kernel(Y, gamma=gamma)
K_XY = rbf_kernel(X, Y, gamma=gamma)
n = K_XX.shape[0]
m = K_YY.shape[0]
mmd_squared = (np.sum(K_XX)-np.trace(K_XX))/(n*(n-1)) + (np.sum(K_YY)-np.trace(K_YY))/(m*(m-1)) - 2 * | np.sum(K_XY) | numpy.sum |
import os
import numpy as np
import tensorflow as tf
import cv2
import time
import sys
import pickle
import ROLO_utils as util
class YOLO_TF:
fromfile = None
tofile_img = 'test/output.jpg'
tofile_txt = 'test/output.txt'
imshow = True
filewrite_img = False
filewrite_txt = False
disp_console = True
weights_file = '/home/marc/ROLO/3rd\ party_upgrade/weights/YOLO_small.ckpt'
alpha = 0.1
threshold = 0.08
iou_threshold = 0.5
num_class = 20
num_box = 2
grid_size = 7
classes = ["aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
"dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]
w_img, h_img = [352, 240]
num_feat = 4096
num_predict = 6 # final output of LSTM 6 loc parameters
num_heatmap = 1024
def __init__(self, argvs=[]):
self.argv_parser(argvs)
self.build_networks()
if self.fromfile is not None: self.detect_from_file(self.fromfile)
def argv_parser(self, argvs):
for i in range(1, len(argvs), 2):
if argvs[i] == '-fromfile': self.fromfile = argvs[i + 1]
if argvs[i] == '-tofile_img': self.tofile_img = argvs[i + 1]; self.filewrite_img = True
if argvs[i] == '-tofile_txt': self.tofile_txt = argvs[i + 1]; self.filewrite_txt = True
if argvs[i] == '-imshow':
if argvs[i + 1] == '1':
self.imshow = True
else:
self.imshow = False
if argvs[i] == '-disp_console':
if argvs[i + 1] == '1':
self.disp_console = True
else:
self.disp_console = False
def build_networks(self):
if self.disp_console: print("Building YOLO_small graph...")
self.x = tf.placeholder('float32', [None, 448, 448, 3])
self.conv_1 = self.conv_layer(1, self.x, 64, 7, 2)
self.pool_2 = self.pooling_layer(2, self.conv_1, 2, 2)
self.conv_3 = self.conv_layer(3, self.pool_2, 192, 3, 1)
self.pool_4 = self.pooling_layer(4, self.conv_3, 2, 2)
self.conv_5 = self.conv_layer(5, self.pool_4, 128, 1, 1)
self.conv_6 = self.conv_layer(6, self.conv_5, 256, 3, 1)
self.conv_7 = self.conv_layer(7, self.conv_6, 256, 1, 1)
self.conv_8 = self.conv_layer(8, self.conv_7, 512, 3, 1)
self.pool_9 = self.pooling_layer(9, self.conv_8, 2, 2)
self.conv_10 = self.conv_layer(10, self.pool_9, 256, 1, 1)
self.conv_11 = self.conv_layer(11, self.conv_10, 512, 3, 1)
self.conv_12 = self.conv_layer(12, self.conv_11, 256, 1, 1)
self.conv_13 = self.conv_layer(13, self.conv_12, 512, 3, 1)
self.conv_14 = self.conv_layer(14, self.conv_13, 256, 1, 1)
self.conv_15 = self.conv_layer(15, self.conv_14, 512, 3, 1)
self.conv_16 = self.conv_layer(16, self.conv_15, 256, 1, 1)
self.conv_17 = self.conv_layer(17, self.conv_16, 512, 3, 1)
self.conv_18 = self.conv_layer(18, self.conv_17, 512, 1, 1)
self.conv_19 = self.conv_layer(19, self.conv_18, 1024, 3, 1)
self.pool_20 = self.pooling_layer(20, self.conv_19, 2, 2)
self.conv_21 = self.conv_layer(21, self.pool_20, 512, 1, 1)
self.conv_22 = self.conv_layer(22, self.conv_21, 1024, 3, 1)
self.conv_23 = self.conv_layer(23, self.conv_22, 512, 1, 1)
self.conv_24 = self.conv_layer(24, self.conv_23, 1024, 3, 1)
self.conv_25 = self.conv_layer(25, self.conv_24, 1024, 3, 1)
self.conv_26 = self.conv_layer(26, self.conv_25, 1024, 3, 2)
self.conv_27 = self.conv_layer(27, self.conv_26, 1024, 3, 1)
self.conv_28 = self.conv_layer(28, self.conv_27, 1024, 3, 1)
self.fc_29 = self.fc_layer(29, self.conv_28, 512, flat=True, linear=False)
self.fc_30 = self.fc_layer(30, self.fc_29, 4096, flat=False, linear=False)
# skip dropout_31
self.fc_32 = self.fc_layer(32, self.fc_30, 1470, flat=False, linear=True)
self.sess = tf.Session()
self.sess.run(tf.initialize_all_variables())
self.saver = tf.train.Saver()
self.saver.restore(self.sess, self.weights_file)
if self.disp_console: print("Loading complete!" + '\n')
def conv_layer(self, idx, inputs, filters, size, stride):
channels = inputs.get_shape()[3]
weight = tf.Variable(tf.truncated_normal([size, size, int(channels), filters], stddev=0.1))
biases = tf.Variable(tf.constant(0.1, shape=[filters]))
pad_size = size // 2
pad_mat = np.array([[0, 0], [pad_size, pad_size], [pad_size, pad_size], [0, 0]])
inputs_pad = tf.pad(inputs, pad_mat)
conv = tf.nn.conv2d(inputs_pad, weight, strides=[1, stride, stride, 1], padding='VALID',
name=str(idx) + '_conv')
conv_biased = tf.add(conv, biases, name=str(idx) + '_conv_biased')
if self.disp_console: print(
' Layer %d : Type = Conv, Size = %d * %d, Stride = %d, Filters = %d, Input channels = %d' % (
idx, size, size, stride, filters, int(channels)))
return tf.maximum(self.alpha * conv_biased, conv_biased, name=str(idx) + '_leaky_relu')
def pooling_layer(self, idx, inputs, size, stride):
if self.disp_console: print(
' Layer %d : Type = Pool, Size = %d * %d, Stride = %d' % (idx, size, size, stride))
return tf.nn.max_pool(inputs, ksize=[1, size, size, 1], strides=[1, stride, stride, 1], padding='SAME',
name=str(idx) + '_pool')
def fc_layer(self, idx, inputs, hiddens, flat=False, linear=False):
input_shape = inputs.get_shape().as_list()
if flat:
dim = input_shape[1] * input_shape[2] * input_shape[3]
inputs_transposed = tf.transpose(inputs, (0, 3, 1, 2))
inputs_processed = tf.reshape(inputs_transposed, [-1, dim])
else:
dim = input_shape[1]
inputs_processed = inputs
weight = tf.Variable(tf.truncated_normal([dim, hiddens], stddev=0.1))
biases = tf.Variable(tf.constant(0.1, shape=[hiddens]))
if self.disp_console: print(
' Layer %d : Type = Full, Hidden = %d, Input dimension = %d, Flat = %d, Activation = %d' % (
idx, hiddens, int(dim), int(flat), 1 - int(linear)))
if linear: return tf.add(tf.matmul(inputs_processed, weight), biases, name=str(idx) + '_fc')
ip = tf.add(tf.matmul(inputs_processed, weight), biases)
return tf.maximum(self.alpha * ip, ip, name=str(idx) + '_fc')
def detect_from_cvmat(self, img):
s = time.time()
self.h_img, self.w_img, _ = img.shape
img_resized = cv2.resize(img, (448, 448))
img_RGB = cv2.cvtColor(img_resized, cv2.COLOR_BGR2RGB)
img_resized_np = np.asarray(img_RGB)
inputs = np.zeros((1, 448, 448, 3), dtype='float32')
inputs[0] = (img_resized_np / 255.0) * 2.0 - 1.0
in_dict = {self.x: inputs}
net_output = self.sess.run(self.fc_32, feed_dict=in_dict)
self.result = self.interpret_output(net_output[0])
self.show_results(img, self.result)
strtime = str(time.time() - s)
if self.disp_console: print('Elapsed time : ' + strtime + ' secs' + '\n')
def detect_from_file(self, filename):
if self.disp_console: print('Detect from ' + filename)
img = cv2.imread(filename)
# img = misc.imread(filename)
self.detect_from_cvmat(img)
def detect_from_crop_sample(self):
self.w_img = 640
self.h_img = 420
f = np.array(open('person_crop.txt', 'r').readlines(), dtype='float32')
inputs = np.zeros((1, 448, 448, 3), dtype='float32')
for c in range(3):
for y in range(448):
for x in range(448):
inputs[0, y, x, c] = f[c * 448 * 448 + y * 448 + x]
in_dict = {self.x: inputs}
net_output = self.sess.run(self.fc_32, feed_dict=in_dict)
self.boxes, self.probs = self.interpret_output(net_output[0])
img = cv2.imread('person.jpg')
self.show_results(self.boxes, img)
def interpret_output(self, output):
probs = np.zeros((7, 7, 2, 20))
class_probs = np.reshape(output[0:980], (7, 7, 20))
scales = np.reshape(output[980:1078], (7, 7, 2))
boxes = | np.reshape(output[1078:], (7, 7, 2, 4)) | numpy.reshape |
import math
import numpy as np
import matplotlib.pyplot as plt
def sigmoid(x):
return 1 / (1 + math.exp(-x))
# Function to know if we have a CCW turn
def CCW(p1, p2, p3):
if (p3[1]-p1[1])*(p2[0]-p1[0]) >= (p2[1]-p1[1])*(p3[0]-p1[0]):
return True
return False
# Main function:
def create_convex_hull(S):
"""takes in an [np array] of points!
and return a convex hull
"""
n = len(S)
P = [None] * n
l = np.where(S[:,0] == np.min(S[:,0]))
pointOnHull = S[l[0][0]]
i = 0
while True:
P[i] = pointOnHull
endpoint = S[0]
for j in range(1,n):
if (endpoint[0] == pointOnHull[0] and endpoint[1] == pointOnHull[1]) or not CCW(S[j],P[i],endpoint):
endpoint = S[j]
i = i + 1
pointOnHull = endpoint
if endpoint[0] == P[0][0] and endpoint[1] == P[0][1]:
break
for i in range(n):
if P[-1] is None:
del P[-1]
return np.array(P)
def euclidean_dist(pos1, pos2):
return math.sqrt((pos1[0] - pos2[0]) ** 2 + (pos1[1] - pos2[1]) ** 2)
def compute_centroid(vertices):
"""
helper function:
input:
vertices: a list of vertices of a polygon
under the assumption that all vertices are ordered either clockwise/counterclockwise
output:
centroid: position of (x, y) tuple of the polygon relative to the local origin of polygon.
"""
c_x = 0
c_y = 0
area = 0
n = len(vertices)
for i in range(n):
curr = vertices[(i - n) % n]
next = vertices[(i + 1 - n) % n]
diff = (curr[0] * next[1] - curr[1] * next[0])
c_x += (curr[0] + next[0]) * diff
c_y += (curr[1] + next[1]) * diff
area += diff
area = area / 2
c_x = c_x / (6 * area)
c_y = c_y / (6 * area)
return c_x, c_y
def compute_area(vertices):
"""
helper function:
input:
vertices: a list of vertices of a polygon
under the assumption that all vertices are ordered either clockwise/counterclockwise
output:
centroid: position of (x, y) tuple of the polygon relative to the local origin of polygon.
"""
c_x = 0
c_y = 0
area = 0
n = len(vertices)
for i in range(n):
curr = vertices[(i - n) % n]
next = vertices[(i + 1 - n) % n]
diff = (curr[0] * next[1] - curr[1] * next[0])
c_x += (curr[0] + next[0]) * diff
c_y += (curr[1] + next[1]) * diff
area += diff
area = area / 2
return abs(area)
def normalize(vector):
"""
helper function:
input:
vector: (x, y) force vector
output:
vector: (x, y) force vector with normalized magnitude 1
"""
mag = math.sqrt(vector[0] ** 2 + vector[1] ** 2)+1e-6
return vector[0] / mag, vector[1] / mag
def normalize_vector(x, eps=1e-9):
mean = np.mean(x)
std = np.std(x)
x = (x - mean)/(std+eps)
return x
def side_of_point_on_line(start_pt, end_pt, query_pt):
det = (end_pt[0] - start_pt[0]) * (query_pt[1] - start_pt[1]) - (end_pt[1] - start_pt[1]) * (query_pt[0] - start_pt[0])
if det > 0:
return 1
elif det < 0:
return -1
else:
return 0
def pointToLineDistance(e1, e2, p1):
numerator = np.abs((e2[1] - e1[1])*p1[0] - (e2[0] - e1[0])*p1[1] + e2[0]*e1[1] - e1[0]*e2[1])
normalization = np.sqrt((e2[1] - e1[1])**2 + (e2[0] - e1[0])**2)
return numerator/normalization
def scalarProject(start_pt, end_pt, point):
a = np.array(point) - np.array(start_pt)
unit_b = normalize(np.array(end_pt) - np.array(start_pt))
return a[0]*unit_b[0]+a[1]*unit_b[1]
def projectedPtToStartDistance(e1, e2, p1):
d1 = pointToLineDistance(e1, e2, p1)
d2 = euclidean_dist(e1, p1)
if abs(d1) > abs(d2):
return None
return math.sqrt(d2 ** 2 - d1 ** 2)
def two_line_intersect(e1, e2, e3, e4):
denom = (e1[0]-e2[0])*(e3[1]-e4[1]) - (e1[1]-e2[1])*(e3[0]-e4[0])
f1 = (e1[0]*e2[1] - e1[1]*e2[0])
f2 = (e3[0]*e4[1] - e3[1]*e4[0])
if denom == 0:
return None
pt = ((f1*(e3[0] - e4[0]) - f2 * (e1[0] - e2[0])) / (denom+1e-6), (f1*(e3[1] - e4[1]) - f2 * (e1[1] - e2[1]))/(denom+1e-6))
kap = np.dot(np.array(pt) - np.array(e3), np.array(e4) - np.array(e3))
kab = np.dot(np.array(e4) - np.array(e3), np.array(e4) - np.array(e3))
if kap > kab or kap < 0:
return None
else:
return pt
# return pt
def find_max_contact_range(vertices, e1, e2):
p = np.array(e1) - np.array(e2)
vector = (1, -(p[0] / (p[1] + 1e-6)))
# print(vector)
max_contact_range = 0
start_pt = None
max_dist = 0
for i in range(len(vertices)):
dist = pointToLineDistance(e1, e2, vertices[i])
if dist > max_dist:
max_dist = dist
start_pt = vertices[i]
# print(start_pt)
if not start_pt is None:
end_pt = np.array(start_pt) + np.array(vector)
start_pt = np.array(start_pt) - np.array(vector)
intersect_list = set()
for j in range(len(vertices)):
intersect = two_line_intersect(start_pt, end_pt, vertices[j], vertices[(j + 1) % len(vertices)])
# print(vertices[j], vertices[(j + 1) % len(vertices)])
# print(intersect)
if not intersect is None:
add = True
for pt in intersect_list:
if euclidean_dist(pt, intersect) < 0.01:
add = False
if add:
intersect_list.add(intersect)
# print(intersect_list)
if len(intersect_list) == 2:
# print(intersect_list)
intersect_list = list(intersect_list)
contact_range = euclidean_dist(intersect_list[0], intersect_list[1])
if contact_range > max_contact_range:
max_contact_range = contact_range
# for i in range(len(vertices)):
# perp_end_pt = np.array(vertices[i]) + np.array(vector)
# intersect_list = []
# for j in range(len(vertices)):
# intersect = two_line_intersect(vertices[i], perp_end_pt, vertices[j], vertices[(j + 1) % len(vertices)])
# if not intersect is None:
# intersect_list.append(intersect)
# print(intersect_list)
# if len(intersect_list) == 2:
# # print(intersect_list)
# contact_range = euclidean_dist(intersect_list[0], intersect_list[1])
# if contact_range > max_contact_range:
# max_contact_range = contact_range
return max_contact_range, list(intersect_list)
def find_collision_dist_convex_hull(start_pt, vector, centroid, vertices):
abs_vertices = np.array(vertices) + np.array(centroid)
end_pt = np.array(start_pt) + np.array(vector)
dist = 1e2
for i in range(len(vertices)):
intersect = two_line_intersect(start_pt, end_pt, abs_vertices[i], abs_vertices[(i + 1) % len(abs_vertices)])
if not intersect is None:
if ( | np.array(intersect) | numpy.array |
import sys
import csv
from datetime import datetime
import random
import numpy as np
import scipy.spatial
import math
from itertools import combinations
# CONSTS
MAX_ITERATIONS = 15
TYPE_FIXED_NUMBER_OF_ITERATIONS = 99
TYPE_RANDOM_CHOICE = 100
METHOD_C_INDEX = 500
METHOD_DUNN_INDEX = 501
# CONFIGURATION OF PROGRAM
TERMINATION_CRITERIA = TYPE_FIXED_NUMBER_OF_ITERATIONS
ALGORITHM_INITIAL_CLUSTERS = TYPE_RANDOM_CHOICE
def load_data(filename):
with open(filename, 'r') as f:
reader = csv.reader(f)
data = list(reader)
matrix = np.array(data, dtype = int)
# separate labels from samples
samples = matrix[:,1:]
labels = matrix[:,0]
return labels, samples
def print_indent(text, indent, indent_char='\t'):
print('{indent}{text}'.format(indent=indent*indent_char, text=text))
sys.stdout.flush()
def k_means(train_set, k):
"""
:return: clustering [C_1,...,C_k]
"""
assert(k > 0)
k_cluster_centers = choose_cluster_centers(train_set, k, ALGORITHM_INITIAL_CLUSTERS)
k_clusters = {}
termination_dict = {}
while True:
dist = scipy.spatial.distance.cdist(train_set, k_cluster_centers) # uses euclidean
# for each xi, assign it to nearest center
cluster_ids = np.argmin(dist, axis=1)
for i in range(0, k): # for each cluster
xi_indices = | np.where(cluster_ids == i) | numpy.where |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""Sweep plotting functions."""
import matplotlib.lines as lines
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np
import pycls.models.regnet as regnet
from pycls.sweep.analysis import get_info, get_vals, sort_sweep
# Global color scheme and fill color
_COLORS, _COLOR_FILL = [], []
def set_plot_style():
"""Sets default plotting styles for all plots."""
plt.rcParams["figure.figsize"] = [3.0, 2]
plt.rcParams["axes.linewidth"] = 1
plt.rcParams["axes.grid"] = True
plt.rcParams["grid.alpha"] = 0.4
plt.rcParams["xtick.bottom"] = False
plt.rcParams["ytick.left"] = False
plt.rcParams["legend.edgecolor"] = "0.3"
plt.rcParams["axes.xmargin"] = 0.025
plt.rcParams["lines.linewidth"] = 1.25
plt.rcParams["lines.markersize"] = 5.0
plt.rcParams["font.size"] = 10
plt.rcParams["axes.titlesize"] = 10
plt.rcParams["legend.fontsize"] = 8
plt.rcParams["legend.title_fontsize"] = 8
plt.rcParams["xtick.labelsize"] = 7
plt.rcParams["ytick.labelsize"] = 7
def set_colors(colors=None):
"""Sets the global color scheme (colors should be a list of rgb float values)."""
global _COLORS
default_colors = [
[0.000, 0.447, 0.741],
[0.850, 0.325, 0.098],
[0.929, 0.694, 0.125],
[0.494, 0.184, 0.556],
[0.466, 0.674, 0.188],
[0.301, 0.745, 0.933],
[0.635, 0.078, 0.184],
[0.300, 0.300, 0.300],
[0.600, 0.600, 0.600],
[1.000, 0.000, 0.000],
]
colors = default_colors if colors is None else colors
colors, n = np.array(colors), len(colors)
err_str = "Invalid colors list: {}".format(colors)
assert ((colors >= 0) & (colors <= 1)).all() and colors.shape[1] == 3, err_str
_COLORS = np.tile(colors, (int(np.ceil((10000 / n))), 1)).reshape((-1, 3))
def set_color_fill(color_fill=None):
"""Sets the global color fill (color should be a set of rgb float values)."""
global _COLOR_FILL
_COLOR_FILL = [0.000, 0.447, 0.741] if color_fill is None else color_fill
def get_color(ind=(), scale=1, dtype=float):
"""Gets color (or colors) referenced by index (or indices)."""
return | np.ndarray.astype(_COLORS[ind] * scale, dtype) | numpy.ndarray.astype |
# BSD 3-Clause License; see https://github.com/jpivarski/awkward-1.0/blob/master/LICENSE
from __future__ import absolute_import
import numpy
import awkward1._util
import awkward1._connect._numpy
import awkward1.layout
import awkward1.operations.convert
def count(array, axis=None, keepdims=False, maskidentity=False):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 1:
return xs[0]
else:
return xs[0] + reduce(xs[1:])
return reduce([numpy.size(x) for x in awkward1._util.completely_flatten(layout)])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.count(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
@awkward1._connect._numpy.implements(numpy.count_nonzero)
def count_nonzero(array, axis=None, keepdims=False, maskidentity=False):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 1:
return xs[0]
else:
return xs[0] + reduce(xs[1:])
return reduce([numpy.count_nonzero(x) for x in awkward1._util.completely_flatten(layout)])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.count_nonzero(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
@awkward1._connect._numpy.implements(numpy.sum)
def sum(array, axis=None, keepdims=False, maskidentity=False):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 1:
return xs[0]
else:
return xs[0] + reduce(xs[1:])
return reduce([numpy.sum(x) for x in awkward1._util.completely_flatten(layout)])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.sum(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
@awkward1._connect._numpy.implements(numpy.prod)
def prod(array, axis=None, keepdims=False, maskidentity=False):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 1:
return xs[0]
else:
return xs[0] * reduce(xs[1:])
return reduce([numpy.prod(x) for x in awkward1._util.completely_flatten(layout)])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.prod(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
@awkward1._connect._numpy.implements(numpy.any)
def any(array, axis=None, keepdims=False, maskidentity=False):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 1:
return xs[0]
else:
return xs[0] or reduce(xs[1:])
return reduce([numpy.any(x) for x in awkward1._util.completely_flatten(layout)])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.any(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
@awkward1._connect._numpy.implements(numpy.all)
def all(array, axis=None, keepdims=False, maskidentity=False):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 1:
return xs[0]
else:
return xs[0] and reduce(xs[1:])
return reduce([numpy.all(x) for x in awkward1._util.completely_flatten(layout)])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.all(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
@awkward1._connect._numpy.implements(numpy.min)
def min(array, axis=None, keepdims=False, maskidentity=True):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 0:
return None
elif len(xs) == 1:
return xs[0]
else:
x, y = xs[0], reduce(xs[1:])
return x if x < y else y
tmp = awkward1._util.completely_flatten(layout)
return reduce([numpy.min(x) for x in tmp if len(x) > 0])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.min(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
@awkward1._connect._numpy.implements(numpy.max)
def max(array, axis=None, keepdims=False, maskidentity=True):
layout = awkward1.operations.convert.tolayout(array, allowrecord=False, allowother=False)
if axis is None:
def reduce(xs):
if len(xs) == 0:
return None
elif len(xs) == 1:
return xs[0]
else:
x, y = xs[0], reduce(xs[1:])
return x if x > y else y
tmp = awkward1._util.completely_flatten(layout)
return reduce([numpy.max(x) for x in tmp if len(x) > 0])
else:
behavior = awkward1._util.behaviorof(array)
return awkward1._util.wrap(layout.max(axis=axis, mask=maskidentity, keepdims=keepdims), behavior)
### The following are not strictly reducers, but are defined in terms of reducers and ufuncs.
def moment(x, n, weight=None, axis=None, keepdims=False):
with numpy.errstate(invalid="ignore"):
if weight is None:
sumw = count(x, axis=axis, keepdims=keepdims)
sumwxn = sum(x**n, axis=axis, keepdims=keepdims)
else:
sumw = sum(x*0 + weight, axis=axis, keepdims=keepdims)
sumwxn = sum((x*weight)**n, axis=axis, keepdims=keepdims)
return numpy.true_divide(sumwxn, sumw)
@awkward1._connect._numpy.implements(numpy.mean)
def mean(x, weight=None, axis=None, keepdims=False):
with numpy.errstate(invalid="ignore"):
if weight is None:
sumw = count(x, axis=axis, keepdims=keepdims)
sumwx = sum(x, axis=axis, keepdims=keepdims)
else:
sumw = sum(x*0 + weight, axis=axis, keepdims=keepdims)
sumwx = sum(x*weight, axis=axis, keepdims=keepdims)
return numpy.true_divide(sumwx, sumw)
@awkward1._connect._numpy.implements(numpy.var)
def var(x, weight=None, ddof=0, axis=None, keepdims=False):
with numpy.errstate(invalid="ignore"):
xmean = mean(x, weight=weight, axis=axis, keepdims=keepdims)
if weight is None:
sumw = count(x, axis=axis, keepdims=keepdims)
sumwxx = sum((x - xmean)**2, axis=axis, keepdims=keepdims)
else:
sumw = sum(x*0 + weight, axis=axis, keepdims=keepdims)
sumwxx = sum((x - xmean)**2 * weight, axis=axis, keepdims=keepdims)
if ddof != 0:
return numpy.true_divide(sumwxx, sumw) * numpy.true_divide(sumw, sumw - ddof)
else:
return numpy.true_divide(sumwxx, sumw)
@awkward1._connect._numpy.implements(numpy.std)
def std(x, weight=None, ddof=0, axis=None, keepdims=False):
with numpy.errstate(invalid="ignore"):
return numpy.sqrt(var(x, weight=weight, ddof=ddof, axis=axis, keepdims=keepdims))
def covar(x, y, weight=None, axis=None, keepdims=False):
with numpy.errstate(invalid="ignore"):
xmean = mean(x, weight=weight, axis=axis, keepdims=keepdims)
ymean = mean(y, weight=weight, axis=axis, keepdims=keepdims)
if weight is None:
sumw = count(x, axis=axis, keepdims=keepdims)
sumwxy = sum((x - xmean)*(y - ymean), axis=axis, keepdims=keepdims)
else:
sumw = sum(x*0 + weight, axis=axis, keepdims=keepdims)
sumwxy = sum((x - xmean)*(y - ymean)*weight, axis=axis, keepdims=keepdims)
return numpy.true_divide(sumwxy, sumw)
def corr(x, y, weight=None, axis=None, keepdims=False):
with numpy.errstate(invalid="ignore"):
xmean = mean(x, weight=weight, axis=axis, keepdims=keepdims)
ymean = mean(y, weight=weight, axis=axis, keepdims=keepdims)
xdiff = x - xmean
ydiff = y - ymean
if weight is None:
sumwxx = sum(xdiff**2, axis=axis, keepdims=keepdims)
sumwyy = sum(ydiff**2, axis=axis, keepdims=keepdims)
sumwxy = sum(xdiff*ydiff, axis=axis, keepdims=keepdims)
else:
sumwxx = sum((xdiff**2)*weight, axis=axis, keepdims=keepdims)
sumwyy = sum((ydiff**2)*weight, axis=axis, keepdims=keepdims)
sumwxy = sum((xdiff*ydiff)*weight, axis=axis, keepdims=keepdims)
return numpy.true_divide(sumwxy, | numpy.sqrt(sumwxx * sumwyy) | numpy.sqrt |
"""
Test Surrogates Overview
========================
"""
# Author: <NAME> <<EMAIL>>
# License: new BSD
from PIL import Image
import numpy as np
import scripts.surrogates_overview as exo
import scripts.image_classifier as imgclf
import sklearn.datasets
import sklearn.linear_model
SAMPLES = 10
BATCH = 50
SAMPLE_IRIS = False
IRIS_SAMPLES = 50000
def test_bilmey_image():
"""Tests surrogate image bLIMEy."""
# Load the image
doggo_img = Image.open('surrogates_overview/img/doggo.jpg')
doggo_array = np.array(doggo_img)
# Load the classifier
clf = imgclf.ImageClassifier()
explain_classes = [('tennis ball', 852),
('golden retriever', 207),
('Labrador retriever', 208)]
# Configure widgets to select occlusion colour, segmentation granularity
# and explained class
colour_selection = {
i: i for i in ['mean', 'black', 'white', 'randomise-patch', 'green']
}
granularity_selection = {'low': 13, 'medium': 30, 'high': 50}
# Generate explanations
blimey_image_collection = {}
for gran_name, gran_number in granularity_selection.items():
blimey_image_collection[gran_name] = {}
for col_name in colour_selection:
blimey_image_collection[gran_name][col_name] = \
exo.build_image_blimey(
doggo_array,
clf.predict_proba,
explain_classes,
explanation_size=5,
segments_number=gran_number,
occlusion_colour=col_name,
samples_number=SAMPLES,
batch_size=BATCH,
random_seed=42)
exp = []
for gran_ in blimey_image_collection:
for col_ in blimey_image_collection[gran_]:
exp.append(blimey_image_collection[gran_][col_]['surrogates'])
assert len(exp) == len(EXP_IMG)
for e, E in zip(exp, EXP_IMG):
assert sorted(list(e.keys())) == sorted(list(E.keys()))
for key in e.keys():
assert e[key]['name'] == E[key]['name']
assert len(e[key]['explanation']) == len(E[key]['explanation'])
for e_, E_ in zip(e[key]['explanation'], E[key]['explanation']):
assert e_[0] == E_[0]
assert np.allclose(e_[1], E_[1], atol=.001, equal_nan=True)
def test_bilmey_tabular():
"""Tests surrogate tabular bLIMEy."""
# Load the iris data set
iris = sklearn.datasets.load_iris()
iris_X = iris.data # [:, :2] # take the first two features only
iris_y = iris.target
iris_labels = iris.target_names
iris_feature_names = iris.feature_names
label2class = {lab: i for i, lab in enumerate(iris_labels)}
# Fit the classifier
logreg = sklearn.linear_model.LogisticRegression(C=1e5)
logreg.fit(iris_X, iris_y)
# explained class
_dtype = iris_X.dtype
explained_instances = {
'setosa': np.array([5, 3.5, 1.5, 0.25]).astype(_dtype),
'versicolor': np.array([5.5, 2.75, 4.5, 1.25]).astype(_dtype),
'virginica': np.array([7, 3, 5.5, 2.25]).astype(_dtype)
}
petal_length_idx = iris_feature_names.index('petal length (cm)')
petal_length_bins = [1, 2, 3, 4, 5, 6, 7]
petal_width_idx = iris_feature_names.index('petal width (cm)')
petal_width_bins = [0, .5, 1, 1.5, 2, 2.5]
discs_ = []
for i, ix in enumerate(petal_length_bins): # X-axis
for iix in petal_length_bins[i + 1:]:
for j, jy in enumerate(petal_width_bins): # Y-axis
for jjy in petal_width_bins[j + 1:]:
discs_.append({
petal_length_idx: [ix, iix],
petal_width_idx: [jy, jjy]
})
for inst_i in explained_instances:
for cls_i in iris_labels:
for disc_i, disc in enumerate(discs_):
inst = explained_instances[inst_i]
cls = label2class[cls_i]
exp = exo.build_tabular_blimey(
inst, cls, iris_X, iris_y, logreg.predict_proba, disc,
IRIS_SAMPLES, SAMPLE_IRIS, 42)
key = '{}&{}&{}'.format(inst_i, cls, disc_i)
exp_ = EXP_TAB[key]
assert exp['explanation'].shape[0] == exp_.shape[0]
assert np.allclose(
exp['explanation'], exp_, atol=.001, equal_nan=True)
EXP_IMG = [
{207: {'explanation': [(13, -0.24406872165780585),
(11, -0.20456180387430317),
(9, -0.1866779131424261),
(4, 0.15001224157793785),
(3, 0.11589480417160983)],
'name': 'golden retriever'},
208: {'explanation': [(13, -0.08395966359346249),
(0, -0.0644986107387837),
(9, 0.05845584633658977),
(1, 0.04369763085720947),
(11, -0.035958188394941866)],
'name': '<NAME>'},
852: {'explanation': [(13, 0.3463529698715463),
(11, 0.2678050131923326),
(4, -0.10639863421417416),
(6, 0.08345792378117327),
(9, 0.07366945242386444)],
'name': '<NAME>'}},
{207: {'explanation': [(13, -0.0624167912596456),
(7, 0.06083359545295548),
(3, 0.0495953943686462),
(11, -0.04819787147412231),
(2, -0.03858823761391199)],
'name': '<NAME>'},
208: {'explanation': [(13, -0.08408428146916162),
(7, 0.07704235920590158),
(3, 0.06646468388122273),
(11, -0.0638326572126609),
(2, -0.052621478002380796)],
'name': '<NAME>'},
852: {'explanation': [(11, 0.35248212611685886),
(13, 0.2516925608037859),
(2, 0.13682853028454384),
(9, 0.12930134856644754),
(6, 0.1257747954095489)],
'name': '<NAME>'}},
{207: {'explanation': [(3, 0.21351937934930917),
(10, 0.16933456312772083),
(11, -0.13447244552856766),
(8, 0.11058919217055371),
(2, -0.06269239798368743)],
'name': '<NAME>'},
208: {'explanation': [(8, 0.05995551486884414),
(9, -0.05375302972380482),
(11, -0.051997353324246445),
(6, 0.04213181405953071),
(2, -0.039169895361928275)],
'name': '<NAME>'},
852: {'explanation': [(7, 0.31382219776986503),
(11, 0.24126214884275987),
(13, 0.21075924370226598),
(2, 0.11937652039885377),
(8, -0.11911265319329697)],
'name': '<NAME>'}},
{207: {'explanation': [(3, 0.39254403293049134),
(9, 0.19357165018747347),
(6, 0.16592079671652987),
(0, 0.14042059731407297),
(1, 0.09793027079765507)],
'name': '<NAME>'},
208: {'explanation': [(9, -0.19351859273276703),
(1, -0.15262967987262344),
(3, 0.12205127112235375),
(2, 0.11352141032313934),
(6, -0.11164209893429898)],
'name': '<NAME>'},
852: {'explanation': [(7, 0.17213007100844877),
(0, -0.1583030948868859),
(3, -0.13748574615069775),
(5, 0.13273283867075436),
(11, 0.12309551170070354)],
'name': '<NAME>'}},
{207: {'explanation': [(3, 0.4073533182995105),
(10, 0.20711667988142463),
(8, 0.15360813290032324),
(6, 0.1405424759832785),
(1, 0.1332920685413575)],
'name': '<NAME>'},
208: {'explanation': [(9, -0.14747910525112617),
(1, -0.13977061235228924),
(2, 0.10526833898161611),
(6, -0.10416022118399552),
(3, 0.09555992655161764)],
'name': '<NAME>'},
852: {'explanation': [(11, 0.2232260929107954),
(7, 0.21638443149433054),
(5, 0.21100464215582274),
(13, 0.145614853795006),
(1, -0.11416523431311262)],
'name': '<NAME>'}},
{207: {'explanation': [(1, 0.14700178977744183),
(0, 0.10346667279328238),
(2, 0.10346667279328238),
(7, 0.10346667279328238),
(8, 0.10162900633690726)],
'name': '<NAME>'},
208: {'explanation': [(10, -0.10845134816658476),
(8, -0.1026920429226184),
(6, -0.10238154733842847),
(18, 0.10094164937411244),
(16, 0.08646888450232793)],
'name': '<NAME>'},
852: {'explanation': [(18, -0.20542297091894474),
(13, 0.2012751176130666),
(8, -0.19194747162742365),
(20, 0.14686930696710473),
(15, 0.11796990086271067)],
'name': '<NAME>'}},
{207: {'explanation': [(13, 0.12446259821701779),
(17, 0.11859084421095789),
(15, 0.09690553833007137),
(12, -0.08869743701731962),
(4, 0.08124900427893789)],
'name': '<NAME>'},
208: {'explanation': [(10, -0.09478194981909983),
(20, -0.09173392507039077),
(9, 0.08768898801254493),
(17, -0.07553994244536394),
(4, 0.07422905503397653)],
'name': '<NAME>'},
852: {'explanation': [(21, 0.1327882942965061),
(1, 0.1238236573086363),
(18, -0.10911712271717902),
(19, 0.09707191051320978),
(6, 0.08593672504338913)],
'name': '<NAME>'}},
{207: {'explanation': [(6, 0.14931728779865114),
(14, 0.14092073957103526),
(1, 0.11071480021464616),
(4, 0.10655287976934531),
(8, 0.08705404649152573)],
'name': '<NAME>'},
208: {'explanation': [(8, -0.12242580400886727),
(9, 0.12142729544158742),
(14, -0.1148252787068248),
(16, -0.09562322208795092),
(4, 0.09350160975513132)],
'name': '<NAME>'},
852: {'explanation': [(6, 0.04227675072263027),
(9, -0.03107924340879173),
(14, 0.028007115650713045),
(13, 0.02771190348545554),
(19, 0.02640441416071482)],
'name': '<NAME>'}},
{207: {'explanation': [(19, 0.14313680656283245),
(18, 0.12866508562342843),
(8, 0.11809779264185447),
(0, 0.11286255403442104),
(2, 0.11286255403442104)],
'name': '<NAME>'},
208: {'explanation': [(9, 0.2397917428082761),
(14, -0.19435572812170654),
(6, -0.1760894833446507),
(18, -0.12243333818399058),
(15, 0.10986343675377105)],
'name': '<NAME>'},
852: {'explanation': [(14, 0.15378038774613365),
(9, -0.14245940635481966),
(6, 0.10213601012183973),
(20, 0.1009180838986786),
(3, 0.09780065767815548)],
'name': '<NAME>'}},
{207: {'explanation': [(15, 0.06525850448807077),
(9, 0.06286791243851698),
(19, 0.055189970374185854),
(8, 0.05499197604401475),
(13, 0.04748220842936177)],
'name': '<NAME>'},
208: {'explanation': [(6, -0.31549091899770765),
(5, 0.1862302670824446),
(8, -0.17381478451341995),
(10, -0.17353516098662508),
(14, -0.13591542421754205)],
'name': '<NAME>'},
852: {'explanation': [(14, 0.2163853942943355),
(6, 0.17565046338282214),
(1, 0.12446193028474549),
(9, -0.11365789839746396),
(10, 0.09239073691962967)],
'name': '<NAME>'}},
{207: {'explanation': [(19, 0.1141207265647932),
(36, -0.08861425922625768),
(30, 0.07219209872026074),
(9, -0.07150939547859836),
(38, -0.06988288637544438)],
'name': '<NAME>'},
208: {'explanation': [(29, 0.10531073909547647),
(13, 0.08279642208039652),
(34, -0.0817952443980797),
(33, -0.08086848205765082),
(12, 0.08086848205765082)],
'name': '<NAME>'},
852: {'explanation': [(13, -0.1330452414595897),
(4, 0.09942366413042845),
(12, -0.09881995683190645),
(33, 0.09881995683190645),
(19, -0.09596925317560831)],
'name': '<NAME>'}},
{207: {'explanation': [(37, 0.08193926967758253),
(35, 0.06804043021426347),
(15, 0.06396269230810163),
(11, 0.062255657227065296),
(8, 0.05529200233091672)],
'name': '<NAME>'},
208: {'explanation': [(19, 0.05711957286614678),
(27, -0.050230108135410824),
(16, -0.04743034616549999),
(5, -0.046717346734255705),
(9, -0.04419100026638039)],
'name': '<NAME>'},
852: {'explanation': [(3, -0.08390967998497496),
(30, -0.07037680222442452),
(22, 0.07029819368543713),
(8, -0.06861396187180349),
(37, -0.06662511956402824)],
'name': '<NAME>'}},
{207: {'explanation': [(19, 0.048418845359024805),
(9, -0.0423869575883795),
(30, 0.04012650790044438),
(36, -0.03787242980067195),
(10, 0.036557999380695635)],
'name': '<NAME>'},
208: {'explanation': [(10, 0.12120686823129677),
(17, 0.10196564232230493),
(7, 0.09495133975425854),
(25, -0.0759657891182803),
(2, -0.07035244568286837)],
'name': '<NAME>'},
852: {'explanation': [(3, -0.0770578003457272),
(28, 0.0769372258280398),
(6, -0.06044725989272927),
(22, 0.05550155775286349),
(31, -0.05399028046597057)],
'name': '<NAME>'}},
{207: {'explanation': [(14, 0.05371383110181226),
(0, -0.04442539316084218),
(18, 0.042589475382826494),
(19, 0.04227647855354252),
(17, 0.041685661662754295)],
'name': '<NAME>'},
208: {'explanation': [(29, 0.14419601354489464),
(17, 0.11785174500536676),
(36, 0.1000501679652906),
(10, 0.09679790134851017),
(35, 0.08710376081189208)],
'name': '<NAME>'},
852: {'explanation': [(8, -0.02486237985832769),
(3, -0.022559886154747102),
(11, -0.021878686669239856),
(36, 0.021847953817988534),
(19, -0.018317598300716522)],
'name': '<NAME>'}},
{207: {'explanation': [(37, 0.08098729255605368),
(35, 0.06639102704982619),
(15, 0.06033721190370432),
(34, 0.05826267856117829),
(28, 0.05549505160798173)],
'name': '<NAME>'},
208: {'explanation': [(17, 0.13839012042250542),
(10, 0.11312187488346881),
(7, 0.10729071207480922),
(25, -0.09529127965797404),
(11, -0.09279834572979286)],
'name': '<NAME>'},
852: {'explanation': [(3, -0.028385651836694076),
(22, 0.023364702783498722),
(8, -0.023097812578270233),
(30, -0.022931236620034406),
(37, -0.022040170736525342)],
'name': '<NAME>'}}
]
EXP_TAB = {
'setosa&0&0': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&1': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&2': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&3': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&4': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&5': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&6': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&7': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&8': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&9': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&10': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&11': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&12': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&13': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&14': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&15': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&16': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&17': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&18': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&19': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&20': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&21': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&22': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&23': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&24': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&25': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&26': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&27': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&28': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&29': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&30': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&31': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&32': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&33': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&34': np.array([0.7974072911132786, 0.006894018772033576]),
'setosa&0&35': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&36': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&37': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&38': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&39': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&40': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&41': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&42': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&43': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&44': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&45': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&46': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&47': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&48': np.array([0.4329463382004908, 0.057167210150691136]),
'setosa&0&49': np.array([0.4656481363306145, 0.007982539480288167]),
'setosa&0&50': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&51': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&52': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&53': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&54': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&55': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&56': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&57': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&58': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&59': np.array([0.4329463382004908, 0.057167210150691136]),
'setosa&0&60': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&61': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&62': np.array([0.009595083643662688, 0.5643652067423869]),
'setosa&0&63': np.array([0.13694026920485936, 0.36331091829858003]),
'setosa&0&64': np.array([0.3094460464703627, 0.11400643817329122]),
'setosa&0&65': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&66': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&67': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&68': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&69': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&70': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&71': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&72': np.array([0.009595083643662688, 0.5643652067423869]),
'setosa&0&73': np.array([0.009595083643662688, 0.5643652067423869]),
'setosa&0&74': np.array([0.13694026920485936, 0.36331091829858003]),
'setosa&0&75': np.array([0.0, 0.95124502153736]),
'setosa&0&76': np.array([0.0, 0.9708703761803881]),
'setosa&0&77': np.array([0.0, 0.5659706098422994]),
'setosa&0&78': np.array([0.0, 0.3962828716108186]),
'setosa&0&79': np.array([0.0, 0.2538069363248767]),
'setosa&0&80': np.array([0.0, 0.95124502153736]),
'setosa&0&81': np.array([0.0, 0.95124502153736]),
'setosa&0&82': np.array([0.0, 0.95124502153736]),
'setosa&0&83': np.array([0.0, 0.95124502153736]),
'setosa&0&84': np.array([0.0, 0.9708703761803881]),
'setosa&0&85': np.array([0.0, 0.9708703761803881]),
'setosa&0&86': np.array([0.0, 0.9708703761803881]),
'setosa&0&87': np.array([0.0, 0.5659706098422994]),
'setosa&0&88': np.array([0.0, 0.5659706098422994]),
'setosa&0&89': np.array([0.0, 0.3962828716108186]),
'setosa&0&90': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&91': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&92': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&93': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&94': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&95': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&96': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&97': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&98': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&99': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&100': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&101': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&102': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&103': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&104': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&105': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&106': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&107': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&108': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&109': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&110': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&111': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&112': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&113': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&114': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&115': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&116': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&117': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&118': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&119': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&120': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&121': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&122': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&123': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&124': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&125': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&126': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&127': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&128': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&129': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&130': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&131': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&132': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&133': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&134': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&135': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&136': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&137': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&138': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&139': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&140': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&141': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&142': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&143': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&144': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&145': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&146': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&147': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&148': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&149': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&150': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&151': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&152': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&153': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&154': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&155': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&156': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&157': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&158': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&159': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&160': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&161': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&162': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&163': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&164': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&165': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&166': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&167': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&168': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&169': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&170': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&171': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&172': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&173': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&174': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&175': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&176': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&177': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&178': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&179': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&180': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&181': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&182': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&183': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&184': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&185': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&186': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&187': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&188': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&189': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&190': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&191': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&192': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&193': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&194': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&195': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&196': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&197': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&198': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&199': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&200': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&201': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&202': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&203': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&204': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&205': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&206': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&207': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&208': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&209': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&210': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&211': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&212': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&213': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&214': np.array([0.9706534384443797, 0.007448195602953232]),
'setosa&0&215': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&216': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&217': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&218': np.array([0.7431524521056113, 0.24432235603856345]),
'setosa&0&219': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&220': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&221': np.array([0.4926091071260067, 0.49260910712601286]),
'setosa&0&222': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&223': np.array([0.9550700362273441, 0.025428672111930138]),
'setosa&0&224': np.array([0.9672121512728677, 0.012993005706020341]),
'setosa&0&225': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&226': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&227': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&228': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&229': np.array([0.7974072911132786, 0.006894018772033576]),
'setosa&0&230': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&231': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&232': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&233': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&234': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&235': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&236': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&237': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&238': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&239': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&240': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&241': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&242': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&243': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&244': np.array([0.7974072911132786, 0.006894018772033576]),
'setosa&0&245': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&246': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&247': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&248': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&249': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&250': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&251': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&252': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&253': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&254': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&255': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&256': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&257': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&258': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&259': np.array([0.7974072911132786, 0.006894018772033576]),
'setosa&0&260': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&261': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&262': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&263': np.array([0.19685199412911678, 0.7845879230594391]),
'setosa&0&264': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&265': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&266': np.array([0.07476043598366156, 0.9062715528547001]),
'setosa&0&267': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&268': np.array([0.7770298852793471, 0.0294434304771479]),
'setosa&0&269': np.array([0.7936433456054741, 0.01258375207649658]),
'setosa&0&270': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&271': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&272': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&273': np.array([0.4329463382004908, 0.057167210150691136]),
'setosa&0&274': np.array([0.4656481363306145, 0.007982539480288167]),
'setosa&0&275': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&276': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&277': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&278': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&279': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&280': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&281': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&282': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&283': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&284': np.array([0.4329463382004908, 0.057167210150691136]),
'setosa&0&285': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&286': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&287': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&288': np.array([0.4329463382004908, 0.057167210150691136]),
'setosa&0&289': np.array([0.4656481363306145, 0.007982539480288167]),
'setosa&0&290': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&291': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&292': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&293': np.array([0.050316962184345455, 0.9292276112117481]),
'setosa&0&294': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&295': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&296': np.array([0.0171486447659196, 0.9632117581295891]),
'setosa&0&297': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&298': np.array([0.06151571389390039, 0.524561199322281]),
'setosa&0&299': np.array([0.4329463382004908, 0.057167210150691136]),
'setosa&0&300': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&301': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&302': np.array([0.009595083643662688, 0.5643652067423869]),
'setosa&0&303': np.array([0.13694026920485936, 0.36331091829858003]),
'setosa&0&304': np.array([0.3094460464703627, 0.11400643817329122]),
'setosa&0&305': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&306': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&307': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&308': np.array([0.029402442458921055, 0.9481684282717416]),
'setosa&0&309': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&310': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&311': np.array([0.00988785935411159, 0.9698143912008228]),
'setosa&0&312': np.array([0.009595083643662688, 0.5643652067423869]),
'setosa&0&313': np.array([0.009595083643662688, 0.5643652067423869]),
'setosa&0&314': np.array([0.13694026920485936, 0.36331091829858003]),
'setosa&1&0': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&1': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&2': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&3': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&4': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&5': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&6': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&7': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&8': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&9': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&10': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&11': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&12': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&13': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&14': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&15': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&16': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&17': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&18': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&19': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&20': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&21': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&22': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&23': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&24': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&25': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&26': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&27': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&28': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&29': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&30': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&31': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&32': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&33': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&34': np.array([-0.26192650167775977, 0.33491141590339474]),
'setosa&1&35': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&36': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&37': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&38': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&39': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&40': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&41': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&42': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&43': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&44': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&45': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&46': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&47': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&48': np.array([0.33108168891715983, 0.13647816746351163]),
'setosa&1&49': np.array([0.4079256832347186, 0.038455640985860955]),
'setosa&1&50': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&51': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&52': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&53': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&54': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&55': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&56': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&57': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&58': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&59': np.array([0.33108168891715983, 0.13647816746351163]),
'setosa&1&60': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&61': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&62': np.array([0.25657760110071476, 0.12592645350389123]),
'setosa&1&63': np.array([0.13717260713320106, 0.3627779907901665]),
'setosa&1&64': np.array([0.3093950298647913, 0.1140298206733954]),
'setosa&1&65': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&66': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&67': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&68': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&69': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&70': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&71': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&72': np.array([0.25657760110071476, 0.12592645350389123]),
'setosa&1&73': np.array([0.25657760110071476, 0.12592645350389123]),
'setosa&1&74': np.array([0.13717260713320106, 0.3627779907901665]),
'setosa&1&75': np.array([0.0, -0.4756207622944677]),
'setosa&1&76': np.array([0.0, -0.4854334805210761]),
'setosa&1&77': np.array([0.0, 0.16885577975809635]),
'setosa&1&78': np.array([0.0, 0.395805885538554]),
'setosa&1&79': np.array([0.0, 0.2538072707138344]),
'setosa&1&80': np.array([0.0, -0.4756207622944677]),
'setosa&1&81': np.array([0.0, -0.4756207622944677]),
'setosa&1&82': np.array([0.0, -0.4756207622944677]),
'setosa&1&83': np.array([0.0, -0.4756207622944677]),
'setosa&1&84': np.array([0.0, -0.4854334805210761]),
'setosa&1&85': np.array([0.0, -0.4854334805210761]),
'setosa&1&86': np.array([0.0, -0.4854334805210761]),
'setosa&1&87': np.array([0.0, 0.16885577975809635]),
'setosa&1&88': np.array([0.0, 0.16885577975809635]),
'setosa&1&89': np.array([0.0, 0.395805885538554]),
'setosa&1&90': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&91': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&92': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&93': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&94': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&95': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&96': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&97': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&98': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&99': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&100': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&101': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&102': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&103': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&104': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&105': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&106': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&107': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&108': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&109': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&110': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&111': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&112': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&113': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&114': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&115': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&116': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&117': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&118': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&119': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&120': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&121': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&122': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&123': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&124': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&125': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&126': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&127': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&128': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&129': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&130': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&131': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&132': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&133': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&134': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&135': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&136': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&137': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&138': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&139': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&140': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&141': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&142': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&143': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&144': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&145': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&146': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&147': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&148': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&149': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&150': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&151': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&152': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&153': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&154': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&155': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&156': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&157': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&158': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&159': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&160': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&161': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&162': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&163': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&164': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&165': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&166': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&167': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&168': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&169': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&170': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&171': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&172': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&173': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&174': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&175': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&176': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&177': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&178': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&179': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&180': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&181': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&182': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&183': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&184': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&185': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&186': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&187': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&188': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&189': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&190': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&191': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&192': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&193': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&194': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&195': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&196': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&197': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&198': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&199': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&200': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&201': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&202': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&203': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&204': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&205': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&206': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&207': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&208': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&209': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&210': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&211': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&212': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&213': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&214': np.array([-0.4964962439921071, 0.3798215458387346]),
'setosa&1&215': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&216': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&217': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&218': np.array([-0.37157553889555184, -0.1221600832023858]),
'setosa&1&219': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&220': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&221': np.array([-0.2463036871609408, -0.24630368716093934]),
'setosa&1&222': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&223': np.array([-0.9105775730167809, 0.6842162738602727]),
'setosa&1&224': np.array([-0.6718337295341267, 0.6620422637360075]),
'setosa&1&225': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&226': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&227': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&228': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&229': np.array([-0.26192650167775977, 0.33491141590339474]),
'setosa&1&230': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&231': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&232': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&233': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&234': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&235': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&236': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&237': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&238': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&239': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&240': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&241': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&242': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&243': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&244': np.array([-0.26192650167775977, 0.33491141590339474]),
'setosa&1&245': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&246': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&247': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&248': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&249': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&250': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&251': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&252': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&253': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&254': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&255': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&256': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&257': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&258': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&259': np.array([-0.26192650167775977, 0.33491141590339474]),
'setosa&1&260': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&261': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&262': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&263': np.array([0.32199975656257585, -0.748229355246375]),
'setosa&1&264': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&265': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&266': np.array([0.43843349141088417, -0.8642740701867918]),
'setosa&1&267': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&268': np.array([-0.7141739659554724, 0.6619819140152877]),
'setosa&1&269': np.array([-0.4446001433508151, 0.6107546840046902]),
'setosa&1&270': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&271': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&272': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&273': np.array([0.33108168891715983, 0.13647816746351163]),
'setosa&1&274': np.array([0.4079256832347186, 0.038455640985860955]),
'setosa&1&275': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&276': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&277': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&278': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&279': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&280': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&281': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&282': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&283': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&284': np.array([0.33108168891715983, 0.13647816746351163]),
'setosa&1&285': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&286': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&287': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&288': np.array([0.33108168891715983, 0.13647816746351163]),
'setosa&1&289': np.array([0.4079256832347186, 0.038455640985860955]),
'setosa&1&290': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&291': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&292': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&293': np.array([0.7749499208750121, -0.814718944080443]),
'setosa&1&294': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&295': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&296': np.array([0.80403091954169, -0.844515250413482]),
'setosa&1&297': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&298': np.array([0.5826506963750848, -0.22335655671229107]),
'setosa&1&299': np.array([0.33108168891715983, 0.13647816746351163]),
'setosa&1&300': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&301': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&302': np.array([0.25657760110071476, 0.12592645350389123]),
'setosa&1&303': np.array([0.13717260713320106, 0.3627779907901665]),
'setosa&1&304': np.array([0.3093950298647913, 0.1140298206733954]),
'setosa&1&305': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&306': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&307': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&308': np.array([0.4933316375690333, -0.5272416708629277]),
'setosa&1&309': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&310': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&311': np.array([0.5041830043657418, -0.5392782673950876]),
'setosa&1&312': np.array([0.25657760110071476, 0.12592645350389123]),
'setosa&1&313': np.array([0.25657760110071476, 0.12592645350389123]),
'setosa&1&314': np.array([0.13717260713320106, 0.3627779907901665]),
'setosa&2&0': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&1': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&2': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&3': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&4': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&5': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&6': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&7': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&8': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&9': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&10': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&11': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&12': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&13': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&14': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&15': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&16': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&17': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&18': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&19': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&20': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&21': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&22': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&23': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&24': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&25': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&26': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&27': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&28': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&29': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&30': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&31': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&32': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&33': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&34': np.array([-0.5354807894355184, -0.3418054346754283]),
'setosa&2&35': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&36': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&37': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&38': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&39': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&40': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&41': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&42': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&43': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&44': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&45': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&46': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&47': np.array([-0.6441664102689847, -0.3012046426099901]),
'setosa&2&48': np.array([-0.7640280271176497, -0.19364537761420375]),
'setosa&2&49': np.array([-0.8735738195653328, -0.046438180466149094]),
'setosa&2&50': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&51': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&52': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&53': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&54': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&55': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&56': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&57': np.array([-0.6441664102689847, -0.3012046426099901]),
'setosa&2&58': np.array([-0.6441664102689847, -0.3012046426099901]),
'setosa&2&59': np.array([-0.7640280271176497, -0.19364537761420375]),
'setosa&2&60': np.array([-0.5227340800279542, -0.42092675740881474]),
'setosa&2&61': np.array([-0.5140708637198534, -0.43053612380573514]),
'setosa&2&62': np.array([-0.2661726847443776, -0.6902916602462779]),
'setosa&2&63': np.array([-0.2741128763380603, -0.7260889090887469]),
'setosa&2&64': np.array([-0.6188410763351541, -0.22803625884668638]),
'setosa&2&65': np.array([-0.5227340800279542, -0.42092675740881474]),
'setosa&2&66': np.array([-0.5227340800279542, -0.42092675740881474]),
'setosa&2&67': np.array([-0.5227340800279542, -0.42092675740881474]),
'setosa&2&68': np.array([-0.5227340800279542, -0.42092675740881474]),
'setosa&2&69': np.array([-0.5140708637198534, -0.43053612380573514]),
'setosa&2&70': np.array([-0.5140708637198534, -0.43053612380573514]),
'setosa&2&71': np.array([-0.5140708637198534, -0.43053612380573514]),
'setosa&2&72': np.array([-0.2661726847443776, -0.6902916602462779]),
'setosa&2&73': np.array([-0.2661726847443776, -0.6902916602462779]),
'setosa&2&74': np.array([-0.2741128763380603, -0.7260889090887469]),
'setosa&2&75': np.array([0.0, -0.47562425924289314]),
'setosa&2&76': np.array([0.0, -0.48543689565931186]),
'setosa&2&77': np.array([0.0, -0.7348263896003956]),
'setosa&2&78': np.array([0.0, -0.7920887571493729]),
'setosa&2&79': np.array([0.0, -0.507614207038711]),
'setosa&2&80': np.array([0.0, -0.47562425924289314]),
'setosa&2&81': np.array([0.0, -0.47562425924289314]),
'setosa&2&82': np.array([0.0, -0.47562425924289314]),
'setosa&2&83': np.array([0.0, -0.47562425924289314]),
'setosa&2&84': np.array([0.0, -0.48543689565931186]),
'setosa&2&85': np.array([0.0, -0.48543689565931186]),
'setosa&2&86': np.array([0.0, -0.48543689565931186]),
'setosa&2&87': np.array([0.0, -0.7348263896003956]),
'setosa&2&88': np.array([0.0, -0.7348263896003956]),
'setosa&2&89': np.array([0.0, -0.7920887571493729]),
'setosa&2&90': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&91': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&92': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&93': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&94': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&95': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&96': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&97': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&98': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&99': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&100': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&101': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&102': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&103': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&104': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&105': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&106': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&107': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&108': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&109': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&110': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&111': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&112': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&113': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&114': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&115': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&116': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&117': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&118': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&119': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&120': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&121': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&122': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&123': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&124': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&125': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&126': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&127': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&128': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&129': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&130': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&131': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&132': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&133': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&134': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&135': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&136': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&137': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&138': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&139': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&140': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&141': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&142': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&143': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&144': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&145': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&146': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&147': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&148': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&149': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&150': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&151': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&152': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&153': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&154': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&155': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&156': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&157': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&158': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&159': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&160': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&161': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&162': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&163': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&164': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&165': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&166': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&167': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&168': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&169': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&170': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&171': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&172': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&173': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&174': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&175': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&176': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&177': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&178': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&179': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&180': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&181': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&182': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&183': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&184': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&185': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&186': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&187': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&188': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&189': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&190': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&191': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&192': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&193': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&194': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&195': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&196': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&197': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&198': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&199': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&200': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&201': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&202': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&203': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&204': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&205': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&206': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&207': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&208': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&209': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&210': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&211': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&212': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&213': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&214': np.array([-0.47415719445227245, -0.38726974144168774]),
'setosa&2&215': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&216': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&217': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&218': np.array([-0.3715769132100501, -0.12216227283618744]),
'setosa&2&219': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&220': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&221': np.array([-0.24630541996506924, -0.24630541996506994]),
'setosa&2&222': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&223': np.array([-0.044492463210563125, -0.7096449459722027]),
'setosa&2&224': np.array([-0.29537842173874096, -0.6750352694420283]),
'setosa&2&225': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&226': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&227': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&228': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&229': np.array([-0.5354807894355184, -0.3418054346754283]),
'setosa&2&230': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&231': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&232': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&233': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&234': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&235': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&236': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&237': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&238': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&239': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&240': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&241': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&242': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&243': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&244': np.array([-0.5354807894355184, -0.3418054346754283]),
'setosa&2&245': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&246': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&247': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&248': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&249': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&250': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&251': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&252': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&253': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&254': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&255': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&256': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&257': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&258': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&259': np.array([-0.5354807894355184, -0.3418054346754283]),
'setosa&2&260': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&261': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&262': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&263': np.array([-0.5188517506916893, -0.036358567813067795]),
'setosa&2&264': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&265': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&266': np.array([-0.513193927394545, -0.041997482667908786]),
'setosa&2&267': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&268': np.array([-0.06285591932387405, -0.6914253444924359]),
'setosa&2&269': np.array([-0.34904320225465857, -0.6233384360811872]),
'setosa&2&270': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&271': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&272': np.array([-0.6441664102689847, -0.3012046426099901]),
'setosa&2&273': np.array([-0.7640280271176497, -0.19364537761420375]),
'setosa&2&274': np.array([-0.8735738195653328, -0.046438180466149094]),
'setosa&2&275': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&276': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&277': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&278': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&279': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&280': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&281': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&282': np.array([-0.6441664102689847, -0.3012046426099901]),
'setosa&2&283': np.array([-0.6441664102689847, -0.3012046426099901]),
'setosa&2&284': np.array([-0.7640280271176497, -0.19364537761420375]),
'setosa&2&285': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&286': np.array([-0.8211795643076093, -0.1186965077161071]),
'setosa&2&287': np.array([-0.6441664102689847, -0.3012046426099901]),
'setosa&2&288': np.array([-0.7640280271176497, -0.19364537761420375]),
'setosa&2&289': np.array([-0.8735738195653328, -0.046438180466149094]),
'setosa&2&290': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&291': np.array([-0.8252668830593567, -0.11450866713130638]),
'setosa&2&292': | np.array([-0.8252668830593567, -0.11450866713130638]) | numpy.array |
import os
import errno
import h5py
import numpy as np
import scipy
import logging
from shutil import rmtree
from typing import *
from loompy import LoomConnection
class LoomTiles(object):
#############
# DEEP ZOOM #
#############
__slots__ = [
'ds',
'_maxes',
'_mins'
]
def __init__(self, ds: LoomConnection) -> None:
self.ds = ds
self._maxes = None # type: np.ndarray
self._mins = None
def maxes(self) -> Any:
if self._maxes is None:
# colormax = np.percentile(data, 99, axis=1) + 0.1
# minFloat = np.finfo(float).eps;
# def percentileMap(data):
# return np.percentile(data, 99, axis=1) + minFloat;
# Prefer using numpy's built-in method for finding the
# max values faster
# self._maxes = self.ds.map([max], 0)[0]
logging.info('calculating & caching max values')
rows = self.ds.shape[0]
_maxes = np.zeros(rows)
ix = 0
while ix < rows:
rows_per_chunk = min(rows - ix, 64)
chunk = self.ds[ix:ix + rows_per_chunk, :]
_maxes[ix:ix + rows_per_chunk] = np.nanmax(chunk, axis=1)
ix += rows_per_chunk
print('.', end='', flush=True)
self._maxes = _maxes
print(' done\n\n')
return self._maxes
def mins(self) -> Any:
if self._mins is None:
# self._mins = self.ds.map([min], 0)[0]
logging.info('calculating & caching min values')
rows = self.ds.shape[0]
_mins = np.zeros(rows)
ix = 0
while ix < rows:
rows_per_chunk = min(rows - ix, 64)
chunk = self.ds[ix:ix + rows_per_chunk, :]
_mins[ix:ix + rows_per_chunk] = np.nanmin(chunk, axis=1)
ix += rows_per_chunk
print('.', end='', flush=True)
self._mins = _mins
print(' done\n\n')
return self._mins
def prepare_heatmap(self, truncate: bool = False) -> None:
tile_dir = "%s.tiles/" % (self.ds.filename)
if os.path.isdir(tile_dir):
logging.info(" Previous tile folder found at %s)", tile_dir)
if truncate:
logging.info(" Truncate set, removing old tile folder")
rmtree(tile_dir)
else:
logging.info(" Call prepare_heatmap(truncate=True) to overwrite")
return
self.maxes()
self.mins()
logging.info(' Generating and saving tiles')
self.dz_get_zoom_tile(0, 0, 8, truncate)
print(" done\n\n")
def dz_zoom_range(self) -> Tuple[int, int, int]:
"""
Determine the zoom limits for this file.
Returns:
Tuple (middle, min_zoom, max_zoom) of integer zoom levels.
"""
return (8, int(max(np.ceil(np.log2(self.ds.shape)))), int(max(np.ceil(np.log2(self.ds.shape))) + 8))
def dz_dimensions(self) -> Tuple[int, int]:
"""
Determine the total size of the deep zoom image.
Returns:
Tuple (x,y) of integers
"""
(y, x) = | np.divide(self.ds.shape, 256) | numpy.divide |
import matplotlib.pyplot as plt
#import seaborn as sns
import math
import itertools
import numpy as np
import pandas as pd
def preplot(x_df_se,y_se,xlab="Index",ylab="Value"):
if type(x_df_se) is pd.core.series.Series:
x_df = pd.DataFrame()
x_df[x_df_se.name] = x_df_se
else:
x_df = x_df_se
labs_list = x_df.columns.tolist()
nlabs = len(labs_list)
nind = len(x_df.index)
plt.figure(figsize=(8,3))
#sns.set_style("whitegrid")
plt.rcParams["font.size"]=15
for lab in labs_list:
plt.plot(range(nind),x_df[lab],alpha=0.8,marker="o",label=lab)
if y_se is not None:
plt.plot(range(nind),y_se,alpha=0.8,marker="o",label=y_se.name)
plt.xlabel(xlab)
plt.ylabel(ylab)
plt.grid()
#plt.xlim(-0.5,27)
#plt.ylim(-.8,)
plt.legend(loc="best",prop={"size":15})
#plt.colorbar()
#plt.savefig("./preplot.png")
plt.show()
def list_plot(x_list,y_list,label=None):
plt.figure(figsize=(6,5))
plt.rcParams["font.size"]=15
plt.plot(x_list,y_list,"+-",alpha=0.8,label=label)
#plt.title(title)
plt.legend(loc="best",prop={"size":12})
#plt.xlabel("Index")
#plt.ylabel("Feature values")
#plt.xlim(-0.5,27)
#plt.ylim(-.8,)
plt.grid()
#plt.colorbar()
#plt.savefig("./preplot.png")
plt.show()
def vs_plot(list1,list2,pmin=None,pmax=None,xlab="y",ylab="hy"):
if not pmin:
pmin = min(list1) - (max(list1) - min(list1)) / 10.
if not pmax:
pmax = max(list1) + (max(list1) - min(list1)) / 10.
plt.figure(figsize=(6,5))
plt.rcParams["font.size"]=15
plt.scatter(list1,list2,s=50,alpha=0.7)
plt.plot([pmin,pmax],[pmin,pmax],ls="--",c="k",lw=1.)
plt.xlabel(xlab)
plt.ylabel(ylab)
plt.grid()
plt.xlim(pmin,pmax)
plt.ylim(pmin,pmax)
#plt.legend(loc="upper left",prop={"size":12})
#plt.legend(loc="upper left",prop={"size":14})
#plt.savefig("vs.eps")
plt.show()
def lev_plot(lev,m,n):
outlier = 2*n/m
plt.figure(figsize=(8,3))
plt.rcParams["font.size"]=15
plt.plot(range(m),lev,alpha=0.8,marker="o",label="Leverage")
plt.axhline(outlier,linestyle="--",color="k",label="Outlier line (for Leverage)")
plt.xlabel("Index")
plt.ylabel("Leverages")
plt.grid()
plt.legend(loc="best",prop={"size":15})
plt.show()
def res_plot(e,eq):
m = len(e)
plt.figure(figsize=(8,3))
plt.rcParams["font.size"]=15
plt.plot(range(m),e,alpha=0.8,marker="o",label="Residuals")
plt.plot(range(m),eq,alpha=0.8,marker="o",label="Pred_residuals")
plt.xlabel("Index")
plt.ylabel("Residuals")
plt.grid()
plt.legend(loc="best",prop={"size":15})
plt.show()
def res_plot2(e_in,e_ex,dff,m,n):
outlier = 2* | np.sqrt(n/m) | numpy.sqrt |
# coding=utf-8
# Copyright 2021 The Google Research 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.
"""Tests for the NumPy ops."""
import itertools
from typing import Callable
from absl.testing import parameterized
import numpy as np
from scipy import special
import tensorflow as tf
from dedal import alignment
from dedal import smith_waterman_np as npy_ops
# For test purposes.
def _sw_general(sim_mat,
gap_func):
"""Computes soft Smith-Waterman with general gap function.
Args:
sim_mat: a np.ndarray<float>[len1, len2] containing
the substitution values for pairs of sequences.
gap_func: a function of the form gap_func(k), where k is an integer.
Returns:
Smith-Waterman value (float).
"""
len_1, len_2 = sim_mat.shape
match = np.zeros((len_1 + 1, len_2 + 1))
for i in range(1, len_1 + 1):
for j in range(1, len_2 + 1):
tmp = match[i - 1, j - 1] + sim_mat[i-1, j-1]
delete = max([match[i - k, j] - gap_func(k) for k in range(1, i + 1)])
insert = max([match[i, j - k] - gap_func(k) for k in range(1, j + 1)])
match[i, j] = max(tmp, delete, insert, 0)
return max(match[1:, 1:].ravel())
def scores_brute_force(weights):
len_1, len_2, _ = weights.shape
ret = []
for alignment_mat in npy_ops.alignment_matrices(len_1, len_2):
ret.append(np.vdot(alignment_mat, weights))
return | np.array(ret) | numpy.array |
import numpy as np
import csv
import matplotlib.pyplot as plt
n = 16 # number of input features.
m = 60 # number of training examples.
grad = np.zeros(shape = (n, 1))
theta = np.ones(shape=(n, 1), dtype = float)
hx = np.ones(shape=(m, 1), dtype = float)
file_handle = open("datasets/air-pollution/data.csv", "r")
reader = csv.reader(file_handle, delimiter = ',')
learning_rate = 1e-6
def h(X):
global theta
res = np.matmul(np.transpose(theta), X)
return res
cost_list = []
itr_list = []
def gradient_descent_algorithm():
global theta, grad
num_itrs = 10000
for itr in range(num_itrs):
file_handle.seek(0)
total_cost = 0.0
idx = 0
for row in reader:
X = [float(x) for x in row[0: -1]]
# list of floats
X = np.asarray(X)
np.reshape(X, [n, 1])
hx[idx][0] = h(X)
y_correct = float(row[0])
diff = (hx[idx][0] - y_correct)
total_cost += (diff * diff)
idx += 1
for j in range(n):
grad[j][0] = 0.0
i = 0
file_handle.seek(0)
for row in reader:
y_correct = float(row[-1])
xij = float(row[j + 1])
diff = hx[i][0] - y_correct
grad[j][0] += ((learning_rate * diff * xij) / m)
i += 1
theta = theta - grad
total_cost = total_cost /(2 * m)
cost_list.append(total_cost)
itr_list.append(itr + 1)
gradient_descent_algorithm()
plt.plot(itr_list, cost_list, label = "cost")
plt.xlabel("iterations")
# naming the y axis
plt.ylabel('Cost')
# giving a title to my graph
plt.title('Cost vs iterations')
# show a legend on the plot
plt.legend()
# function to show the plot
plt.show()
ypaxis = []
ycaxis = []
xaxis = []
index = 0
file_handle.seek(0)
for row in reader:
X = [float(x) for x in row[1:]]
# list of floats
X = | np.asarray(X) | numpy.asarray |
from collections import defaultdict
import numpy
from OpenGL.GL import *
from btypes.big_endian import *
import gx
from j3d.opengl import *
import logging
logger = logging.getLogger(__name__)
class Header(Struct):
magic = ByteString(4)
section_size = uint32
attribute_format_offset = uint32
position_offset = uint32
normal_offset = uint32
unknown0_offset = uint32 # NBT?
color_offsets = Array(uint32,2)
texcoord_offsets = Array(uint32,8)
def __init__(self):
self.magic = b'VTX1'
self.unknown0_offset = 0
@classmethod
def unpack(cls,stream):
header = super().unpack(stream)
if header.magic != b'VTX1':
raise FormatError('invalid magic')
if header.unknown0_offset != 0:
logger.warning('unknown0_offset different from default')
return header
class AttributeFormat(Struct):
""" Arguments to GXSetVtxAttrFmt."""
attribute = EnumConverter(uint32,gx.Attribute)
component_count = uint32
component_type = uint32
scale_exponent = uint8
__padding__ = Padding(3)
def __init__(self,attribute,component_count,component_type,scale_exponent):
self.attribute = attribute
self.component_count = component_count
self.component_type = component_type
self.scale_exponent = scale_exponent
class AttributeFormatList(TerminatedList):
element_type = AttributeFormat
terminator_value = AttributeFormat(gx.VA_NULL,1,0,0)
@staticmethod
def terminator_predicate(element):
return element.attribute == gx.VA_NULL
class Array(numpy.ndarray):
@staticmethod
def create_element_type(component_type,component_count):
return numpy.dtype((component_type.numpy_type,component_count.actual_value)).newbyteorder('>')
def __array_finalize__(self,obj):
if not isinstance(obj,Array): return
self.attribute = obj.attribute
self.component_type = obj.component_type
self.component_count = obj.component_count
self.scale_exponent = obj.scale_exponent
def gl_convert(self):
array = | numpy.asfarray(self,numpy.float32) | numpy.asfarray |
Subsets and Splits