prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
"""
Calculation of Earth layers and electron densities.
"""
from __future__ import division
import numpy as np
try:
import numba
except ImportError:
numba = None
from pisa import FTYPE
from pisa.utils.fileio import from_file
from pisa.utils.log import logging, set_verbosity
__all__ = ['extCalcLayers', 'Layers']
__author__ = '<NAME>'
__license__ = '''Copyright (c) 2014-2017, The IceCube Collaboration
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.'''
if numba is None:
class jit(object):
"""Decorator class to mimic Numba's `jit` when Numba is missing"""
def __init__(self, *args, **kwargs):
pass
def __call__(self, *args):
return args[0]
else:
jit = numba.jit
ftype = numba.typeof(FTYPE(1))
@jit(nopython=True, nogil=True, cache=True)
def extCalcLayers(
cz,
r_detector,
prop_height,
detector_depth,
max_layers,
min_detector_depth,
rhos,
YeFrac,
YeOuterRadius,
default_elec_frac,
coszen_limit,
radii):
"""Layer density/distance calculator for each coszen specified.
Accelerated with Numba if present.
Parameters
----------
cz
r_detector
prop_height
detector_depth
max_layers
min_detector_depth
rhos
YeFrac
YeOuterRadius
default_elec_frac
coszen_limit
Returns
-------
n_layers : int number of layers
density : array of densities, flattened from (cz, max_layers)
distance : array of distances per layer, flattened from (cz, max_layers)
"""
# Something to store the final results in
shape = (np.int64(len(cz)), np.int64(max_layers))
n_layers = np.zeros(shape[0], dtype=np.int32)
distance = np.zeros(shape=shape, dtype=FTYPE)
density = np.zeros(shape=shape, dtype=FTYPE)
# Loop over all CZ values
for k, coszen in enumerate(cz):
tot_earth_len = -2 * coszen * r_detector
# To store results
traverse_rhos = np.zeros(max_layers, dtype=FTYPE)
traverse_dist = | np.zeros(max_layers, dtype=FTYPE) | numpy.zeros |
import gzip
import os
import pickle
import numpy as np
from PIL import Image
__all__ = [
'_shuffle',
'DSBuilder'
]
def _shuffle(inputs, islist=True):
"""
Shuffle the datas/labels
Argu:
inputs: np.array/list, or list/tuple of np.array/list.
In the latter case, the corresponding elements for each
item in the list are shuffled together as a whole.
islist: Boolean. The latter case is enabled when the
value is True. Default is True.
Return:
A shuffled np.array/list(depend on argus)
"""
from random import shuffle
if islist:
len_ = len(inputs[0])
index = list(range(len_))
shuffle(index)
outputs = [[i[index[j]] for j in range(len_)] for i in inputs]
else:
len_ = len(inputs)
index = list(range(len_))
shuffle(index)
outputs = [inputs[i] for i in index]
return outputs
class DSBuilder(object):
"""
Data Set Builder
Argu:
dsdir: Str. Path of Dataset.
"""
def __init__(self, dsdir, size:list, shuffle=False, pklen=None, pklname='filelist.txt'):
self.dsdir = dsdir
self.size = size
self.shuffle = shuffle
self.pklen = pklen or self._cpklen(size)
self.pklname = pklname
self.classes_dict = {}
self.get_classes_dict()
def _cpklen(self, size):
"""
Compute pkl lenth
Max Byte is 2GiB(2^31).
"""
maxbyte = 2 ** 31
if len(size) == 2:
photo = size[0] * size[1] * 3
else:
photo = size[0] * size[1] * size[2]
return maxbyte // photo
def get_classes_dict(self, filename='classes.txt'):
"""
Get Classes Dict
Argu:
filename: Str. File name of the file that stores the
classified information.
Return:
Dict.
"""
if not self.classes_dict:
with open(f"{self.dsdir}/{filename}", 'r') as f:
temp = [i.strip() for i in f.readlines()]
self.classes_dict = dict(zip(range(len(temp)), temp))
return self.classes_dict
def get_all(self, mode):
"""
mode:
ignore
fill0
fillx
stretch
crop
"""
train, val, test = self.load()
if any([train, val, test]):
train_x, train_y = train
val_x, val_y = val
test_x = test
else:
train_x, train_y = self.get_data('train', mode)
val_x, val_y = self.get_data('val', mode)
test_x = self.get_data('test', mode)
self.save(
[train_x, train_y],
[val_x, val_y],
test_x)
return [train_x, train_y], [val_x, val_y], test_x
def get_data(self, name, img_mode, suffix='.jpg'):
if name != 'test':
images, labels = [], []
for item in self.classes_dict:
_dir = f"{self.dsdir}/{name}/{self.classes_dict[item]}/"
for i in range(len(os.listdir(_dir))):
img = self.img_func(_dir + f'{i}{suffix}', img_mode)
images.append(img)
labels.append(item)
if self.shuffle:
images, labels = _shuffle([images, labels])
return np.array(images), np.array(labels)
else:
images = []
_dir = f"{self.dsdir}/{name}/"
if not os.path.exists(_dir):
return None
for files in os.listdir(_dir):
img = self.img_func(_dir + files, img_mode)
images.append(img)
return np.array(images)
def save(self, train, val, test=None, suffix='.gz'):
file_list = []
num_train = len(train[0])
for i in range((num_train + self.pklen - 1) // self.pklen):
if (i + 1) * self.pklen <= num_train:
dtrain = {
'train_x': train[0][i*self.pklen:(i + 1)*self.pklen],
'train_y': train[1][i*self.pklen:(i + 1)*self.pklen],
}
else:
dtrain = {
'train_x': train[0][i*self.pklen:],
'train_y': train[1][i*self.pklen:],
}
with gzip.open(f"{self.dsdir}/train{i}{suffix}", 'wb') as f:
pickle.dump(dtrain, f)
file_list.append(f'train{i}{suffix}\n')
num_val = len(val[0])
for i in range((num_val + self.pklen - 1) // self.pklen):
if (i + 1) * self.pklen <= num_val:
dval = {
'val_x': val[0][i*self.pklen:(i + 1)*self.pklen],
'val_y': val[1][i*self.pklen:(i + 1)*self.pklen],
}
else:
dval = {
'val_x': val[0][i*self.pklen:],
'val_y': val[1][i*self.pklen:],
}
with gzip.open(f"{self.dsdir}/val{i}{suffix}", 'wb') as f:
pickle.dump(dval, f)
file_list.append(f'val{i}{suffix}\n')
if test != None:
num_test = len(test)
for i in range((num_test + self.pklen - 1) // self.pklen):
if (i + 1) * self.pklen <= num_test:
dtest = {
'test_x': test[i*self.pklen:(i + 1)*self.pklen],
}
else:
dtest = {
'test_x': test[i*self.pklen:],
}
with gzip.open(f"{self.dsdir}/test{i}{suffix}", 'wb') as f:
pickle.dump(dtest, f)
file_list.append(f'test{i}{suffix}\n')
with open(f"{self.dsdir}/{self.pklname}", 'w') as f:
f.writelines(file_list)
def load(self):
if not os.path.exists(f"{self.dsdir}/{self.pklname}"):
return [], [], []
with open(f"{self.dsdir}/{self.pklname}", 'r') as f:
filelist = [i.strip() for i in f.readlines()]
train_list = [i for i in filelist if 'train' in i]
train_x, train_y = [], []
for i in train_list:
with gzip.open(f"{self.dsdir}/{i}", 'rb') as f:
train = pickle.load(f)
train_x.append(train['train_x'])
train_y.append(train['train_y'])
train_x = np.concatenate(train_x)
train_y = np.concatenate(train_y)
val_list = [i for i in filelist if 'val' in i]
val_x, val_y = [], []
for i in val_list:
with gzip.open(f"{self.dsdir}/{i}", 'rb') as f:
val = pickle.load(f)
val_x.append(val['val_x'])
val_y.append(val['val_y'])
val_x = np.concatenate(val_x)
val_y = np.concatenate(val_y)
test_list = [i for i in filelist if 'test' in i]
if test_list:
test_x = []
for i in test_list:
with gzip.open(f"{self.dsdir}/{i}", 'rb') as f:
test = pickle.load(f)
test_x.append(test['test_x'])
test_x = np.concatenate(test_x)
else:
test_x = None
return [train_x, train_y], [val_x, val_y], test_x
def img_func(self, filename, mode):
img = Image.open(filename)
if img.mode != 'RGB':
print(filename, img.mode)
img = img.convert('RGB')
if mode == 'ignore':
img = np.array(img)
elif mode == 'fill0':
w, h = img.size
if h > self.size[0] or w > self.size[1]:
if h >= w:
_w = int(w / h * self.size[0])
img = img.resize((_w, self.size[0]))
if w > h:
_h = int(h / w * self.size[1])
img = img.resize((self.size[1], _h))
w, h = img.size
p_w = self.size[0] - w
p_h = self.size[1] - h
pad_w = (int(p_w / 2), p_w - int(p_w / 2))
pad_h = (int(p_h / 2), p_h - int(p_h / 2))
img = | np.array(img) | numpy.array |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from sys import argv
from desert.helpers import filename
from numpy import array
from numpy import cos
from numpy import pi
from numpy import sin
from numpy import zeros
from numpy.random import random
from desert import Desert
from desert import stroke
from desert.color import rgb
from desert.color import white
from desert.color import black
from time import time
TWOPI = 2.0*pi
VERBOSE = 'v'
def main(arg):
with Desert(1000, show=True, verbose=VERBOSE)\
.init(fg=black(0.001),
bg=white()) as c:
density = 0.02
a = random(2)*TWOPI
acc = zeros(2)
noise = 0.000000005
rad = 0.45
resa = []
resb = []
for i in range(4000000):
a += acc
acc += (1-2*random(2))*noise
resa.append((cos(a[0]), | sin(a[0]) | numpy.sin |
################################################################################
# Copyright (C) 2011-2014 <NAME>
#
# This file is licensed under the MIT License.
################################################################################
"""
General numerical functions and methods.
"""
import itertools
import numpy as np
import scipy as sp
#import scipy.linalg.decomp_cholesky as decomp
import scipy.linalg as linalg
import scipy.special as special
import scipy.optimize as optimize
import scipy.sparse as sparse
#import scikits.sparse.cholmod as cholmod
# THIS IS SOME NEW GENERALIZED UFUNC FOR LINALG FEATURE, NOT IN OFFICIAL NUMPY
# REPO YET
#import numpy.linalg._gufuncs_linalg as gula
#import numpy.core.gufuncs_linalg as gula
from . import misc
def chol(C, ndim=1):
if sparse.issparse(C):
if ndim != 1:
raise NotImplementedError()
# Sparse Cholesky decomposition (returns a Factor object)
return cholmod.cholesky(C)
else:
# Computes Cholesky decomposition for a collection of matrices.
# The last 2*ndim axes of C are considered as the matrix.
if ndim == 0:
return np.sqrt(C)
shape_original = np.shape(C)[-ndim:]
C = (
C if ndim == 1 else
misc.flatten_axes(C, ndim, ndim)
)
if np.shape(C)[-1] != np.shape(C)[-2]:
raise ValueError("Not square matrix w.r.t. ndim sense")
U = np.empty(np.shape(C))
for i in misc.nested_iterator(np.shape(U)[:-2]):
try:
# Handle (0, 0) matrices. See:
# https://github.com/scipy/scipy/issues/8056
U[i] = (
np.empty((0,0)) if np.size(C[i]) == 0 else
linalg.cho_factor(C[i])[0]
)
except np.linalg.linalg.LinAlgError:
raise Exception("Matrix not positive definite")
return (
U if ndim == 1 else
misc.reshape_axes(U, shape_original, shape_original)
)
def chol_solve(U, b, out=None, matrix=False, ndim=1):
if isinstance(U, np.ndarray) or np.isscalar(U):
if sparse.issparse(b):
b = b.toarray()
if ndim == 0:
return (b / U) / U
shape = np.shape(U)[-ndim:]
U = (
U if ndim == 1 else
misc.flatten_axes(U, ndim, ndim)
)
if matrix:
shape_b = np.shape(b)[-ndim:]
B = (
b if ndim == 1 else
misc.flatten_axes(b, ndim, ndim)
)
B = transpose(B, ndim=1)
U = U[...,None,:,:]
else:
B = (
b if ndim == 1 else
misc.flatten_axes(b, ndim)
)
# Allocate memory
sh_u = U.shape[:-2]
sh_b = B.shape[:-1]
l_u = len(sh_u)
l_b = len(sh_b)
# Check which axis are iterated over with B along with U
ind_b = [slice(None)] * l_b
l_min = min(l_u, l_b)
jnd_b = tuple(i for i in range(-l_min,0) if sh_b[i]==sh_u[i])
if out == None:
# Shape of the result (broadcasting rules)
sh = misc.broadcasted_shape(sh_u, sh_b)
#out = np.zeros(np.shape(B))
out = | np.zeros(sh + B.shape[-1:]) | numpy.zeros |
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.preprocessing.image import array_to_img
from tensorflow import keras
from tensorflow.keras.preprocessing import image_dataset_from_directory
from keras.callbacks import TensorBoard
from time import time
import tensorflow as tf
import os
import json
import base64
from io import BytesIO
from datetime import datetime
from keras.optimizers import Adam
from sklearn.model_selection import train_test_split
import models as models
import numpy as np
import locale
def train_target_score_model(imagesPath, modelPath, tensorboard_gcs_logs, epochs_count, batch_size):
train_images_dir = imagesPath
scores_file = os.path.join(imagesPath, "scores.json")
IMAGE_SIZE = 128
with open(scores_file) as f:
train_data = json.load(f)
labels = []
img_data = []
img_index = 0
#tensorboard_gcs_logs = 'gs://dpa23/tarsanlogs'
img_to_show = []
def add_image(img, rotation, score):
labels.append(score)
if rotation != 0:
r_image = img.rotate(rotation)
else:
r_image = img
img_array = img_to_array(r_image) / 255.0
img_data.append(img_array)
for file_name, score in train_data.items():
full_file_name = os.path.join(train_images_dir, file_name)
print("Loading {} with score {}".format(full_file_name, score))
img = load_img(full_file_name, color_mode="grayscale", target_size=(IMAGE_SIZE,IMAGE_SIZE), interpolation='bilinear')
if img_index < 10:
buffered = BytesIO()
img.save(buffered, format="PNG")
img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
img_to_show.append((img_base64, score, 0.0))
add_image(img, 0, score)
add_image(img, 45, score)
add_image(img, 90, score)
add_image(img, 135, score)
img_index = img_index + 1
np_labels = np.asfarray(labels)
np_image_data = np.asfarray(img_data)
# partition the data into training and testing splits using 75% of
# the data for training and the remaining 25% for testing
split = train_test_split(np_labels, np_image_data, test_size=0.25, random_state=42)
(trainAttrX, testAttrX, trainImagesX, testImagesX) = split
# find the largest score in the training set and use it to
# scale the scores to the range [0, 1]
maxScore = trainAttrX.max()
trainY = trainAttrX / maxScore
testY = testAttrX / maxScore
# create our Convolutional Neural Network and then compile the model
# using mean absolute percentage error as our loss, implying that we
# seek to minimize the absolute percentage difference between our
# score *predictions* and the *actual score*
model = models.create_cnn(IMAGE_SIZE, IMAGE_SIZE, 1, regress=True)
opt = Adam(lr=1e-3, decay=1e-3 / 200)
model.compile(loss="mean_absolute_percentage_error", optimizer=opt)
# Define Tensorboard as a Keras callback
tensorboard = TensorBoard(
log_dir=tensorboard_gcs_logs +'/' + datetime.now().strftime("%Y%m%d-%H%M%S"),
histogram_freq=5,
write_images=True,
update_freq='epoch'
)
keras_callbacks = []
if len(tensorboard_gcs_logs) > 2:
keras_callbacks = [
tensorboard
]
# train the model
print("[INFO] training model...")
model.fit(trainImagesX, trainY, validation_data=(testImagesX, testY),
epochs=epochs_count, batch_size=batch_size, callbacks=keras_callbacks)
print("[INFO] saving model to {} ...".format(modelPath))
model.save(modelPath)
# make predictions on the testing data
print("[INFO] predicting scores prices...")
preds = model.predict(testImagesX)
# compute the difference between the *predicted* scores and the
# *actual* scores, then compute the percentage difference and
# the absolute percentage difference
diff = preds.flatten() - testY
percentDiff = (diff / testY) * 100
absPercentDiff = np.abs(percentDiff)
# compute the mean and standard deviation of the absolute percentage
# difference
mean = | np.mean(absPercentDiff) | numpy.mean |
"""
Dispersed Phases
================
Create several objects and functions to manipulate dispersed phase particles
The `single_bubble_model`, `stratified_plume_model`, and `bent_plume_model`
all must handle dispersed phase particles in several different ways. This
module defines several particle classes that provide seamless interfaces to
the `dbm` module. It also defines several functions that aid in manipulating
common input data to create the inputs needed to initialize these particle
classes. These classes and functions originated in the older versions of
the `single_bubble_model` and `stratified_plume_model`. This module is a
re-factorization of these modules during creation of the `bent_plume_model`,
which allows all particle manipulations to reside in one place.
Notes
-----
These class objects and helper functions are used throughout the TAMOC
modeling suite.
See Also
--------
`stratified_plume_model` : Predicts the plume solution for quiescent ambient
conditions or weak crossflows, where the intrusion (outer plume)
interacts with the upward rising plume in a double-plume integral model
approach. Such a situation is handeled properly in the
`stratified_plume_model` and would violate the assumption of non-
iteracting Lagrangian plume elements as required in this module.
`single_bubble_model` : Tracks the trajectory of a single bubble, drop or
particle through the water column. The numerical solution, including
the various object types and their functionality, used here follows the
pattern in the `single_bubble_model`. The main difference is the more
complex state space and governing equations.
`bent_plume_model` : Simulates a multiphase plume as a Lagrangian plume
model, which makes the model much more amenable to a crossflow. This
model is similar to the `stratified_plume_model`, except that it does
not have an outer plume that interacts with the inner plume (Lagrangian
elements are independent).
"""
# <NAME>, October 2014, Texas A&M University <<EMAIL>>.
from __future__ import (absolute_import, division, print_function)
from tamoc import seawater
from tamoc import dbm
import numpy as np
from scipy.optimize import fsolve
import unicodedata
from copy import copy
# ----------------------------------------------------------------------------
# Define the Particle objects for the multiphase behavior in the TAMOC models
# ----------------------------------------------------------------------------
class SingleParticle(object):
"""
Interface to the `dbm` module and container for model parameters
This class provides a uniform interface to the `dbm` module objects and
methods and stores the particle-specific model parameters. Because the
methods for `dbm.FluidParticle` and `dbm.InsolubleParticle` sometimes have
different inputs and different outputs, there needs to be a method to
support these interface differences in a single location. This object
solves that problem by providing a single interface and uniform outputs
for the particle properties needed by the single bubble model. This also
affords a convenient place to store the particle-specific model
parameters and behavior, such as mass transfer reduction factor, etc.,
turning off heat transfer once the particle matches the ambient
temperature and turning off the particle buoyancy once the particle is
dissolved.
Parameters
----------
dbm_particle : `dbm.FluidParticle` or `dbm.InsolubleParticle` object
Object describing the particle properties and behavior
m0 : ndarray
Initial masses of the components of the `dbm` particle object (kg)
T0 : float
Initial temperature of the of `dbm` particle object (K)
K : float, default = 1.
Mass transfer reduction factor (--).
K_T : float, default = 1.
Heat transfer reduction factor (--).
fdis : float, default = 1e-6
Fraction of the initial total mass (--) remaining when the particle
should be considered dissolved.
t_hyd : float, default = 0.
Hydrate film formation time (s). Mass transfer is computed by clean
bubble methods for t less than t_hyd and by dirty bubble methods
thereafter. The default behavior is to assume the particle is dirty
or hydrate covered from the release.
lag_time : bool, default = True.
Flag that indicates whether (True) or not (False) to use the
biodegradation lag times data.
Attributes
----------
particle : `dbm.FluidParticle` or `dbm.InsolubleParticle` object
Stores the `dbm_particle` object passed to `__init__()`.
composition : str list
Copy of the `composition` attribute of the `dbm_particle` object.
m0 : ndarray
Initial masses (kg) of the particle components
T0 : float
Initial temperature (K) of the particle
cp : float
Heat capacity at constant pressure (J/(kg K)) of the particle.
K : float
Mass transfer reduction factor (--)
K_T : float
Heat transfer reduction factor (--)
fdis : float
Fraction of initial mass remaining as total dissolution (--)
diss_indices : ndarray bool
Indices of m0 that are non-zero.
Notes
-----
This object only provides an interface to the `return_all` and
`diameter` methods of the `dbm` module objects. The intent is to be as
fast as possible while providing a single location for the necessary
`if`-statements needed to select between soluble and insoluble particle
methods and facilitate turning heat transfer and dissolution on and off
as necessary at the simulation progresses.
Dissolution is turned off component by component as each components mass
becomes fdis times smaller than the initial mass. Once all of the initial
components have been turned off, the particle is assumed to have a
density equation to the ambient water and a slip velocity of zero.
Heat transfer is turned off once the particle comes within 0.1 K of the
ambient temperature. Thereafter, the temperature is forced to track
the ambient temperature.
"""
def __init__(self, dbm_particle, m0, T0, K=1., K_T=1., fdis=1.e-6,
t_hyd=0., lag_time=True):
super(SingleParticle, self).__init__()
# Make sure the masses are in a numpy array
if not isinstance(m0, np.ndarray):
if not isinstance(m0, list):
m0 = np.array([m0])
else:
m0 = np.array(m0)
# Store the input parameters
self.particle = dbm_particle
self.composition = dbm_particle.composition
self.m0 = m0
self.T0 = T0
self.cp = seawater.cp() * 0.5
self.lag_time = lag_time
# Store the particle-specific model parameters
self.K = K
self.K_T = K_T
self.fdis = fdis
self.t_hyd = t_hyd
self.lag_time = lag_time
# Store parameters to track the dissolution of the initial masses
self.diss_indices = self.m0 > 0
def properties(self, m, T, P, Sa, Ta, t):
"""
Return the particle properties from the discrete bubble model
Provides a single interface to the `return_all` methods of the fluid
and insoluble particle objects defined in the `dbm` module.
This method also applies the particle-specific model parameters to
adjust the mass and heat transfer and determine the dissolution state.
Parameters
----------
m : float
mass of the particle (kg)
T : float
particle temperature (K)
P : float
particle pressure (Pa)
Sa : float
salinity of ambient seawater (psu)
Ta : float
temperature of ambient seawater (K)
t : float
age of the particle--time since it was released into the water
column (s)
Returns
-------
A tuple containing:
us : float
slip velocity (m/s)
rho_p : float
particle density (kg/m^3)
A : float
surface area (m^2)
Cs : ndarray, size (nc)
solubility (kg/m^3)
K * beta : ndarray, size (nc)
effective mass transfer coefficient(s) (m/s)
K_T * beta_T : float
effective heat transfer coefficient (m/s)
T : float
temperature of the particle (K)
Notes
-----
For insoluble particles, `Cs` and `beta` are undefined. This method
returns values for these variables that will result in no
dissolution and will also protect model simulations from undefined
mathematical operations (e.g., divide by zero).
"""
# Turn off heat transfer when at equilibrium. This will be a
# persistent change, so it only has to happen once.
if self.K_T > 0. and np.abs(Ta - T) < 0.5:
self.K_T = 0.
# Use the right temperature
if self.K_T == 0.:
T = Ta
# Decide which slip velocity and mass and heat transfer to use
if t < self.t_hyd:
# Treat the particle as clean for slip velocity and mass
# transfer
status = 1
else:
# Use the dirty bubble slip velocity and mass transfer
status = -1
# Distinguish between soluble and insoluble particles
if self.particle.issoluble:
# Get the DBM results
m[m<0] = 0. # stop oscillations at small mass
shape, de, rho_p, us, A, Cs, beta, beta_T = \
self.particle.return_all(m, T, P, Sa, Ta, status)
# Turn off dissolution for "dissolved" components
frac_diss = np.ones(np.size(m))
frac_diss[self.diss_indices] = \
m[self.diss_indices] / self.m0[self.diss_indices]
beta[frac_diss < self.fdis] = 0.
# Shut down bubble forces when particles fully dissolve
if np.sum(beta[self.diss_indices]) == 0.:
# Injected chemicals have dissolved
if np.sum(m[self.diss_indices]) > \
np.sum(m[~self.diss_indices]):
# The whole particle has dissolved
us = 0.0
rho_p = seawater.density(Ta, Sa, P)
else:
# Get the particle properties
shape, de, rho_p, us, A, beta_T = \
self.particle.return_all(m[0], T, P, Sa, Ta, status)
beta = np.array([])
Cs = np.array([])
# Return the particle properties
return (us, rho_p, A, Cs, self.K * beta, self.K_T * beta_T, T)
def diameter(self, m, T, P, Sa, Ta):
"""
Compute the diameter of a particle from mass and density
Computes the diameter of a particle using the methods in the `dbm`
module. This method is used in the post-processor of the `Model`
object, but not in the actual simulation.
Parameters
----------
m : float
mass of the particle (kg)
T : float
particle temperature (K)
P : float
particle pressure (Pa)
Sa : float
salinity of ambient seawater (psu)
Ta : float
temperature of ambient seawater (K)
Returns
-------
de : float
diameter of the particle (m)
"""
# Distinguish between soluble and insoluble particles
if self.particle.issoluble:
de = self.particle.diameter(m, T, P)
else:
de = self.particle.diameter(m, T, P, Sa, Ta)
# Return the diameter
return de
def biodegradation_rate(self, t):
"""
Compute the biodegradation rate constants
Computes the biodegradation rate constants using the method in the
`dbm` module.
Parameters
----------
t : float
current simulation time (s)
Returns
-------
k_bio : ndarray, size (nc)
first-order biodegradation rate constants (1/s)
"""
return self.particle.biodegradation_rate(t, self.lag_time)
class PlumeParticle(SingleParticle):
"""
Interface to the `dbm` module and container for the model parameters
As in the `single_bubble_model.Particle` class, this object provides a
uniform interface to the `dbm` module objects and captures the
particle-specific model parameters.
Parameters
----------
dbm_particle : `dbm.FluidParticle` or `dbm.InsolubleParticle` object
Object describing the particle properties and behavior
m0 : ndarray
Initial masses of one particle for the components of the
`dbm_particle` object (kg)
T0 : float
Initial temperature of the of `dbm` particle object (K)
nb0 : float
Initial number flux of particles at the release (--)
lambda_1 : float
spreading rate of the dispersed phase in a plume (--)
P : float
Local pressure (Pa)
Sa : float
Local salinity surrounding the particle (psu)
Ta : float
Local temperature surrounding the particle (K)
K : float, default = 1.
Mass transfer reduction factor (--).
K_T : float, default = 1.
Heat transfer reduction factor (--).
fdis : float, default = 0.01
Fraction of the initial total mass (--) remaining when the particle
should be considered dissolved.
t_hyd : float, default = 0.
Hydrate film formation time (s). Mass transfer is computed by clean
bubble methods for t less than t_hyd and by dirty bubble methods
thereafter. The default behavior is to assume the particle is dirty
or hydrate covered from the release.
lag_time : bool, default = True.
Flag that indicates whether (True) or not (False) to use the
biodegradation lag times data.
Attributes
----------
particle : `dbm.FluidParticle` or `dbm.InsolubleParticle` object
Stores the `dbm_particle` object passed to `__init__()`.
composition : str list
Copy of the `composition` attribute of the `dbm_particle` object.
m0 : ndarray
Initial masses (kg) of the particle components
T0 : float
Initial temperature (K) of the particle
cp : float
Heat capacity at constant pressure (J/(kg K)) of the particle.
K : float
Mass transfer reduction factor (--)
K_T : float
Heat transfer reduction factor (--)
fdis : float
Fraction of initial mass remaining as total dissolution (--)
diss_indices : ndarray bool
Indices of m0 that are non-zero.
nb0 : float
Initial number flux of particles at the release (--)
lambda_1 : float
Spreading rate of the dispersed phase in a plume (--)
m : ndarray
Current masses of the particle components (kg)
T : float
Current temperature of the particle (K)
us : float
Slip velocity (m/s)
rho_p : float
Particle density (kg/m^3)
A : float
Particle surface area (m^2)
Cs : ndarray
Solubility of each dissolving component in the particle (kg/m^3)
beta : ndarray
Mass transfer coefficients (m/s)
beta_T : float
Heat transfer coefficient (m/s)
See Also
--------
single_bubble_model.Particle
Notes
-----
This object inherits the `single_bubble_model.Particle` object, which
defines the attributes: `particle`, `composition`, `m0`, `T0`, `cp`,
`K`, `K_T`, `fdis`, and `diss_indices` and the methods
`single_bubble_model.Particle.properties`, and
`single_bubble_model.Particle.diameter`.
"""
def __init__(self, dbm_particle, m0, T0, nb0, lambda_1, P, Sa, Ta,
K=1., K_T=1., fdis=1.e-6, t_hyd=0., lag_time=True):
super(PlumeParticle, self).__init__(dbm_particle, m0, T0, K, K_T,
fdis, t_hyd, lag_time)
# Store the input variables related to the particle description
self.nb0 = nb0
# Store the model parameters
self.lambda_1 = lambda_1
# Set the local masses and temperature to their initial values. The
# particle age is zero at instantiation
self.update(m0, T0, P, Sa, Ta, 0.)
def update(self, m, T, P, Sa, Ta, t):
"""
Store the instantaneous values of the particle properties
During the simulation, it is often helpful to keep the state space
variables for each particle stored within the particle, especially
since each particle type (soluble or insoluble) can have different
sizes of arrays for m.
Parameters
----------
m : ndarray
Current masses (kg) of the particle components
T : float
Current temperature (K) of the particle
P : float
Local pressure (Pa)
Sa : float
Local salinity surrounding the particle (psu)
Ta : float
Local temperature surrounding the particle (K)
t : float
age of the particle--time since it was released into the water
column (s)
"""
# Make sure the masses are in a numpy array
if not isinstance(m, np.ndarray):
if not isinstance(m, list):
m = np.array([m])
else:
m = np.array(m)
# Update the variables with their currrent values
self.m = m
if np.sum(self.m) > 0.:
self.us, self.rho_p, self.A, self.Cs, self.beta, \
self.beta_T, self.T = self.properties(m, T, P, Sa, Ta, t)
self.k_bio = self.biodegradation_rate(t)
else:
self.us = 0.
self.rho_p = seawater.density(Ta, Sa, P)
self.A = 0.
self.Cs = np.zeros(len(self.composition))
self.beta = np.zeros(len(self.composition))
self.beta_T = 0.
self.T = Ta
self.k_bio = np.zeros(len(self.composition))
# ----------------------------------------------------------------------------
# Functions that help to create SingleParticle and PlumeParticle objects
# ----------------------------------------------------------------------------
def initial_conditions(profile, z0, dbm_particle, yk, q, q_type, de,
T0=None):
"""
Define standard initial conditions for a PlumeParticle from flow rate
Returns the standard variables describing a particle as needed to
initializae a PlumeParticle object from specification of the dispersed phase
flow rate.
Parameters
----------
profile : `ambient.Profile` object
The ambient CTD object used by the simulation.
z0 : float
Depth of the release point (m)
dbm_particle : `dbm.FluidParticle` or `dbm.InsolubleParticle` object
Object describing the particle properties and behavior
yk : ndarray
Vector of mol fractions of each component of the dispersed phase
particle. If the particle is a `dbm.InsolubleParticle`, then yk
should be equal to one.
q : float
Flux of the dispersed phase, either as the volume flux (m^3/s) at
standard conditions, defined as 0 deg C and 1 bar, or as mass flux
(kg/s).
q_type : int
Determines the type of flux units. 0: we want the mass of a single
particle (hence q = None since it is currently unknown), 1: q is
volume flux, 2: q is mass flux
de : float
Initial diameter (m) of the particle
T0 : float, default = None
Initial temperature of the of `dbm` particle object (K). If None,
then T0 is set equal to the ambient temperature.
Returns
-------
m0 : ndarray
Initial masses of the components of one particle in the `dbm`
particle object (kg)
T0 : float
Initial temperature of the of `dbm` particle object (K)
nb0 : float
Initial number flux of particles at the release (--)
P : float
Local pressure (Pa)
Sa : float
Local salinity surrounding the particle (psu)
Ta : float
Local temperature surrounding the particle (K)
"""
# Make sure yk is an array
if not isinstance(yk, np.ndarray):
if not isinstance(yk, list):
yk = np.array([yk])
else:
yk = np.array(yk)
# Get the ambient conditions at the release
Ta, Sa, P = profile.get_values(z0, ['temperature', 'salinity',
'pressure'])
# Get the particle temperature
if T0 is None:
T0 = copy(Ta)
# Compute the density at standard and in situ conditions
if dbm_particle.issoluble:
mf = dbm_particle.mass_frac(yk)
rho_N = dbm_particle.density(mf, 273.15, 1.e5)
rho_p = dbm_particle.density(mf, T0, P)
else:
mf = 1.
rho_N = dbm_particle.density(273.15, 1.e5, 0., 273.15)
rho_p = dbm_particle.density(T0, P, Sa, Ta)
# Get the mass and number flux of particles
if q_type == 0:
# Compute the mass flux of a single particle from the given diameter
if dbm_particle.issoluble:
m0 = dbm_particle.masses_by_diameter(de, T0, P, yk)
else:
m0 = dbm_particle.mass_by_diameter(de, T0, P, Sa, Ta)
nb0 = 1.
else:
if q_type == 1:
# Compute the total mass flux from the given volume flux at STP
m_dot = q * rho_N
else:
# The input flux is the total mass flux
m_dot = q
# Get the source volume flux and particle number flux
Q = m_dot / rho_p
nb0 = Q / (np.pi * de**3 / 6.)
# Get the initial particle mass(es)
m0 = m_dot / nb0 * mf
# Return the standard variables
return (m0, T0, nb0, P, Sa, Ta)
# ----------------------------------------------------------------------------
# Functions to save and load a particle to an open netCDF4 dataset
# ----------------------------------------------------------------------------
def save_particle_to_nc_file(nc, chem_names, particles, K_T0):
"""
Write the particle attributes to a netCDF output file
Writes all of the object attributes for a `SingleParticle` or
`PlumeParticle` object to a netCDF output file.
Parameters
----------
nc : `netCDF4.Dataset` object
A `netCDF4.Dataset` object that is open and where the particle
attributes should be written
chem_names : str list
A list of chemical names in the composition of the `dbm` objects
in these particles
particles : list of `Particle` objects
List of `SingleParticle`, `PlumeParticle`, or
`bent_plume_model.Particle` objects describing each dispersed phase
in the simulation
K_T0 : ndarray
Array of the initial values of the heat transfer reduction factor.
"""
# Make sure the particles variable is iterable
if not isinstance(particles, list):
particles = [particles]
# Make sure K_T0 is an array
if not isinstance(K_T0, np.ndarray):
if not isinstance(K_T0, list):
K_T0 = np.array([K_T0])
else:
K_T0 = np.array(K_T0)
# Count the number of particles
nparticles = nc.createDimension('nparticles', len(particles))
ngroups = nc.createDimension('ngroups', 15)
if len(chem_names) > 0:
nchems = nc.createDimension('nchems', len(chem_names))
else:
nchems = nc.createDimension('nchems', 1)
num = nc.createDimension('num', 1)
# Save the particle composition
nc.composition = ' '.join(chem_names)
# Create the dataset descriptions for all the particle variables
particle_type = nc.createVariable('particle_type', 'i4', ('num',))
particle_type.long_name = 'dispersed_phases Particle type'
particle_type.standard_name = 'particle_type'
particle_type.units = '0: Single, 1:Plume, 2:Bent plume particle'
issoluble = nc.createVariable('issoluble', 'i4', ('nparticles',))
issoluble.long_name = 'solubility (0: false, 1: true)'
issoluble.standard_name = 'issoluble'
issoluble.units = 'boolean'
isair = nc.createVariable('isair', 'i4', ('nparticles',))
isair.long_name = 'fluid is air (0: false, 1: true)'
isair.standard_name = 'isair'
isair.units = 'boolean'
isfluid = nc.createVariable('isfluid', 'i4', ('nparticles',))
isfluid.long_name = 'Fluid status (0: false, 1: true)'
isfluid.standard_name = 'isfluid'
isfluid.units = 'boolean'
iscompressible = nc.createVariable('iscompressible', 'i4',
('nparticles',))
iscompressible.long_name = 'Compressibility (0: false, 1: true)'
iscompressible.standard_name = 'iscompressible'
iscompressible.units = 'boolean'
calc_delta = nc.createVariable('calc_delta', 'i4', ('nparticles',))
calc_delta.long_name = 'Calculate delta (-1: false, 1: true)'
calc_delta.standard_name = 'calc_delta'
calc_delta.units = 'boolean'
extern_data = nc.createVariable('extern_data', 'i4', ('nparticles',))
extern_data.long_name = 'External chem database (0: false, 1: true)'
extern_data.standard_name = 'extern_data'
extern_data.units = 'boolean'
fp_type = nc.createVariable('fp_type', 'i4', ('nparticles',))
fp_type.long_name = 'fluid phase (0: gas, 1: liquid, 2: solid)'
fp_type.standard_name = 'fp_type'
fp_type.units = 'nondimensional'
rho_p = nc.createVariable('rho_p', 'f8', ('nparticles',))
rho_p.long_name = 'particle density'
rho_p.standard_name = 'rho_p'
rho_p.units = 'kg/m^3'
gamma = nc.createVariable('gamma', 'f8', ('nparticles',))
gamma.long_name = 'API Gravity'
gamma.standard_name = 'gamma'
gamma.units = 'deg API'
beta = nc.createVariable('beta', 'f8', ('nparticles',))
beta.long_name = 'thermal expansion coefficient'
beta.standard_name = 'beta'
beta.units = 'Pa^(-1)'
co = nc.createVariable('co', 'f8', ('nparticles',))
co.long_name = 'isothermal compressibility coefficient'
co.standard_name = 'co'
co.units = 'K^(-1)'
sigma_correction = nc.createVariable('sigma_correction', 'f8',
('nparticles',))
sigma_correction.long_name = 'interfacial tension reduction factor (--)'
sigma_correction.standard_name = 'sigma_correction'
sigma_correction.units = 'nondimensional'
delta_groups = nc.createVariable('delta_groups', 'f8', ('nparticles',
'nchems', 'ngroups'))
delta_groups.long_name = 'group contribution method delta groups'
delta_groups.standard_name = 'delta_groups'
delta_groups.units = 'nondimensional'
m0 = nc.createVariable('m0', 'f8', ('nparticles', 'nchems'))
m0.long_name = 'initial mass flux'
m0.standard_name = 'm0'
m0.units = 'kg/s'
T0 = nc.createVariable('T0', 'f8', ('nparticles'))
T0.long_name = 'initial temperature'
T0.standard_name = 'T0'
T0.units = 'K'
K = nc.createVariable('K', 'f8', ('nparticles',))
K.long_name = 'mass transfer reduction factor'
K.standard_name = 'K'
K.units = 'nondimensional'
K_T = nc.createVariable('K_T', 'f8', ('nparticles',))
K_T.long_name = 'heat transfer reduction factor'
K_T.standard_name = 'K_T'
K_T.units = 'nondimensional'
fdis = nc.createVariable('fdis', 'f8', ('nparticles',))
fdis.long_name = 'dissolution criteria'
fdis.standard_name = 'fdis'
fdis.units = 'nondimensional'
t_hyd = nc.createVariable('t_hyd', 'f8', ('nparticles',))
t_hyd.long_name = 'hydrate formation time'
t_hyd.standard_name = 't_hyd'
t_hyd.units = 's'
# Check if these are plume particle objects
try:
particles[0].integrate
# Must be bent_plume_model.Particle object
particle_type[0] = 2
nb0 = nc.createVariable('nb0', 'f8', ('nparticles'))
nb0.long_name = 'initial bubble number flux'
nb0.standard_name = 'nb0'
nb0.units = 's^(-1)'
nbe = nc.createVariable('nbe', 'f8', ('nparticles'))
nbe.long_name = 'number of bubbles following plume element'
nbe.standard_name = 'nbe'
nbe.units = 'count'
lambda_1 = nc.createVariable('lambda_1', 'f8', ('nparticles'))
lambda_1.long_name = 'bubble spreading ratio'
lambda_1.standard_name = 'lambda_1'
lambda_1.units = 'nondimensional'
integrate = nc.createVariable('integrate', 'i4', ('nparticles',))
integrate.long_name = 'Particle status (0: false, 1: true)'
integrate.standard_name = 'integrate'
integrate.units = 'boolean'
sim_stored = nc.createVariable('sim_stored', 'i4', ('nparticles',))
sim_stored.long_name = 'Tracking state (0: false, 1: true)'
sim_stored.standard_name = 'sim_stored'
sim_stored.units = 'boolean'
farfield = nc.createVariable('farfield', 'i4', ('nparticles',))
farfield.long_name = 'Farfield simualtion (0: false, 1: true)'
farfield.standard_name = 'farfield'
farfield.units = 'boolean'
tp = nc.createVariable('tp', 'f8', ('nparticles'))
tp.long_name = 'time'
tp.standard_name = 't'
tp.units = 's'
xp = nc.createVariable('xp', 'f8', ('nparticles'))
xp.long_name = 'x-coordinate'
xp.standard_name = 'x'
xp.units = 'm'
yp = nc.createVariable('yp', 'f8', ('nparticles'))
yp.long_name = 'y-coordinate'
yp.standard_name = 'y'
yp.units = 'm'
zp = nc.createVariable('zp', 'f8', ('nparticles'))
zp.long_name = 'z-coordinate'
zp.standard_name = 'z'
zp.units = 'm'
zp.axis = 'Z'
zp.positive = 'down'
te = nc.createVariable('te', 'f8', ('nparticles'))
te.long_name = 'particle exit time'
te.standard_name = 'te'
te.units = 's'
xe = nc.createVariable('xe', 'f8', ('nparticles'))
xe.long_name = 'particle exit x-coordinate'
xe.standard_name = 'xe'
xe.units = 'm'
ye = nc.createVariable('ye', 'f8', ('nparticles'))
ye.long_name = 'particle exit y-coordinate'
ye.standard_name = 'ye'
ye.units = 'm'
ze = nc.createVariable('ze', 'f8', ('nparticles'))
ze.long_name = 'particle exit z-coordinate'
ze.standard_name = 'ze'
ze.units = 'm'
ze.axis = 'Z'
ze.positive = 'down'
except AttributeError:
try:
particles[0].nb0
# Must be PlumeParticle object
particle_type[0] = 1
nb0 = nc.createVariable('nb0', 'f8', ('nparticles'))
nb0.long_name = 'initial bubble number flux'
nb0.standard_name = 'nb0'
nb0.units = 's^(-1)'
lambda_1 = nc.createVariable('lambda_1', 'f8', ('nparticles'))
lambda_1.long_name = 'bubble spreading ratio'
lambda_1.standard_name = 'lambda_1'
lambda_1.units = 'nondimensional'
except AttributeError:
particle_type[0] = 0
# Check if we need to reserve space to store an external chemical data
# base of user_data
next_chems = 0
for i in range(len(particles)):
if particles[i].particle.issoluble:
if len(particles[i].particle.user_data) > next_chems:
next_chems = len(particles[i].particle.user_data)
# Python 3 will not index a dict_keys() object because that
# is not a good thing to do. However, that is what we do
# below...hence, we need to make the dict_keys into a list
user_composition = \
list(particles[i].particle.user_data.keys())
if next_chems > 0:
next_chems = nc.createDimension('next_chems', next_chems)
nc.user_composition = ' '.join(user_composition)
M = nc.createVariable('M', 'f8', ('nparticles', 'next_chems'))
M.long_name = 'molecular weight'
M.standard_name = 'M'
M.units = 'kg/mol'
Pc = nc.createVariable('Pc', 'f8', ('nparticles', 'next_chems'))
Pc.long_name = 'pressure at the critical point'
Pc.standard_name = 'Pc'
Pc.units = 'Pa'
Tc = nc.createVariable('Tc', 'f8', ('nparticles', 'next_chems'))
Tc.long_name = 'temperature at the critical point'
Tc.standard_name = 'Tc'
Tc.units = 'K'
Vc = nc.createVariable('Vc', 'f8', ('nparticles', 'next_chems'))
Vc.long_name = 'molar volume at the critical point'
Vc.standard_name = 'Vc'
Vc.units = 'm^3/mol'
Tb = nc.createVariable('Tb', 'f8', ('nparticles', 'next_chems'))
Tb.long_name = 'boiling point'
Tb.standard_name = 'Tb'
Tb.units = 'K'
Vb = nc.createVariable('Vb', 'f8', ('nparticles', 'next_chems'))
Vb.long_name = 'molar volume at the boiling point'
Vb.standard_name = 'Vb'
Vb.units = 'm^3/mol'
omega = nc.createVariable('omega', 'f8', ('nparticles',
'next_chems'))
omega.long_name = 'acentric factor'
omega.standard_name = 'omega'
omega.units = 'nondimensional'
kh_0 = nc.createVariable('kh_0', 'f8', ('nparticles', 'next_chems'))
kh_0.long_name = 'Henrys law constant at 298.15 K'
kh_0.standard_name = 'kh_0'
kh_0.units = 'kg/(m^3 Pa)'
neg_dH_solR = nc.createVariable('neg_dH_solR', 'f8', ('nparticles',
'next_chems'))
neg_dH_solR.long_name = 'negative of the enthalpy of solution / R'
neg_dH_solR.standard_name = 'neg_dH_solR'
neg_dH_solR.units = 'K'
nu_bar = nc.createVariable('nu_bar', 'f8', ('nparticles',
'next_chems'))
nu_bar.long_name = 'specific volume at infinite dilution'
nu_bar.standard_name = 'nu_bar'
nu_bar.units = 'm^3/mol'
B = nc.createVariable('B', 'f8', ('nparticles', 'next_chems'))
B.long_name = 'diffusivity model coefficient B'
B.standard_name = 'B'
B.units = 'm^2/s'
dE = nc.createVariable('dE', 'f8', ('nparticles', 'next_chems'))
dE.long_name = 'diffusivity model coefficient dE'
dE.standard_name = 'dE'
dE.units = 'J/mol'
K_salt = nc.createVariable('K_salt', 'f8', ('nparticles',
'next_chems'))
K_salt.long_name = 'Setschenow salting out correction for solubility'
K_salt.standard_name = 'K_salt'
K_salt.units = 'm^3/mol'
# Store the values for each particle in the list
for i in range(len(particles)):
# Store the variables needed to create dbm particle objects
if particles[i].particle.issoluble:
issoluble[i] = 1
isfluid[i] = 1
isair[i] = particles[i].particle.isair
iscompressible[i] = 1
fp_type[i] = particles[i].particle.fp_type
calc_delta[i] = particles[i].particle.calc_delta
if len(particles[i].particle.user_data) == 0:
extern_data[i] = 0
else:
extern_data[i] = 1
user_data = particles[i].particle.user_data
for j in range(len(user_composition)):
M[i,j] = user_data[user_composition[j]]['M']
Pc[i,j] = user_data[user_composition[j]]['Pc']
Tc[i,j] = user_data[user_composition[j]]['Tc']
Vc[i,j] = user_data[user_composition[j]]['Vc']
Tb[i,j] = user_data[user_composition[j]]['Tb']
Vb[i,j] = user_data[user_composition[j]]['Vb']
omega[i,j] = user_data[user_composition[j]]['omega']
kh_0[i,j] = user_data[user_composition[j]]['kh_0']
neg_dH_solR[i,j] = \
user_data[user_composition[j]]['-dH_solR']
nu_bar[i,j] = user_data[user_composition[j]]['nu_bar']
B[i,j] = user_data[user_composition[j]]['B']
dE[i,j] = user_data[user_composition[j]]['dE']
K_salt[i,j] = user_data[user_composition[j]]['K_salt']
sigma_correction[i] = particles[i].particle.sigma_correction
if particles[i].particle.calc_delta:
delta_groups[i,:,:] = particles[i].particle.delta_groups
else:
delta_groups[i,:,:] = np.zeros((len(chem_names),15))
m0[i,:] = particles[i].m0
rho_p[i] = -1.
gamma[i] = -1.
beta[i] = -1.
co[i] = -1.
else:
issoluble[i] = 0
isair[i] = 0
if particles[i].particle.isfluid:
isfluid[i] = 1
else:
isfluid[i] = 0
if particles[i].particle.iscompressible:
iscompressible[i] = 1
else:
iscompressible[i] = 0
fp_type[i] = 3
calc_delta[i] = -1
sigma_correction[i] = 1.
m0[i,0] = particles[i].m0
rho_p[i] = particles[i].particle.rho_p
gamma[i] = particles[i].particle.gamma
beta[i] = particles[i].particle.beta
co[i] = particles[i].particle.co
# Store the variables needed to create dispersed_phases SingleParticle
# or PlumeParticle objects
T0[i] = particles[i].T0
K[i] = particles[i].K
K_T[i] = K_T0[i]
fdis[i] = particles[i].fdis
t_hyd[i] = particles[i].t_hyd
if particle_type[0] == 1 or particle_type[0] == 2:
nb0[i] = particles[i].nb0
lambda_1[i] = particles[i].lambda_1
if particle_type[0] == 2:
nb0[i] = particles[i].nb0
nbe[i] = particles[i].nbe
lambda_1[i] = particles[i].lambda_1
integrate[i] = particles[i].integrate
sim_stored[i] = particles[i].sim_stored
farfield[i] = particles[i].farfield
tp[i] = particles[i].t
xp[i] = particles[i].x
yp[i] = particles[i].y
zp[i] = particles[i].z
try:
te[i] = particles[i].te
xe[i] = particles[i].xe
ye[i] = particles[i].ye
ze[i] = particles[i].ze
except:
pass
def load_particle_from_nc_file(nc):
"""
Read the complete `particles` list from a netCDF output file
Creates the `particles` list of `SingleParticle`, `PlumeParticle`, or
`bent_plume_model.Particle` objects from the attributes stored in a
netCDF output file.
Parameters
----------
nc : `netCDF4.Dataset` object
A `netCDF4.Dataset` object that is open and where the particle
attributes should be written
particle_type : int
The particle type is either 0: `SingleParticle`, 1: `PlumeParticle`
or 2: `bent_plume_model.Particle`
X0 : ndarray
Vector of initial positions for the `bent_plume_model.Particle`
objects.
"""
# All particles have the same composition
chem_names = str(nc.composition).split()
# Load each particle object separately
particles = []
for i in range(len(nc.dimensions['nparticles'])):
# Create the correct dbm object
if nc.variables['issoluble'][i]:
if nc.variables['extern_data'][i]:
user_data = {}
user_composition = str(nc.user_composition).split()
for j in range(len(user_composition)):
user_data[user_composition[j]] = {}
user_data[user_composition[j]]['M'] = \
nc.variables['M'][i,j]
user_data[user_composition[j]]['Pc'] = \
nc.variables['Pc'][i,j]
user_data[user_composition[j]]['Tc'] = \
nc.variables['Tc'][i,j]
user_data[user_composition[j]]['Vc'] = \
nc.variables['Vc'][i,j]
user_data[user_composition[j]]['Tb'] = \
nc.variables['Tb'][i,j]
user_data[user_composition[j]]['Vb'] = \
nc.variables['Vb'][i,j]
user_data[user_composition[j]]['omega'] = \
nc.variables['omega'][i,j]
user_data[user_composition[j]]['kh_0'] = \
nc.variables['kh_0'][i,j]
user_data[user_composition[j]]['-dH_solR'] = \
nc.variables['neg_dH_solR'][i,j]
user_data[user_composition[j]]['nu_bar'] = \
nc.variables['nu_bar'][i,j]
user_data[user_composition[j]]['B'] = \
nc.variables['B'][i,j]
user_data[user_composition[j]]['dE'] = \
nc.variables['dE'][i,j]
user_data[user_composition[j]]['K_salt'] = \
nc.variables['K_salt'][i,j]
else:
user_data = {}
if nc.variables['calc_delta'][i]:
delta_groups = nc.variables['delta_groups'][i,:,:]
else:
delta_groups = None
particle = dbm.FluidParticle(chem_names,
fp_type=nc.variables['fp_type'][i],
user_data=user_data,
delta_groups=delta_groups,
isair=nc.variables['isair'][i],
sigma_correction=nc.variables['sigma_correction'][i])
m0 = np.array(nc.variables['m0'][i,:])
else:
if nc.variables['isfluid'][i]:
isfluid = True
else:
isfluid = False
if nc.variables['iscompressible'][i]:
iscompressible = True
else:
iscompressible = False
particle = dbm.InsolubleParticle(isfluid, iscompressible,
rho_p=nc.variables['rho_p'][i],
gamma=nc.variables['gamma'][i],
beta=nc.variables['beta'][i],
co=nc.variables['co'][i])
m0 = | np.array([nc.variables['m0'][i,0]]) | numpy.array |
import numpy as np
import matplotlib.pyplot as plt
import math
import matplotlib.patches as patches
import matplotlib.animation as animation
import gym
import random
from datetime import date
float_formatter = "{:.2f}".format
np.set_printoptions(formatter={'float_kind':float_formatter})
import numpy as np
#%matplotlib qt
import matplotlib.pyplot as plt
import math
import matplotlib.patches as patches
from matplotlib.collections import PatchCollection
import matplotlib.animation as animation
from matplotlib.offsetbox import TextArea, DrawingArea, OffsetImage, AnnotationBbox
import matplotlib.image as mpimg
float_formatter = "{:.2f}".format
np.set_printoptions(formatter={'float_kind':float_formatter})
class UnbreakableSeaweed(gym.Env):
"""
Description:
A one D model of Aplysia californica feeding.
The goal is to ingest the most edible food
Source:
This enviornment cooresponds to the model of Aplysia feeding presented in
Control for Multifunctionality: Bioinspired Control Based on Feeding in Aplysia californica
2
Observation (7-element):
Type:
Num Observation Min Max
0 x_h 0 1
1 x_g 0 1
2 force_on_object -Inf Inf
3 pressure_grasper -Inf Inf
4 pressure_jaws -Inf Inf
5 edible -1 1
6 grasper_friction_state 0 1
Actions (32-element):
Type: 5 element array
element 0 - B7 state
element 1 - B6/B9/B3 state
element 2 - B 8a/b state
element 3 - B31/B32 state
element 4 - B38 state
Control frequency: 20 Hz
Reward:
Reward is proportional to the amount of seaweed ingested
Episode Termination:
Episode is greater than max_steps_per_iteration. Default: 1000
"""
##properties for visualization
#define the location of the ground plane
x_ground = np.array([[0],[0]])
len_ground_line = 5
#define the location of the force transducer
x_transducer = x_ground + np.array([[8],[0]])
len_transducer_line = 5
#define location and shape of head
x_H = x_ground + np.array([[0],[0]])
x_H_width = 1
x_H_height = 4
#define the extents of the grasper protraction/retraction path
grasper_origin = x_H + np.array([[0],[0]])
grasper_full = grasper_origin + np.array([[1],[0]])
#define the starting position for the bottom of the grasper along this track
x_R = grasper_origin + np.array([[0],[0]])
#specify vectors based on the grasper in the upright position
theta_grasper_initial = math.pi/2
#specify the grasper radius
r_grasper = 1
grasper_offset = 1
#define the positions of the I2 muscle origins
x_I2_Borigin = grasper_origin + np.array([[0],[0]])
x_I2_Aorigin = grasper_origin + np.array([[0],[2*r_grasper]])
#define the position of the hinge origin
x_hinge_origin = grasper_origin + np.array([[0],[0]])
#specify the angle relative to horizontal for each of the attachment points fixed on the grasper surface
theta_s = 0
theta_I2_A = math.pi/6
theta_I2_B = math.pi/6
#plot line representing ground
line_ground =[]
#plot a dot at the origin
dot_ground =[]
#plot line representing force transducer
line_transducer =[]
#plot line representing track
line_grapser_track =[]
#plot line from R to G
line_RG =[]
#plot dot at point R
dot_R =[]
#plot dot at point G
dot_G =[]
#plot dot at point S
dot_S =[]
#plot dot at I2 attachment point A
dot_I2_A =[]
#plot dot at I2 attachment point B
dot_I2_B =[]
#plot dot at I2 attachment point A
dot_I2_Aorigin =[]
#plot dot at I2 attachment point B
dot_I2_Borigin =[]
#draw grasper
draw_circle =[]
#draw head
head =[]
dot_H_spring =[]
#draw head spring as dashed line
line_H_spring =[]
#draw grasper to head spring as dashed line
line_G_spring =[]
preset_inputs = 0
generat_plots_toggle = 0
init_reward = 0.0
init_force_level = 'low'
high_threshold = 4
low_threshold = 40
output_expert_mean = | np.load('output_expert_mean.npy') | numpy.load |
import tensorflow as tf
import numpy as np
from FUNCTION import *
def psnr(input, label, shave):
assert (label.dtype == input.dtype)
if shave != 0:
input = input[shave:-shave, shave:-shave, :]
label = label[shave:-shave, shave:-shave, :]
diff = np.int32(label) - | np.int32(input) | numpy.int32 |
"""
Generating target function, featurizer, and train/validation/test splits for the Lasso homework.
Author: <NAME> <<EMAIL>>
License: Creative Commons Attribution 4.0 International License
"""
import random
import numpy as np
import matplotlib.pyplot as plt
import pickle
def step_fn_generator(stepLoc=0):
def f(x):
ret = np.zeros(len(x))
ret[x >= stepLoc] = 1
return ret
return f
def linear_comb_generator(fns, coefs):
def f(x):
return sum(fns[i](x) * coefs[i] for i in range(len(fns)))
return f
def get_target_and_featurizer(num_basis_fns = 100, num_nonzero = 10, coefs_true=None):
# We'll create a basis of step functions on the interval [0,1]. We'll then
# construct a linear combination of these step functions to be our target
# function. We'll construct a function to "featurize" an input in [0,1]
# into the evaluations of all functions in the basis on the input.
# Optionally: If coefs_true is provided, they will be used to generate
# target_fn and featurize.
# Construct basis, to be used for generating target function
if coefs_true is not None:
num_basis_fns = len(coefs_true)
else:
nonzero_indices = np.random.choice(num_basis_fns, num_nonzero)
coefs_true = np.zeros(num_basis_fns)
coefs_true[nonzero_indices] = np.random.randn(num_nonzero)
all_basis_fns = [step_fn_generator(stepLoc=s)
for s in np.linspace(0, 1, num_basis_fns, endpoint=False)]
# Construct target function (the Bayes prediction function)
target_fn = linear_comb_generator(all_basis_fns, coefs_true)
def featurize(x):
n = len(x)
# Featurize input values in [0,1]
X_ftrs = np.empty((n, num_basis_fns))
for ftr_num in range(num_basis_fns):
X_ftrs[:, ftr_num] = all_basis_fns[ftr_num](x)
return X_ftrs
return target_fn, coefs_true, featurize
def generate_data(target_fn, n=1000, noise_scale=.25, tdof=6):
# Construct dataset
x = np.sort(np.random.rand(n)) #chooses uniformly from [0,1)
y_target = target_fn(x)
y = y_target + noise_scale * | np.random.standard_t(tdof,n) | numpy.random.standard_t |
import pandas as pd
import sys
import numpy as np
import scipy as sp
import json
import os
from decimal import Decimal
import scipy.optimize as opt
from scipy.optimize import minimize, curve_fit
from scipy.special import erfc
from scipy.stats import crystalball
from scipy.signal import medfilt, find_peaks
import pygama.analysis.histograms as pgh
import pygama.utils as pgu
import pygama.analysis.peak_fitting as pga
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
plt.style.use('style.mplstyle')
def main():
## this code takes the peaks from thorium's first-pass calibration and fits them. the values from these fits are used to then do a non-linear, second-pass calibration.
peak_2615()
#peak_1765()
#peak_1460()
#peak_609()
#peak_352()
def peak_2615():
if(len(sys.argv) != 2):
print('Usage: fit_bkg_peaks.py [run number]')
sys.exit()
with open("runDB.json") as f:
runDB = json.load(f)
meta_dir = os.path.expandvars(runDB["meta_dir"])
#df = pd.read_hdf("{}/Spectrum_280-329.hdf5".format(meta_dir), key="df")
df = pd.read_hdf("{}/Spectrum_{}.hdf5".format(meta_dir,sys.argv[1]), key="df")
def gauss(x, mu, sigma, A=1):
"""
define a gaussian distribution, w/ args: mu, sigma, area (optional).
"""
return A * (1. / sigma / np.sqrt(2 * np.pi)) * np.exp(-(x - mu)**2 / (2. * sigma**2))
def radford_peak(x, mu, sigma, hstep, htail, tau, bg0, a=1):
"""
David Radford's HPGe peak shape function
"""
# make sure the fractional amplitude parameters stay reasonable...
if htail < 0 or htail > 1:
return np.zeros_like(x)
if hstep < 0 or hstep > 1:
return np.zeros_like(x)
bg_term = bg0 #+ x*bg1
if np.any(bg_term < 0):
return np.zeros_like(x)
# compute the step and the low energy tail
step = a * hstep * erfc((x - mu) / (sigma * np.sqrt(2)))
le_tail = a * htail
le_tail *= erfc((x - mu) / (sigma * np.sqrt(2)) + sigma / (tau * np.sqrt(2)))
le_tail *= np.exp((x - mu) / tau)
le_tail /= (2 * tau * np.exp(-(sigma / (np.sqrt(2) * tau))**2))
# add up all the peak shape components
return (1 - htail) * gauss(x, mu, sigma, a) + bg_term + step + le_tail
hist, bins, var = pgh.get_hist(df['e_cal'], range=(2540,2680), dx=0.5)
pgh.plot_hist(hist, bins, var=hist, label="data")
pars, cov = pga.fit_hist(radford_peak, hist, bins, var=hist, guess=[2608.5, 1.05, 0.001, 0.02, 5, 1, 4000])
pgu.print_fit_results(pars, cov, radford_peak)
pgu.plot_func(radford_peak, pars, label="chi2 fit", color='red')
#x_vals = np.arange(2540,2680,0.5)
#plt.plot(x_vals, radford_peak(x_vals, 2608.5, 1.05, .001, 0.02, 5, 1, 4000))
FWHM = '%.2f' % Decimal(pars[1]*2)
FWHM_uncertainty = '%.2f' % Decimal(np.sqrt(cov[1][1])*2)
peak = '%.2f' % Decimal(pars[0])
peak_uncertainty = '%.2f' % Decimal(np.sqrt(cov[0][0]))
residual = '%.2f' % (2614.51 - float(peak))
chi_2_element_list = []
for i in range(len(hist)):
chi_2_element = abs((radford_peak(bins[i], *pars) - hist[i])**2/radford_peak(bins[i], *pars))
chi_2_element_list.append(chi_2_element)
chi_2 = sum(chi_2_element_list)
reduced_chi_2 = '%.2f' % Decimal(chi_2/len(hist))
print(reduced_chi_2)
label_01 = '2614.51 keV peak fit'
label_02 = 'FWHM = '+str(FWHM)+r' $\pm$ '+str(FWHM_uncertainty)
label_03 = 'Peak = '+str(peak)+r' $\pm$ '+str(peak_uncertainty)
label_04 = 'Residual = '+str(residual)+r' $\pm$ '+str(peak_uncertainty)
colors = ['red', 'red','red', 'red']
lines = [Line2D([0], [0], color=c, lw=2) for c in colors]
labels = [label_01, label_02, label_03, label_04]
plt.xlim(2540,2680)
plt.ylim(0,plt.ylim()[1])
plt.xlabel('Energy (keV)', ha='right', x=1.0)
plt.ylabel('Counts', ha='right', y=1.0)
plt.title('Fit of First-Pass Kr83m Calibration Peak')
plt.tight_layout()
#plt.semilogy()
plt.legend(lines, labels, frameon=False, loc='upper right', fontsize='small')
plt.show()
def peak_1765():
if(len(sys.argv) != 2):
print('Usage: fit_bkg_peaks.py [run number]')
sys.exit()
with open("runDB.json") as f:
runDB = json.load(f)
meta_dir = os.path.expandvars(runDB["meta_dir"])
#df = pd.read_hdf("{}/Spectrum_280-329.hdf5".format(meta_dir), key="df")
df = pd.read_hdf("{}/Spectrum_{}.hdf5".format(meta_dir,sys.argv[1]), key="df")
def gauss(x, mu, sigma, A=1):
"""
define a gaussian distribution, w/ args: mu, sigma, area (optional).
"""
return A * (1. / sigma / np.sqrt(2 * np.pi)) * np.exp(-(x - mu)**2 / (2. * sigma**2))
def radford_peak(x, mu, sigma, hstep, htail, tau, bg0, a=1):
"""
<NAME>'s HPGe peak shape function
"""
# make sure the fractional amplitude parameters stay reasonable...
if htail < 0 or htail > 1:
return np.zeros_like(x)
if hstep < 0 or hstep > 1:
return np.zeros_like(x)
bg_term = bg0 #+ x*bg1
if np.any(bg_term < 0):
return np.zeros_like(x)
# compute the step and the low energy tail
step = a * hstep * erfc((x - mu) / (sigma * np.sqrt(2)))
le_tail = a * htail
le_tail *= erfc((x - mu) / (sigma * np.sqrt(2)) + sigma / (tau * np.sqrt(2)))
le_tail *= | np.exp((x - mu) / tau) | numpy.exp |
import torch.nn as nn
import torch
from torch.autograd import Variable
import pickle
import numpy as np
from torch.utils.data import SubsetRandomSampler, TensorDataset
import os
from model import *
import torch.optim as optim
import datetime
seed = 1
torch.manual_seed(seed)
np.random.seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
title_count, title_set, genres2int, features, targets_values, ratings, users, movies, data, movies_orig, users_orig = pickle.load(open('preprocess.p', mode='rb'))
embed_dim = 32
uid_max = max(features.take(0,1)) + 1
gender_max = max(features.take(2,1)) + 1
age_max = max(features.take(3,1)) + 1
job_max = max(features.take(4,1)) + 1
movie_id_max = max(features.take(1,1)) + 1
movie_categories_max = max(genres2int.values()) + 1
movie_title_max = len(title_set)
sentences_size = title_count
# print(uid_max,gender_max,age_max,job_max,movie_id_max,movie_title_max,movie_categories_max)
#电影ID转下标的字典，数据集中电影ID跟下标不一致，比如第5行的数据电影ID不一定是5
movieid2idx = {val[0]:i for i, val in enumerate(movies.values)}
model = MR_Model(uid_max, gender_max, age_max, job_max, movie_id_max, movie_categories_max, movie_title_max)
model_dir = './movie_recommendation_model'
pt_name = model_dir + '/lr_checkpoint.pt'
model.load_state_dict(torch.load(pt_name, map_location="cpu"))
def movie_feature():
MF = []
model.eval()
for item in movies.values:
categories = np.zeros([1, 18])
categories[0] = item.take(2)
titles = | np.zeros([1, sentences_size]) | numpy.zeros |
# -*- coding: utf-8 -*-
'''
Author: <NAME>
Date: 2021-11-02 16:17:39
LastEditTime: 2021-11-29 13:23:25
LastEditors: <NAME>
Description:
FilePath: \标定上位机\Calculate.py
'''
import math
import numpy as np
from GPS2UTM import *
# 角度转弧度
def Angle2Rad(angle):
return angle * math.pi / 180
# 弧度转角度
def Rad2Angle(rad):
return rad * 180 / math.pi
'''
description: 计算两点之间距离和方位角，以真值为原点，正北方向为y轴
param {mat} 位置矩阵，目标经度，目标纬度，雷达经度，雷达纬度
return {angle} 距离，方位弧度，方位角度
'''
def TwoPointsCal(mat):
earthRad = 6371004
# earthRad = 6378137
radLonTar = Angle2Rad(mat[0])
radLatTar = Angle2Rad(mat[1])
radLonTru = Angle2Rad(mat[2])
radLatTru = Angle2Rad(mat[3])
lonDis = radLonTru - radLonTar
latDis = radLatTru - radLatTar
dst = 2 * math.asin(math.sqrt(math.pow(math.sin(latDis / 2), 2) + math.cos(radLatTru) * math.cos(radLatTar) * \
math.pow(math.sin(lonDis / 2), 2)))
dst = abs(dst * earthRad)
# 计算两点方位角，以真值为原点，正北方向为y轴
x = math.sin(radLonTar - radLonTru) * math.cos(radLatTar)
y = math.cos(radLatTru) * math.sin(radLatTar) - math.sin(radLatTru) * math.cos(radLatTar) * math.cos(radLonTar - radLonTru)
rad = math.atan2(y, x)
angle = (90 - Rad2Angle(rad)) % 360
return dst, rad, angle
'''
description: 北向夹角计算
param {mat} 位置矩阵，目标x，y，经度，纬度，雷达经度，纬度
return {angle} 北向夹角
'''
def NorthAngleCal(mat):
'''
x' = x * cos + y * sin
y' = y * cos - x * sin
逆时针旋转为正
'''
inputMat = np.array([mat[2], mat[3], mat[4], mat[5]])
dis, rad, angle = TwoPointsCal(inputMat)
xCoor = dis * math.cos(rad)
yCoor = dis * math.sin(rad)
northRad = math.atan2(mat[0] * yCoor - xCoor * mat[1], \
mat[0] * xCoor + mat[1] * yCoor)
northAngle = (360 - Rad2Angle(northRad)) % 360
return northAngle
'''
description: 距离误差计算——检测中心
param {mat} 位置矩阵，目标检测经纬度, 目标真值经纬度, 主基站北向夹角
return {dis} x,y方向距离误差
'''
def DisCal(mat):
inputMat = np.array([mat[0], mat[1], mat[2], mat[3]])
dis, rad, angle = TwoPointsCal(inputMat)
xDis = dis * math.cos(rad)
yDis = dis * math.sin(rad)
rotAngle = 360 - mat[4]
rotRad = Angle2Rad(rotAngle)
rotMat = np.array([[math.cos(rotRad), math.sin(rotRad)], [-math.sin(rotRad), math.cos(rotRad)]]) # 坐标系旋转矩阵
newCoor = np.matmul(rotMat, np.array([[xDis], [yDis]]))
return newCoor
'''
description: 标定参数计算
param {mat} 2行3列，第1行：主基站经度，纬度，北向夹角
第2行：副基站经度，纬度，北向夹角
return {副基站} x平移量，y平移量，角度差
'''
def CalibCal(mat):
angleDis = (mat[0,2] - mat[1,2])
inputMat = np.array([mat[1,0], mat[1,1], mat[0,0], mat[0,1], mat[0,2]])
result = DisCal(inputMat)
return np.array([result[0], result[1], angleDis])
'''
--------------------------------------------------------
### 经纬度转UTM坐标系，再计算距离、角度方法，暂时不使用 ###
--------------------------------------------------------
'''
# description: 北向夹角计算
# param {mat} 位置矩阵，目标x,y,E,N;雷达E,N
# return {angle} 航向角
# '''
# def angleCal(mat):
# '''
# x' = x * cos + y * sin
# y' = y * cos - x * sin
# 逆时针旋转为正
# '''
# xEarth = mat[2] - mat[4]
# yEarth = mat[3] - mat[5]
# rad = math.atan2(yEarth * mat[0] - mat[1] * xEarth, \
# yEarth * mat[1] + xEarth * mat[0])
# angle = 360 - (rad / math.pi * 180) % 360
# # angle = (90 - Rad2Angle(rad)) % 360
# return angle
# '''
# description: 标定参数计算
# param {mat} 2行3列，第1行：主基站X，主基站Y，主基站北向夹角
# 第2行：副基站X，副基站Y，副基站北向夹角
# return {副基站} x平移量，y平移量，角度差
# '''
# def calibCal(mat):
# angleDis = (mat[0,2] - mat[1,2])
# rad = (360 - mat[0,2]) / 180 * math.pi
# coor = np.array([[mat[1,0] - mat[0,0]], [mat[1,1] - mat[0,1]]]) # 以主基站为原点，副基站xy坐标
# rotMat = np.array([[math.cos(rad), math.sin(rad)], [-math.sin(rad), math.cos(rad)]]) # 坐标系旋转矩阵
# newCoor = np.matmul(rotMat, coor)
# xDis = newCoor[0]
# yDis = newCoor[1]
# result = [xDis, yDis, angleDis]
# return result
# '''
# description: 距离误差计算
# param {mat} 位置矩阵，目标x,y方向, 真值x,y方向, 主基站北向夹角
# return {dis} x,y方向距离误差
# '''
# def disCal(mat):
# rad = Angle2Rad(360 - mat[4])
# coor = np.array([[mat[0] - mat[2]], [mat[1] - mat[3]]]) # 以真值为原点，检测结果相对真值位置
# rotMat = np.array([[math.cos(rad), math.sin(rad)], [-math.sin(rad), math.cos(rad)]]) # 坐标系旋转矩阵
# newCoor = np.matmul(rotMat, coor)
# print('------------------')
# print(newCoor)
# xDis = newCoor[0]
# yDis = newCoor[1]
# result = [xDis, yDis]
# # return result
# return result
if __name__ == '__main__':
lonLidar = 116.2869783345294
latLidar = 40.0516953302213
lonTar = 116.2867578256973
latTar = 40.0520586730172
# lonTar = 116.2869783345294
# latTar = 40.0516953302213
angleLidar = 159.43
angleTar = 163
ELidar, NLidar = GPS2UTM(latLidar, lonLidar) # 雷达经纬度转xy
ETar, NTar = GPS2UTM(latTar, lonTar)
mat = np.array([-18,40, lonTar, latTar, lonLidar, latLidar])
mat2 = | np.array([-18,40, ETar, NTar, ELidar, NLidar]) | numpy.array |
from scipy.stats import lognorm
import numpy as np
def all_true(logical_list):
try:
logical_list[2]
return logical_list[0] and all_true(logical_list[1:])
except IndexError:
return logical_list[0] and logical_list[1]
class MarkovRenewalProcess():
""" Markov renewal process
- the transition matrix has entries [j][i] which is the probablity of next=j given current=i
- the residence times are log-normal distributed
"""
def __init__(self, states, tm=None, mu=None, sigma=None, m=None):
self.states = states
k = len(self.states)
# init the parameters for training
if tm == 'uniform' or tm is None:
tm = np.ones((k, k))
tm.flat[::k+1] = 0
self.__comx = tm
if sigma is None:
sigma = np.full((k, ), 10)
if mu is None:
mu = np.full((k, ), 1)
self.__mu = np.log(mu**2/np.sqrt(sigma**2 + mu**2))
self.__S2 = np.log(1 + sigma**2/mu**2) + self.__mu**2
@property
def states(self):
return self.__states
@property
def transition_matrix(self):
return self.__comx / self.__comx.sum(axis=0, keepdims=True)
@property
def residence_times(self):
# base the residence times upon the parameters mu and sigma
return {state: lognorm(s=self.s[self._ix[state]], loc=0, scale=self.scale[self._ix[state]]) for state in self.states}
@property
def sigma(self):
""" second moments for each of the states' residence times
based on self.n samples
"""
return [np.sqrt(rv.stats(moments='v')) for rv in self.residence_times.values()]
@property
def mu(self):
""" first moments for each of the states' residence times
"""
return [rv.stats(moments='m') for rv in self.residence_times.values()]
@property
def comx(self):
""" co-occurrence matrix
"""
return self.__comx
@states.setter
def states(self, states):
self.__states = list(states)
@property
def _ix(self):
return {s: ix for ix, s in enumerate(self.states)}
@property
def s(self):
return np.sqrt(self.__S2 - self.__mu ** 2)
@property
def scale(self):
return np.exp(self.__mu)
@property
def steady_state(self):
w, v = np.linalg.eig(self.transition_matrix)
ix = np.argmax(np.real(w))
steady_state = np.real(v[:, ix])
for ix, st in enumerate(self.residence_times.values()):
steady_state[ix] = steady_state[ix] * st.stats(moments='m') # steady_state[ix] = steady_state[ix] * self.mu[ix]
return steady_state / steady_state.sum()
def train(self, X):
""" X comes as a list of tuples (state, duration)
for a specific element that has no duration, it is not used to update the estimate
of the residence_times, but is used as an "end-state" (previous transition is taken
into account, not the next one)
"""
# residence times
surv_t = {
s: [] for s in self.states
}
# the number of observations we already had
m = self.__comx.sum(axis=0) # TODO: should this not be axis=0 ???
# get the current and next states together as x and y
for x, y in zip(X[:-1], X[1:]):
if x[1] is not None:
# only if the current state has a duration will we look at
# - current residence time
# - transition to next state
surv_t[x[0]].append(np.log(x[1]))
self.__comx[self._ix[y[0]], self._ix[x[0]]] += 1
# the number of observations after the update
n = self.__comx.sum(axis=0) # TODO: should this not be axis=0 ???
# update estimators of first two moments: mu and S2
for k, v in surv_t.items():
ix = self._ix[k]
# do not update if no samples are observed
# alternative, we may multiply
# the current estimator by alpha
# and the newly obtained estimator by (1 - alpha)
# this would allow to forget the past trials at a "constant" rate
# (not taking into account variance of the estimators)
if n[ix] - m[ix] > 0:
self.__mu[ix] = (self.__mu[ix] * m[ix] + np.array(v).sum()) / n[ix]
self.__S2[ix] = (self.__S2[ix] * m[ix] + ( | np.array(v) | numpy.array |
"""
Multiplication of distributions.
Example usage
-------------
Distribution * a constant::
>>> distribution = chaospy.Uniform(0, 1) * 4
>>> print(distribution)
Mul(Uniform(lower=0, upper=1), 4)
>>> print(numpy.around(distribution.sample(5), 4))
[2.6144 0.46 3.8011 1.9288 3.4899]
>>> print(numpy.around(distribution.fwd([1, 2, 3]), 4))
[0.25 0.5 0.75]
>>> print(numpy.around(distribution.inv(distribution.fwd([1, 2, 3])), 4))
[1. 2. 3.]
>>> print(numpy.around(distribution.pdf([1, 2, 3]), 4))
[0.25 0.25 0.25]
>>> print(numpy.around(distribution.mom([1, 2, 3]), 4))
[ 2. 5.3333 16. ]
>>> print(numpy.around(distribution.ttr([1, 2, 3]), 4))
[[2. 2. 2. ]
[1.3333 1.0667 1.0286]]
Construct joint multiplication distribution::
>>> lhs = chaospy.Uniform(-1, 0)
>>> rhs = chaospy.Uniform(-3, -2)
>>> multiplication = lhs * rhs
>>> print(multiplication)
Mul(Uniform(lower=-1, upper=0), Uniform(lower=-3, upper=-2))
>>> joint1 = chaospy.J(lhs, multiplication)
>>> print(joint1.range())
[[-1. 0.]
[ 0. 3.]]
>>> joint2 = chaospy.J(rhs, multiplication)
>>> print(joint2.range())
[[-3. -0.]
[-2. 3.]]
>>> joint3 = chaospy.J(multiplication, lhs)
>>> print(joint3.range())
[[ 0. -1.]
[ 3. 0.]]
>>> joint4 = chaospy.J(multiplication, rhs)
>>> print(joint4.range())
[[-0. -3.]
[ 3. -2.]]
Generate random samples::
>>> print(numpy.around(joint1.sample(4), 4))
[[-0.7877 -0.9593 -0.6028 -0.7669]
[ 2.2383 2.1172 1.6532 1.8345]]
>>> print(numpy.around(joint2.sample(4), 4))
[[-2.8177 -2.2565 -2.9304 -2.1147]
[ 2.6843 2.1011 1.2174 0.0613]]
Forward transformations::
>>> lcorr = numpy.array([-0.9, -0.5, -0.1])
>>> rcorr = numpy.array([-2.99, -2.5, -2.01])
>>> print(numpy.around(joint1.fwd([lcorr, lcorr*rcorr]), 4))
[[0.1 0.5 0.9 ]
[0.99 0.5 0.01]]
>>> print(numpy.around(joint2.fwd([rcorr, lcorr*rcorr]), 4))
[[0.01 0.5 0.99]
[0.9 0.5 0.1 ]]
Inverse transformations::
>>> print(numpy.around(joint1.inv(joint1.fwd([lcorr, lcorr*rcorr])), 4))
[[-0.9 -0.5 -0.1 ]
[ 2.691 1.25 0.201]]
>>> print(numpy.around(joint2.inv(joint2.fwd([rcorr, lcorr*rcorr])), 4))
[[-2.99 -2.5 -2.01 ]
[ 2.691 1.25 0.201]]
"""
import numpy
from ..baseclass import Dist
from .. import evaluation
class Mul(Dist):
"""Multiplication."""
def __init__(self, left, right):
"""
Args:
left (Dist, numpy.ndarray) : Left hand side.
right (Dist, numpy.ndarray) : Right hand side.
"""
self.matrix = False
if (isinstance(left, Dist) and
len(left) > 1 and
not isinstance(right, Dist)):
right = right*numpy.eye(len(left))
self.matrix = True
elif (isinstance(right, Dist) and
len(right) > 1 and
not isinstance(left, Dist)):
left = left*numpy.eye(len(right))
self.matrix = True
Dist.__init__(self, left=left, right=right)
def _bnd(self, xloc, left, right, cache):
"""
Distribution bounds.
Example:
>>> print(chaospy.Uniform().range([-2, 0, 2, 4]))
[[0. 0. 0. 0.]
[1. 1. 1. 1.]]
>>> print(Mul(chaospy.Uniform(), 2).range([-2, 0, 2, 4]))
[[0. 0. 0. 0.]
[2. 2. 2. 2.]]
>>> print(Mul(2, chaospy.Uniform()).range([-2, 0, 2, 4]))
[[0. 0. 0. 0.]
[2. 2. 2. 2.]]
>>> print(Mul(2, 2).range([-2, 0, 2, 4]))
[[4. 4. 4. 4.]
[4. 4. 4. 4.]]
>>> dist = chaospy.Mul(chaospy.Iid(chaospy.Uniform(), 2), [1, 2])
>>> print(dist.range([[0.5, 0.6, 1.5], [0.5, 0.6, 1.5]]))
[[[0. 0. 0.]
[0. 0. 0.]]
<BLANKLINE>
[[1. 1. 1.]
[2. 2. 2.]]]
>>> dist = chaospy.Mul([2, 1], chaospy.Iid(chaospy.Uniform(), 2))
>>> print(dist.range([[0.5, 0.6, 1.5], [0.5, 0.6, 1.5]]))
[[[0. 0. 0.]
[0. 0. 0.]]
<BLANKLINE>
[[2. 2. 2.]
[1. 1. 1.]]]
>>> dist = chaospy.Mul(chaospy.Iid(chaospy.Uniform(), 2), [1, 2])
>>> print(dist.range([[0.5, 0.6, 1.5], [0.5, 0.6, 1.5]]))
[[[0. 0. 0.]
[0. 0. 0.]]
<BLANKLINE>
[[1. 1. 1.]
[2. 2. 2.]]]
"""
left = evaluation.get_forward_cache(left, cache)
right = evaluation.get_forward_cache(right, cache)
if isinstance(left, Dist):
if isinstance(right, Dist):
raise evaluation.DependencyError(
"under-defined distribution {} or {}".format(left, right))
elif not isinstance(right, Dist):
return numpy.dot(left, right), numpy.dot(left, right)
else:
left = numpy.asfarray(left)
if self.matrix:
Ci = numpy.linalg.inv(left)
xloc = numpy.dot(Ci, xloc)
assert len(xloc) == len(right)
elif len(left.shape) == 3:
left_ = numpy.mean(left, 0)
valids = left_ != 0
xloc.T[valids.T] = xloc.T[valids.T]/left_.T[valids.T]
else:
left = (left.T+numpy.zeros(xloc.shape).T).T
valids = left != 0
xloc.T[valids.T] = xloc.T[valids.T]/left.T[valids.T]
assert len(xloc) == len(right)
lower, upper = evaluation.evaluate_bound(right, xloc, cache=cache)
if self.matrix:
lower = numpy.dot(lower.T, left.T).T
upper = numpy.dot(upper.T, left.T).T
elif len(left.shape) == 3:
lower = numpy.where(left[0]*lower > 0, left[0]*lower, left[1]*lower)
upper = numpy.where(left[1]*upper > 0, left[1]*upper, left[0]*upper)
lower, upper = (
numpy.where(lower < upper, lower, upper),
numpy.where(lower < upper, upper, lower),
)
lower[(left[0] < 0) & (lower > 0)] = 0.
assert len(lower) == len(right)
else:
lower *= left
upper *= left
lower, upper = (
numpy.where(lower < upper, lower, upper),
numpy.where(lower < upper, upper, lower),
)
return lower, upper
right = numpy.asfarray(right)
if self.matrix:
Ci = numpy.linalg.inv(right)
xloc = numpy.dot(xloc.T, Ci.T).T
assert len(left) == len(xloc)
elif len(right.shape) == 3:
right_ = numpy.mean(right, 0)
valids = right_ != 0
xloc.T[valids.T] = xloc.T[valids.T]/right_.T[valids.T]
else:
right = (right.T+numpy.zeros(xloc.shape).T).T
valids = right != 0
xloc.T[valids.T] = xloc.T[valids.T]/right.T[valids.T]
assert len(left) == len(xloc)
lower, upper = evaluation.evaluate_bound(left, xloc, cache=cache)
if self.matrix:
lower = numpy.dot(lower.T, right.T).T
upper = numpy.dot(upper.T, right.T).T
elif len(right.shape) == 3:
lower = numpy.where(right[0]*lower > 0, right[0]*lower, right[1]*lower)
upper = numpy.where(right[1]*upper > 0, right[1]*upper, right[0]*upper)
lower, upper = (
numpy.where(lower < upper, lower, upper),
numpy.where(lower < upper, upper, lower),
)
lower[(right[0] < 0) & (lower > 0)] = 0.
else:
lower *= right
upper *= right
lower, upper = (
numpy.where(lower < upper, lower, upper),
| numpy.where(lower < upper, upper, lower) | numpy.where |
import mock
import numpy
from PIL import Image
from types import SimpleNamespace
import unittest
from machine_common_sense.mcs_action import MCS_Action
from machine_common_sense.mcs_goal import MCS_Goal
from machine_common_sense.mcs_object import MCS_Object
from machine_common_sense.mcs_pose import MCS_Pose
from machine_common_sense.mcs_return_status import MCS_Return_Status
from machine_common_sense.mcs_step_output import MCS_Step_Output
from .mock_mcs_controller_ai2thor import Mock_MCS_Controller_AI2THOR
class Test_MCS_Controller_AI2THOR(unittest.TestCase):
def setUp(self):
self.controller = Mock_MCS_Controller_AI2THOR()
self.controller.set_config({ 'metadata': '' })
def create_mock_scene_event(self, mock_scene_event_data):
# Wrap the dict in a SimpleNamespace object to permit property access with dotted notation since the actual
# variable is a class, not a dict.
return SimpleNamespace(**mock_scene_event_data)
def create_retrieve_object_list_scene_event(self):
return {
"events": [self.create_mock_scene_event({
"object_id_to_color": {
"testId1": (12, 34, 56),
"testId2": (98, 76, 54),
"testId3": (101, 102, 103)
}
})],
"metadata": {
"objects": [{
"colorsFromMaterials": ["c1"],
"direction": {
"x": 0,
"y": 0,
"z": 0
},
"distance": 0,
"distanceXZ": 0,
"isPickedUp": True,
"mass": 1,
"objectId": "testId1",
"position": {
"x": 1,
"y": 1,
"z": 2
},
"rotation": {
"x": 1.0,
"y": 2.0,
"z": 3.0
},
"salientMaterials": [],
"shape": "shape1",
"visibleInCamera": True
}, {
"colorsFromMaterials": ["c2", "c3"],
"direction": {
"x": 90,
"y": -30,
"z": 0
},
"distance": 1.5,
"distanceXZ": 1.1,
"isPickedUp": False,
"mass": 12.34,
"objectBounds": {
"objectBoundsCorners": ["p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8"]
},
"objectId": "testId2",
"position": {
"x": 1,
"y": 2,
"z": 3
},
"rotation": {
"x": 1.0,
"y": 2.0,
"z": 3.0
},
"salientMaterials": ["Foobar", "Metal", "Plastic"],
"shape": "shape2",
"visibleInCamera": True
}, {
"colorsFromMaterials": [],
"direction": {
"x": -90,
"y": 180,
"z": 270
},
"distance": 2.5,
"distanceXZ": 2,
"isPickedUp": False,
"mass": 34.56,
"objectBounds": {
"objectBoundsCorners": ["pA", "pB", "pC", "pD", "pE", "pF", "pG", "pH"]
},
"objectId": "testId3",
"position": {
"x": -3,
"y": -2,
"z": -1
},
"rotation": {
"x": 11.0,
"y": 12.0,
"z": 13.0
},
"salientMaterials": ["Wood"],
"shape": "shape3",
"visibleInCamera": False
}]
}
}
def create_wrap_output_scene_event(self):
image_data = numpy.array([[0]], dtype=numpy.uint8)
depth_mask_data = numpy.array([[128]], dtype=numpy.uint8)
object_mask_data = numpy.array([[192]], dtype=numpy.uint8)
return {
"events": [self.create_mock_scene_event({
"depth_frame": depth_mask_data,
"frame": image_data,
"instance_segmentation_frame": object_mask_data,
"object_id_to_color": {
"testId": (12, 34, 56),
"testWallId": (101, 102, 103)
}
})],
"metadata": {
"agent": {
"cameraHorizon": 12.34,
"position": {
"x": 0.12,
"y": -0.23,
"z": 4.5
},
"rotation": {
"x": 1.111,
"y": 2.222,
"z": 3.333
}
},
"cameraPosition": {
"y": 0.1234
},
"clippingPlaneFar": 25,
"clippingPlaneNear": 0,
"fov": 42.5,
"lastActionStatus": "SUCCESSFUL",
"lastActionSuccess": True,
"objects": [{
"colorsFromMaterials": ["c1"],
"direction": {
"x": 90,
"y": -30,
"z": 0
},
"distance": 1.5,
"distanceXZ": 1.1,
"isPickedUp": False,
"mass": 12.34,
"objectBounds": {
"objectBoundsCorners": ["p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8"]
},
"objectId": "testId",
"position": {
"x": 10,
"y": 11,
"z": 12
},
"rotation": {
"x": 1.0,
"y": 2.0,
"z": 3.0
},
"salientMaterials": ["Wood"],
"shape": "shape",
"visibleInCamera": True
}, {
"colorsFromMaterials": [],
"direction": {
"x": -90,
"y": 180,
"z": 270
},
"distance": 2.5,
"distanceXZ": 2.0,
"isPickedUp": False,
"mass": 34.56,
"objectBounds": {
"objectBoundsCorners": ["pA", "pB", "pC", "pD", "pE", "pF", "pG", "pH"]
},
"objectId": "testIdHidden",
"position": {
"x": -3,
"y": -2,
"z": -1
},
"rotation": {
"x": 11.0,
"y": 12.0,
"z": 13.0
},
"salientMaterials": ["Wood"],
"shape": "shapeHidden",
"visibleInCamera": False
}],
"structuralObjects": [{
"colorsFromMaterials": ["c2"],
"direction": {
"x": 180,
"y": -60,
"z": 0
},
"distance": 2.5,
"distanceXZ": 2.2,
"isPickedUp": False,
"mass": 56.78,
"objectBounds": {
"objectBoundsCorners": ["p11", "p12", "p13", "p14", "p15", "p16", "p17", "p18"]
},
"objectId": "testWallId",
"position": {
"x": 20,
"y": 21,
"z": 22
},
"rotation": {
"x": 4.0,
"y": 5.0,
"z": 6.0
},
"salientMaterials": ["Ceramic"],
"shape": "structure",
"visibleInCamera": True
}, {
"colorsFromMaterials": [],
"direction": {
"x": -180,
"y": 60,
"z": 90
},
"distance": 3.5,
"distanceXZ": 3.3,
"isPickedUp": False,
"mass": 78.90,
"objectBounds": {
"objectBoundsCorners": ["pAA", "pBB", "pCC", "pDD", "pEE", "pFF", "pGG", "pHH"]
},
"objectId": "testWallIdHidden",
"position": {
"x": 30,
"y": 31,
"z": 32
},
"rotation": {
"x": 14.0,
"y": 15.0,
"z": 16.0
},
"salientMaterials": ["Ceramic"],
"shape": "structureHidden",
"visibleInCamera": False
}]
}
}, image_data, depth_mask_data, object_mask_data
def test_end_scene(self):
# TODO When this function actually does anything
pass
def test_start_scene(self):
# TODO MCS-15
pass
def test_step(self):
# TODO MCS-15
pass
def test_restrict_goal_output_metadata(self):
goal = MCS_Goal(metadata={
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
actual = self.controller.restrict_goal_output_metadata(goal)
self.assertEqual(actual.metadata, {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
def test_restrict_goal_output_metadata_full(self):
self.controller.set_config({ 'metadata': 'full' })
goal = MCS_Goal(metadata={
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
actual = self.controller.restrict_goal_output_metadata(goal)
self.assertEqual(actual.metadata, {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
def test_restrict_goal_output_metadata_no_navigation(self):
self.controller.set_config({ 'metadata': 'no_navigation' })
goal = MCS_Goal(metadata={
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
actual = self.controller.restrict_goal_output_metadata(goal)
self.assertEqual(actual.metadata, {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
def test_restrict_goal_output_metadata_no_vision(self):
self.controller.set_config({ 'metadata': 'no_vision' })
goal = MCS_Goal(metadata={
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
actual = self.controller.restrict_goal_output_metadata(goal)
self.assertEqual(actual.metadata, {
'target': { 'image': None },
'target_1': { 'image': None },
'target_2': { 'image': None }
})
def test_restrict_goal_output_metadata_none(self):
self.controller.set_config({ 'metadata': 'none' })
goal = MCS_Goal(metadata={
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
actual = self.controller.restrict_goal_output_metadata(goal)
self.assertEqual(actual.metadata, {
'target': { 'image': None },
'target_1': { 'image': None },
'target_2': { 'image': None }
})
def test_restrict_object_output_metadata(self):
test_object = MCS_Object(
color={ 'r': 1, 'g': 2, 'b': 3 },
dimensions={ 'x': 1, 'y': 2, 'z': 3 },
distance=12.34,
distance_in_steps=34.56,
distance_in_world=56.78,
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 },
shape='sofa',
texture_color_list=['c1', 'c2']
)
actual = self.controller.restrict_object_output_metadata(test_object)
self.assertEqual(actual.color, { 'r': 1, 'g': 2, 'b': 3 })
self.assertEqual(actual.dimensions, { 'x': 1, 'y': 2, 'z': 3 })
self.assertEqual(actual.distance, 12.34)
self.assertEqual(actual.distance_in_steps, 34.56)
self.assertEqual(actual.distance_in_world, 56.78)
self.assertEqual(actual.position, { 'x': 4, 'y': 5, 'z': 6 })
self.assertEqual(actual.rotation, { 'x': 7, 'y': 8, 'z': 9 })
self.assertEqual(actual.shape, 'sofa')
self.assertEqual(actual.texture_color_list, ['c1', 'c2'])
def test_restrict_object_output_metadata_full(self):
self.controller.set_config({ 'metadata': 'full' })
test_object = MCS_Object(
color={ 'r': 1, 'g': 2, 'b': 3 },
dimensions={ 'x': 1, 'y': 2, 'z': 3 },
distance=12.34,
distance_in_steps=34.56,
distance_in_world=56.78,
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 },
shape='sofa',
texture_color_list=['c1', 'c2']
)
actual = self.controller.restrict_object_output_metadata(test_object)
self.assertEqual(actual.color, { 'r': 1, 'g': 2, 'b': 3 })
self.assertEqual(actual.dimensions, { 'x': 1, 'y': 2, 'z': 3 })
self.assertEqual(actual.distance, 12.34)
self.assertEqual(actual.distance_in_steps, 34.56)
self.assertEqual(actual.distance_in_world, 56.78)
self.assertEqual(actual.position, { 'x': 4, 'y': 5, 'z': 6 })
self.assertEqual(actual.rotation, { 'x': 7, 'y': 8, 'z': 9 })
self.assertEqual(actual.shape, 'sofa')
self.assertEqual(actual.texture_color_list, ['c1', 'c2'])
def test_restrict_object_output_metadata_no_navigation(self):
self.controller.set_config({ 'metadata': 'no_navigation' })
test_object = MCS_Object(
color={ 'r': 1, 'g': 2, 'b': 3 },
dimensions={ 'x': 1, 'y': 2, 'z': 3 },
distance=12.34,
distance_in_steps=34.56,
distance_in_world=56.78,
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 },
shape='sofa',
texture_color_list=['c1', 'c2']
)
actual = self.controller.restrict_object_output_metadata(test_object)
self.assertEqual(actual.color, { 'r': 1, 'g': 2, 'b': 3 })
self.assertEqual(actual.dimensions, { 'x': 1, 'y': 2, 'z': 3 })
self.assertEqual(actual.distance, 12.34)
self.assertEqual(actual.distance_in_steps, 34.56)
self.assertEqual(actual.distance_in_world, 56.78)
self.assertEqual(actual.position, None)
self.assertEqual(actual.rotation, None)
self.assertEqual(actual.shape, 'sofa')
self.assertEqual(actual.texture_color_list, ['c1', 'c2'])
def test_restrict_object_output_metadata_no_vision(self):
self.controller.set_config({ 'metadata': 'no_vision' })
test_object = MCS_Object(
color={ 'r': 1, 'g': 2, 'b': 3 },
dimensions={ 'x': 1, 'y': 2, 'z': 3 },
distance=12.34,
distance_in_steps=34.56,
distance_in_world=56.78,
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 },
shape='sofa',
texture_color_list=['c1', 'c2']
)
actual = self.controller.restrict_object_output_metadata(test_object)
self.assertEqual(actual.color, None)
self.assertEqual(actual.dimensions, None)
self.assertEqual(actual.distance, None)
self.assertEqual(actual.distance_in_steps, None)
self.assertEqual(actual.distance_in_world, None)
self.assertEqual(actual.position, { 'x': 4, 'y': 5, 'z': 6 })
self.assertEqual(actual.rotation, { 'x': 7, 'y': 8, 'z': 9 })
self.assertEqual(actual.shape, None)
self.assertEqual(actual.texture_color_list, None)
def test_restrict_object_output_metadata_none(self):
self.controller.set_config({ 'metadata': 'none' })
test_object = MCS_Object(
color={ 'r': 1, 'g': 2, 'b': 3 },
dimensions={ 'x': 1, 'y': 2, 'z': 3 },
distance=12.34,
distance_in_steps=34.56,
distance_in_world=56.78,
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 },
shape='sofa',
texture_color_list=['c1', 'c2']
)
actual = self.controller.restrict_object_output_metadata(test_object)
self.assertEqual(actual.color, None)
self.assertEqual(actual.dimensions, None)
self.assertEqual(actual.distance, None)
self.assertEqual(actual.distance_in_steps, None)
self.assertEqual(actual.distance_in_world, None)
self.assertEqual(actual.position, None)
self.assertEqual(actual.rotation, None)
self.assertEqual(actual.shape, None)
self.assertEqual(actual.texture_color_list, None)
def test_restrict_step_output_metadata(self):
step = MCS_Step_Output(
camera_aspect_ratio=(1, 2),
camera_clipping_planes=(3, 4),
camera_field_of_view=5,
camera_height=6,
depth_mask_list=[7],
object_mask_list=[8],
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 }
)
actual = self.controller.restrict_step_output_metadata(step)
self.assertEqual(actual.camera_aspect_ratio, (1, 2))
self.assertEqual(actual.camera_clipping_planes, (3, 4))
self.assertEqual(actual.camera_field_of_view, 5)
self.assertEqual(actual.camera_height, 6)
self.assertEqual(actual.depth_mask_list, [7])
self.assertEqual(actual.object_mask_list, [8])
self.assertEqual(actual.position, { 'x': 4, 'y': 5, 'z': 6 })
self.assertEqual(actual.rotation, { 'x': 7, 'y': 8, 'z': 9 })
def test_restrict_step_output_metadata_full(self):
self.controller.set_config({ 'metadata': 'full' })
step = MCS_Step_Output(
camera_aspect_ratio=(1, 2),
camera_clipping_planes=(3, 4),
camera_field_of_view=5,
camera_height=6,
depth_mask_list=[7],
object_mask_list=[8],
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 }
)
actual = self.controller.restrict_step_output_metadata(step)
self.assertEqual(actual.camera_aspect_ratio, (1, 2))
self.assertEqual(actual.camera_clipping_planes, (3, 4))
self.assertEqual(actual.camera_field_of_view, 5)
self.assertEqual(actual.camera_height, 6)
self.assertEqual(actual.depth_mask_list, [7])
self.assertEqual(actual.object_mask_list, [8])
self.assertEqual(actual.position, { 'x': 4, 'y': 5, 'z': 6 })
self.assertEqual(actual.rotation, { 'x': 7, 'y': 8, 'z': 9 })
def test_restrict_step_output_metadata_no_navigation(self):
self.controller.set_config({ 'metadata': 'no_navigation' })
step = MCS_Step_Output(
camera_aspect_ratio=(1, 2),
camera_clipping_planes=(3, 4),
camera_field_of_view=5,
camera_height=6,
depth_mask_list=[7],
object_mask_list=[8],
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 }
)
actual = self.controller.restrict_step_output_metadata(step)
self.assertEqual(actual.camera_aspect_ratio, (1, 2))
self.assertEqual(actual.camera_clipping_planes, (3, 4))
self.assertEqual(actual.camera_field_of_view, 5)
self.assertEqual(actual.camera_height, 6)
self.assertEqual(actual.depth_mask_list, [7])
self.assertEqual(actual.object_mask_list, [8])
self.assertEqual(actual.position, None)
self.assertEqual(actual.rotation, None)
def test_restrict_step_output_metadata_no_vision(self):
self.controller.set_config({ 'metadata': 'no_vision' })
step = MCS_Step_Output(
camera_aspect_ratio=(1, 2),
camera_clipping_planes=(3, 4),
camera_field_of_view=5,
camera_height=6,
depth_mask_list=[7],
object_mask_list=[8],
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 }
)
actual = self.controller.restrict_step_output_metadata(step)
self.assertEqual(actual.camera_aspect_ratio, None)
self.assertEqual(actual.camera_clipping_planes, None)
self.assertEqual(actual.camera_field_of_view, None)
self.assertEqual(actual.camera_height, None)
self.assertEqual(actual.depth_mask_list, [])
self.assertEqual(actual.object_mask_list, [])
self.assertEqual(actual.position, { 'x': 4, 'y': 5, 'z': 6 })
self.assertEqual(actual.rotation, { 'x': 7, 'y': 8, 'z': 9 })
def test_restrict_step_output_metadata_none(self):
self.controller.set_config({ 'metadata': 'none' })
step = MCS_Step_Output(
camera_aspect_ratio=(1, 2),
camera_clipping_planes=(3, 4),
camera_field_of_view=5,
camera_height=6,
depth_mask_list=[7],
object_mask_list=[8],
position={ 'x': 4, 'y': 5, 'z': 6 },
rotation={ 'x': 7, 'y': 8, 'z': 9 }
)
actual = self.controller.restrict_step_output_metadata(step)
self.assertEqual(actual.camera_aspect_ratio, None)
self.assertEqual(actual.camera_clipping_planes, None)
self.assertEqual(actual.camera_field_of_view, None)
self.assertEqual(actual.camera_height, None)
self.assertEqual(actual.depth_mask_list, [])
self.assertEqual(actual.object_mask_list, [])
self.assertEqual(actual.position, None)
self.assertEqual(actual.rotation, None)
def test_retrieve_action_list(self):
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(), 0), self.controller.ACTION_LIST)
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(action_list=[]), 0), \
self.controller.ACTION_LIST)
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(action_list=[[]]), 0), \
self.controller.ACTION_LIST)
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(action_list=[['MoveAhead',\
'RotateLook,rotation=180']]), 0), ['MoveAhead', 'RotateLook,rotation=180'])
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(action_list=[['MoveAhead',\
'RotateLook,rotation=180']]), 1), self.controller.ACTION_LIST)
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(action_list=[['MoveAhead',\
'RotateLook,rotation=180'], []]), 1), self.controller.ACTION_LIST)
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(action_list=[[],['MoveAhead',\
'RotateLook,rotation=180']]), 0), self.controller.ACTION_LIST)
self.assertEqual(self.controller.retrieve_action_list(MCS_Goal(action_list=[[],['MoveAhead',\
'RotateLook,rotation=180']]), 1), ['MoveAhead', 'RotateLook,rotation=180'])
def test_retrieve_goal(self):
goal_1 = self.controller.retrieve_goal({})
self.assertEqual(goal_1.action_list, None)
self.assertEqual(goal_1.info_list, [])
self.assertEqual(goal_1.last_step, None)
self.assertEqual(goal_1.task_list, [])
self.assertEqual(goal_1.type_list, [])
self.assertEqual(goal_1.metadata, {})
goal_2 = self.controller.retrieve_goal({
"goal": {
}
})
self.assertEqual(goal_2.action_list, None)
self.assertEqual(goal_2.info_list, [])
self.assertEqual(goal_2.last_step, None)
self.assertEqual(goal_2.task_list, [])
self.assertEqual(goal_2.type_list, [])
self.assertEqual(goal_2.metadata, {})
goal_3 = self.controller.retrieve_goal({
"goal": {
"action_list": [["action1"], [], ["action2", "action3", "action4"]],
"info_list": ["info1", "info2", 12.34],
"last_step": 10,
"task_list": ["task1", "task2"],
"type_list": ["type1", "type2"],
"metadata": {
"key": "value"
}
}
})
self.assertEqual(goal_3.action_list, [["action1"], [], ["action2", "action3", "action4"]])
self.assertEqual(goal_3.info_list, ["info1", "info2", 12.34])
self.assertEqual(goal_3.last_step, 10)
self.assertEqual(goal_3.task_list, ["task1", "task2"])
self.assertEqual(goal_3.type_list, ["type1", "type2"])
self.assertEqual(goal_3.metadata, {
"key": "value"
})
def test_retrieve_goal_with_config_metadata(self):
self.controller.set_config({ 'metadata': 'full' })
actual = self.controller.retrieve_goal({
'goal': {
'metadata': {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
}
}
})
self.assertEqual(actual.metadata, {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
self.controller.set_config({ 'metadata': 'no_navigation' })
actual = self.controller.retrieve_goal({
'goal': {
'metadata': {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
}
}
})
self.assertEqual(actual.metadata, {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
})
self.controller.set_config({ 'metadata': 'no_vision' })
actual = self.controller.retrieve_goal({
'goal': {
'metadata': {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
}
}
})
self.assertEqual(actual.metadata, {
'target': { 'image': None },
'target_1': { 'image': None },
'target_2': { 'image': None }
})
self.controller.set_config({ 'metadata': 'none' })
actual = self.controller.retrieve_goal({
'goal': {
'metadata': {
'target': { 'image': [0] },
'target_1': { 'image': [1] },
'target_2': { 'image': [2] }
}
}
})
self.assertEqual(actual.metadata, {
'target': { 'image': None },
'target_1': { 'image': None },
'target_2': { 'image': None }
})
def test_retrieve_head_tilt(self):
mock_scene_event_data = {
"metadata": {
"agent": {
"cameraHorizon": 12.34
}
}
}
actual = self.controller.retrieve_head_tilt(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(actual, 12.34)
mock_scene_event_data = {
"metadata": {
"agent": {
"cameraHorizon": -56.78
}
}
}
actual = self.controller.retrieve_head_tilt(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(actual, -56.78)
def test_retrieve_object_list(self):
mock_scene_event_data = self.create_retrieve_object_list_scene_event()
actual = self.controller.retrieve_object_list(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(len(actual), 2)
self.assertEqual(actual[0].uuid, "testId1")
self.assertEqual(actual[0].color, {
"r": 12,
"g": 34,
"b": 56
})
self.assertEqual(actual[0].dimensions, {})
self.assertEqual(actual[0].direction, {
"x": 0,
"y": 0,
"z": 0
})
self.assertEqual(actual[0].distance, 0)
self.assertEqual(actual[0].distance_in_steps, 0)
self.assertEqual(actual[0].distance_in_world, 0)
self.assertEqual(actual[0].held, True)
self.assertEqual(actual[0].mass, 1)
self.assertEqual(actual[0].material_list, [])
self.assertEqual(actual[0].position, { "x": 1, "y": 1, "z": 2 })
self.assertEqual(actual[0].rotation, 2.0)
self.assertEqual(actual[0].shape, 'shape1')
self.assertEqual(actual[0].texture_color_list, ['c1'])
self.assertEqual(actual[0].visible, True)
self.assertEqual(actual[1].uuid, "testId2")
self.assertEqual(actual[1].color, {
"r": 98,
"g": 76,
"b": 54
})
self.assertEqual(actual[1].dimensions, ["p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8"])
self.assertEqual(actual[1].direction, {
"x": 90,
"y": -30,
"z": 0
})
self.assertEqual(actual[1].distance, 2.2)
self.assertEqual(actual[1].distance_in_steps, 2.2)
self.assertEqual(actual[1].distance_in_world, 1.5)
self.assertEqual(actual[1].held, False)
self.assertEqual(actual[1].mass, 12.34)
self.assertEqual(actual[1].material_list, ["METAL", "PLASTIC"])
self.assertEqual(actual[1].position, { "x": 1, "y": 2, "z": 3 })
self.assertEqual(actual[1].rotation, 2)
self.assertEqual(actual[1].shape, 'shape2')
self.assertEqual(actual[1].texture_color_list, ['c2', 'c3'])
self.assertEqual(actual[1].visible, True)
def test_retrieve_object_list_with_config_metadata_full(self):
self.controller.set_config({ 'metadata': 'full' })
mock_scene_event_data = self.create_retrieve_object_list_scene_event()
actual = self.controller.retrieve_object_list(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(len(actual), 3)
self.assertEqual(actual[0].uuid, "testId1")
self.assertEqual(actual[0].color, {
"r": 12,
"g": 34,
"b": 56
})
self.assertEqual(actual[0].dimensions, {})
self.assertEqual(actual[0].direction, {
"x": 0,
"y": 0,
"z": 0
})
self.assertEqual(actual[0].distance, 0)
self.assertEqual(actual[0].distance_in_steps, 0)
self.assertEqual(actual[0].distance_in_world, 0)
self.assertEqual(actual[0].held, True)
self.assertEqual(actual[0].mass, 1)
self.assertEqual(actual[0].material_list, [])
self.assertEqual(actual[0].position, { "x": 1, "y": 1, "z": 2 })
self.assertEqual(actual[0].rotation, 2.0)
self.assertEqual(actual[0].shape, 'shape1')
self.assertEqual(actual[0].texture_color_list, ['c1'])
self.assertEqual(actual[0].visible, True)
self.assertEqual(actual[1].uuid, "testId2")
self.assertEqual(actual[1].color, {
"r": 98,
"g": 76,
"b": 54
})
self.assertEqual(actual[1].dimensions, ["p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8"])
self.assertEqual(actual[1].direction, {
"x": 90,
"y": -30,
"z": 0
})
self.assertEqual(actual[1].distance, 2.2)
self.assertEqual(actual[1].distance_in_steps, 2.2)
self.assertEqual(actual[1].distance_in_world, 1.5)
self.assertEqual(actual[1].held, False)
self.assertEqual(actual[1].mass, 12.34)
self.assertEqual(actual[1].material_list, ["METAL", "PLASTIC"])
self.assertEqual(actual[1].position, { "x": 1, "y": 2, "z": 3 })
self.assertEqual(actual[1].rotation, 2)
self.assertEqual(actual[1].shape, 'shape2')
self.assertEqual(actual[1].texture_color_list, ['c2', 'c3'])
self.assertEqual(actual[1].visible, True)
self.assertEqual(actual[2].uuid, "testId3")
self.assertEqual(actual[2].color, {
"r": 101,
"g": 102,
"b": 103
})
self.assertEqual(actual[2].dimensions, ["pA", "pB", "pC", "pD", "pE", "pF", "pG", "pH"])
self.assertEqual(actual[2].direction, {
"x": -90,
"y": 180,
"z": 270
})
self.assertEqual(actual[2].distance, 4)
self.assertEqual(actual[2].distance_in_steps, 4)
self.assertEqual(actual[2].distance_in_world, 2.5)
self.assertEqual(actual[2].held, False)
self.assertEqual(actual[2].mass, 34.56)
self.assertEqual(actual[2].material_list, ["WOOD"])
self.assertEqual(actual[2].position, { "x": -3, "y": -2, "z": -1 })
self.assertEqual(actual[2].rotation, 12)
self.assertEqual(actual[2].shape, 'shape3')
self.assertEqual(actual[2].texture_color_list, [])
self.assertEqual(actual[2].visible, False)
def test_retrieve_object_list_with_config_metadata_no_navigation(self):
self.controller.set_config({ 'metadata': 'no_navigation' })
mock_scene_event_data = self.create_retrieve_object_list_scene_event()
actual = self.controller.retrieve_object_list(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(len(actual), 2)
self.assertEqual(actual[0].uuid, "testId1")
self.assertEqual(actual[0].color, {
"r": 12,
"g": 34,
"b": 56
})
self.assertEqual(actual[0].dimensions, {})
self.assertEqual(actual[0].direction, {
"x": 0,
"y": 0,
"z": 0
})
self.assertEqual(actual[0].distance, 0)
self.assertEqual(actual[0].distance_in_steps, 0)
self.assertEqual(actual[0].distance_in_world, 0)
self.assertEqual(actual[0].held, True)
self.assertEqual(actual[0].mass, 1)
self.assertEqual(actual[0].material_list, [])
self.assertEqual(actual[0].position, None)
self.assertEqual(actual[0].rotation, None)
self.assertEqual(actual[0].shape, 'shape1')
self.assertEqual(actual[0].texture_color_list, ['c1'])
self.assertEqual(actual[0].visible, True)
self.assertEqual(actual[1].uuid, "testId2")
self.assertEqual(actual[1].color, {
"r": 98,
"g": 76,
"b": 54
})
self.assertEqual(actual[1].dimensions, ["p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8"])
self.assertEqual(actual[1].direction, {
"x": 90,
"y": -30,
"z": 0
})
self.assertEqual(actual[1].distance, 2.2)
self.assertEqual(actual[1].distance_in_steps, 2.2)
self.assertEqual(actual[1].distance_in_world, 1.5)
self.assertEqual(actual[1].held, False)
self.assertEqual(actual[1].mass, 12.34)
self.assertEqual(actual[1].material_list, ["METAL", "PLASTIC"])
self.assertEqual(actual[1].position, None)
self.assertEqual(actual[1].rotation, None)
self.assertEqual(actual[1].shape, 'shape2')
self.assertEqual(actual[1].texture_color_list, ['c2', 'c3'])
self.assertEqual(actual[1].visible, True)
def test_retrieve_object_list_with_config_metadata_no_vision(self):
self.controller.set_config({ 'metadata': 'no_vision' })
mock_scene_event_data = self.create_retrieve_object_list_scene_event()
actual = self.controller.retrieve_object_list(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(len(actual), 2)
self.assertEqual(actual[0].uuid, "testId1")
self.assertEqual(actual[0].color, None)
self.assertEqual(actual[0].dimensions, None)
self.assertEqual(actual[0].direction, None)
self.assertEqual(actual[0].distance, None)
self.assertEqual(actual[0].distance_in_steps, None)
self.assertEqual(actual[0].distance_in_world, None)
self.assertEqual(actual[0].held, True)
self.assertEqual(actual[0].mass, 1)
self.assertEqual(actual[0].material_list, [])
self.assertEqual(actual[0].position, { "x": 1, "y": 1, "z": 2 })
self.assertEqual(actual[0].rotation, 2.0)
self.assertEqual(actual[0].shape, None)
self.assertEqual(actual[0].texture_color_list, None)
self.assertEqual(actual[0].visible, True)
self.assertEqual(actual[1].uuid, "testId2")
self.assertEqual(actual[1].color, None)
self.assertEqual(actual[1].dimensions, None)
self.assertEqual(actual[1].direction, None)
self.assertEqual(actual[1].distance, None)
self.assertEqual(actual[1].distance_in_steps, None)
self.assertEqual(actual[1].distance_in_world, None)
self.assertEqual(actual[1].held, False)
self.assertEqual(actual[1].mass, 12.34)
self.assertEqual(actual[1].material_list, ["METAL", "PLASTIC"])
self.assertEqual(actual[1].position, { "x": 1, "y": 2, "z": 3 })
self.assertEqual(actual[1].rotation, 2)
self.assertEqual(actual[1].shape, None)
self.assertEqual(actual[1].texture_color_list, None)
self.assertEqual(actual[1].visible, True)
def test_retrieve_object_list_with_config_metadata_none(self):
self.controller.set_config({ 'metadata': 'none' })
mock_scene_event_data = self.create_retrieve_object_list_scene_event()
actual = self.controller.retrieve_object_list(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(len(actual), 2)
self.assertEqual(actual[0].uuid, "testId1")
self.assertEqual(actual[0].color, None)
self.assertEqual(actual[0].dimensions, None)
self.assertEqual(actual[0].direction, None)
self.assertEqual(actual[0].distance, None)
self.assertEqual(actual[0].distance_in_steps, None)
self.assertEqual(actual[0].distance_in_world, None)
self.assertEqual(actual[0].held, True)
self.assertEqual(actual[0].mass, 1)
self.assertEqual(actual[0].material_list, [])
self.assertEqual(actual[0].position, None)
self.assertEqual(actual[0].rotation, None)
self.assertEqual(actual[0].shape, None)
self.assertEqual(actual[0].texture_color_list, None)
self.assertEqual(actual[0].visible, True)
self.assertEqual(actual[1].uuid, "testId2")
self.assertEqual(actual[1].color, None)
self.assertEqual(actual[1].dimensions, None)
self.assertEqual(actual[1].direction, None)
self.assertEqual(actual[1].distance, None)
self.assertEqual(actual[1].distance_in_steps, None)
self.assertEqual(actual[1].distance_in_world, None)
self.assertEqual(actual[1].held, False)
self.assertEqual(actual[1].mass, 12.34)
self.assertEqual(actual[1].material_list, ["METAL", "PLASTIC"])
self.assertEqual(actual[1].position, None)
self.assertEqual(actual[1].rotation, None)
self.assertEqual(actual[1].shape, None)
self.assertEqual(actual[1].texture_color_list, None)
self.assertEqual(actual[1].visible, True)
def test_retrieve_pose(self):
# TODO MCS-18
pass
def test_retrieve_return_status(self):
mock_scene_event_data = {
"metadata": {
"lastActionStatus": "SUCCESSFUL"
}
}
actual = self.controller.retrieve_return_status(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(actual, MCS_Return_Status.SUCCESSFUL.name)
mock_scene_event_data = {
"metadata": {
"lastActionStatus": "FAILED"
}
}
actual = self.controller.retrieve_return_status(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(actual, MCS_Return_Status.FAILED.name)
mock_scene_event_data = {
"metadata": {
"lastActionStatus": "INVALID_STATUS"
}
}
actual = self.controller.retrieve_return_status(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(actual, MCS_Return_Status.UNDEFINED.name)
mock_scene_event_data = {
"metadata": {
"lastActionStatus": None
}
}
actual = self.controller.retrieve_return_status(self.create_mock_scene_event(mock_scene_event_data))
self.assertEqual(actual, MCS_Return_Status.UNDEFINED.name)
def test_save_images(self):
image_data = numpy.array([[0]], dtype=numpy.uint8)
depth_mask_data = numpy.array([[128]], dtype=numpy.uint8)
object_mask_data = numpy.array([[192]], dtype=numpy.uint8)
mock_scene_event_data = {
"events": [self.create_mock_scene_event({
"depth_frame": depth_mask_data,
"frame": image_data,
"instance_segmentation_frame": object_mask_data
})]
}
image_list, depth_mask_list, object_mask_list = self.controller.save_images(self.create_mock_scene_event(
mock_scene_event_data))
self.assertEqual(len(image_list), 1)
self.assertEqual(len(depth_mask_list), 1)
self.assertEqual(len(object_mask_list), 1)
self.assertEqual( | numpy.array(image_list[0]) | numpy.array |
from tkinter import filedialog, Tk
from typing import List
import matplotlib.pyplot as plt
import numpy as np
from lmfit import Model
from lmfit.models import GaussianModel, LinearModel
from pandas import read_csv, read_hdf, DataFrame, set_option
from scipy import fftpack, interpolate
from scipy.optimize import curve_fit
from seaborn import set_style
from range_selector import RangeTool
set_option('column_space', 80)
set_style("whitegrid")
# set_palette(["#9b59b6", "#3498db", "#95a5a6", "#e74c3c", "#34495e", "#2ecc71"])
e = 2.7182818
def find_nearest(array, value):
idx = ( | np.abs(array - value) | numpy.abs |
import numpy as np
from econml.utilities import cross_product
from statsmodels.tools.tools import add_constant
class AbstracDynamicPanelDGP:
def __init__(self, n_periods, n_treatments, n_x):
self.n_periods = n_periods
self.n_treatments = n_treatments
self.n_x = n_x
return
def create_instance(self, *args, **kwargs):
pass
def _gen_data_with_policy(self, n_units, policy_gen, random_seed=123):
pass
def static_policy_data(self, n_units, tau, random_seed=123):
def policy_gen(Tpre, X, period):
return tau[period]
return self._gen_data_with_policy(n_units, policy_gen, random_seed=random_seed)
def adaptive_policy_data(self, n_units, policy_gen, random_seed=123):
return self._gen_data_with_policy(n_units, policy_gen, random_seed=random_seed)
def static_policy_effect(self, tau, mc_samples=1000):
Y_tau, _, _, _ = self.static_policy_data(mc_samples, tau)
Y_zero, _, _, _ = self.static_policy_data(
mc_samples, np.zeros((self.n_periods, self.n_treatments)))
return np.mean(Y_tau[np.arange(Y_tau.shape[0]) % self.n_periods == self.n_periods - 1]) - \
np.mean(Y_zero[np.arange(Y_zero.shape[0]) %
self.n_periods == self.n_periods - 1])
def adaptive_policy_effect(self, policy_gen, mc_samples=1000):
Y_tau, _, _, _ = self.adaptive_policy_data(mc_samples, policy_gen)
Y_zero, _, _, _ = self.static_policy_data(
mc_samples, np.zeros((self.n_periods, self.n_treatments)))
return np.mean(Y_tau[np.arange(Y_tau.shape[0]) % self.n_periods == self.n_periods - 1]) - \
np.mean(Y_zero[np.arange(Y_zero.shape[0]) %
self.n_periods == self.n_periods - 1])
class DynamicPanelDGP(AbstracDynamicPanelDGP):
def __init__(self, n_periods, n_treatments, n_x):
super().__init__(n_periods, n_treatments, n_x)
def create_instance(self, s_x, sigma_x, sigma_y, conf_str, hetero_strength=0, hetero_inds=None,
autoreg=.5, state_effect=.5, random_seed=123):
np.random.seed(random_seed)
self.s_x = s_x
self.conf_str = conf_str
self.sigma_x = sigma_x
self.sigma_y = sigma_y
self.hetero_inds = hetero_inds.astype(
int) if hetero_inds is not None else hetero_inds
self.endo_inds = np.setdiff1d(
np.arange(self.n_x), hetero_inds).astype(int)
# The first s_x state variables are confounders. The final s_x variables are exogenous and can create
# heterogeneity
self.Alpha = np.random.uniform(-1, 1,
size=(self.n_x, self.n_treatments))
self.Alpha /= np.linalg.norm(self.Alpha, axis=1, ord=1, keepdims=True)
self.Alpha *= state_effect
if self.hetero_inds is not None:
self.Alpha[self.hetero_inds] = 0
self.Beta = np.zeros((self.n_x, self.n_x))
for t in range(self.n_x):
self.Beta[t, :] = autoreg * np.roll(np.random.uniform(low=4.0**(-np.arange(
0, self.n_x)), high=4.0**(-np.arange(1, self.n_x + 1))), t)
if self.hetero_inds is not None:
self.Beta[np.ix_(self.endo_inds, self.hetero_inds)] = 0
self.Beta[np.ix_(self.hetero_inds, self.endo_inds)] = 0
self.epsilon = np.random.uniform(-1, 1, size=self.n_treatments)
self.zeta = np.zeros(self.n_x)
self.zeta[:self.s_x] = self.conf_str / self.s_x
self.y_hetero_effect = np.zeros(self.n_x)
self.x_hetero_effect = np.zeros(self.n_x)
if self.hetero_inds is not None:
self.y_hetero_effect[self.hetero_inds] = np.random.uniform(.5 * hetero_strength, 1.5 * hetero_strength) / \
len(self.hetero_inds)
self.x_hetero_effect[self.hetero_inds] = np.random.uniform(.5 * hetero_strength, 1.5 * hetero_strength) / \
len(self.hetero_inds)
self.true_effect = np.zeros((self.n_periods, self.n_treatments))
self.true_effect[0] = self.epsilon
for t in np.arange(1, self.n_periods):
self.true_effect[t, :] = (self.zeta.reshape(
1, -1) @ np.linalg.matrix_power(self.Beta, t - 1) @ self.Alpha)
self.true_hetero_effect = np.zeros(
(self.n_periods, (self.n_x + 1) * self.n_treatments))
self.true_hetero_effect[0, :] = cross_product(add_constant(self.y_hetero_effect.reshape(1, -1), has_constant='add'),
self.epsilon.reshape(1, -1))
for t in np.arange(1, self.n_periods):
self.true_hetero_effect[t, :] = cross_product(add_constant(self.x_hetero_effect.reshape(1, -1), has_constant='add'),
self.zeta.reshape(1, -1) @ np.linalg.matrix_power(self.Beta, t - 1) @ self.Alpha)
return self
def hetero_effect_fn(self, t, x):
if t == 0:
return (np.dot(self.y_hetero_effect, x.flatten()) + 1) * self.epsilon
else:
return (np.dot(self.x_hetero_effect, x.flatten()) + 1) *\
(self.zeta.reshape(1, -1) @ np.linalg.matrix_power(self.Beta, t - 1)
@ self.Alpha).flatten()
def _gen_data_with_policy(self, n_units, policy_gen, random_seed=123):
np.random.seed(random_seed)
Y = np.zeros(n_units * self.n_periods)
T = np.zeros((n_units * self.n_periods, self.n_treatments))
X = np.zeros((n_units * self.n_periods, self.n_x))
groups = np.zeros(n_units * self.n_periods)
for t in range(n_units * self.n_periods):
period = t % self.n_periods
if period == 0:
X[t] = np.random.normal(0, self.sigma_x, size=self.n_x)
T[t] = policy_gen(np.zeros(self.n_treatments), X[t], period)
else:
X[t] = (np.dot(self.x_hetero_effect, X[t - 1]) + 1) * np.dot(self.Alpha, T[t - 1]) + \
np.dot(self.Beta, X[t - 1]) + \
np.random.normal(0, self.sigma_x, size=self.n_x)
T[t] = policy_gen(T[t - 1], X[t], period)
Y[t] = (np.dot(self.y_hetero_effect, X[t]) + 1) * np.dot(self.epsilon, T[t]) + \
np.dot(X[t], self.zeta) + \
np.random.normal(0, self.sigma_y)
groups[t] = t // self.n_periods
return Y, T, X, groups
def observational_data(self, n_units, gamma, s_t, sigma_t, random_seed=123):
""" Generated observational data with some observational treatment policy parameters
Parameters
----------
n_units : how many units to observe
gamma : what is the degree of auto-correlation of the treatments across periods
s_t : sparsity of treatment policy; how many states does it depend on
sigma_t : what is the std of the exploration/randomness in the treatment
"""
Delta = np.zeros((self.n_treatments, self.n_x))
Delta[:, :s_t] = self.conf_str / s_t
def policy_gen(Tpre, X, period):
return gamma * Tpre + (1 - gamma) * np.dot(Delta, X) + \
np.random.normal(0, sigma_t, size=self.n_treatments)
return self._gen_data_with_policy(n_units, policy_gen, random_seed=random_seed)
class LongRangeDynamicPanelDGP(DynamicPanelDGP):
def __init__(self, n_periods, n_treatments, n_x):
super().__init__(n_periods, n_treatments, n_x)
def create_instance(self, s_x, sigma_x, sigma_y, conf_str, hetero_strength=0, hetero_inds=None,
autoreg=.5, state_effect=.5, random_seed=123):
np.random.seed(random_seed)
self.s_x = s_x
self.conf_str = conf_str
self.sigma_x = sigma_x
self.sigma_y = sigma_y
self.hetero_inds = hetero_inds.astype(
int) if hetero_inds is not None else hetero_inds
self.endo_inds = np.setdiff1d(
np.arange(self.n_x), hetero_inds).astype(int)
# The first s_x state variables are confounders. The final s_x variables are exogenous and can create
# heterogeneity
self.Alpha = state_effect * np.ones((self.n_x, self.n_treatments))
if self.hetero_inds is not None:
self.Alpha[self.hetero_inds] = 0
self.Beta = autoreg * np.eye(self.n_x)
self.epsilon = np.random.uniform(-1, 1, size=self.n_treatments)
self.zeta = np.zeros(self.n_x)
self.zeta[:self.s_x] = self.conf_str / self.s_x
self.y_hetero_effect = np.zeros(self.n_x)
self.x_hetero_effect = np.zeros(self.n_x)
if self.hetero_inds is not None:
self.y_hetero_effect[self.hetero_inds] = np.random.uniform(.5 * hetero_strength, 1.5 * hetero_strength) / \
len(self.hetero_inds)
self.x_hetero_effect[self.hetero_inds] = np.random.uniform(.5 * hetero_strength, 1.5 * hetero_strength) / \
len(self.hetero_inds)
self.true_effect = np.zeros((self.n_periods, self.n_treatments))
self.true_effect[0] = self.epsilon
for t in np.arange(1, self.n_periods):
self.true_effect[t, :] = (self.zeta.reshape(
1, -1) @ np.linalg.matrix_power(self.Beta, t - 1) @ self.Alpha)
self.true_hetero_effect = np.zeros(
(self.n_periods, (self.n_x + 1) * self.n_treatments))
self.true_hetero_effect[0, :] = cross_product(add_constant(self.y_hetero_effect.reshape(1, -1), has_constant='add'),
self.epsilon.reshape(1, -1))
for t in np.arange(1, self.n_periods):
self.true_hetero_effect[t, :] = cross_product(add_constant(self.x_hetero_effect.reshape(1, -1), has_constant='add'),
self.zeta.reshape(1, -1) @ np.linalg.matrix_power(self.Beta, t - 1) @ self.Alpha)
return self
class EndogenousDynamicPanelDGP(DynamicPanelDGP):
def __init__(self, n_periods, n_treatments, n_x):
super().__init__(n_periods, n_treatments, n_x)
def create_instance(self, s_x, sigma_x, sigma_y, conf_str, hetero_strength=0, hetero_inds=None,
autoreg=.5, state_effect=.5, random_seed=123):
np.random.seed(random_seed)
self.s_x = s_x
self.conf_str = conf_str
self.sigma_x = sigma_x
self.sigma_y = sigma_y
self.hetero_inds = hetero_inds.astype(
int) if hetero_inds is not None else hetero_inds
# The first s_x state variables are confounders. The final s_x variables are exogenous and can create
# heterogeneity
self.Alpha = state_effect * \
np.ones((self.n_x, self.n_treatments))/self.n_treatments
self.Beta = autoreg * np.eye(self.n_x)
self.epsilon = np.random.uniform(-1, 1, size=self.n_treatments)
self.zeta = np.zeros(self.n_x)
self.zeta[:self.s_x] = self.conf_str / self.s_x
self.y_hetero_effect = np.zeros(self.n_x)
self.x_hetero_effect = np.zeros(self.n_x)
if self.hetero_inds is not None:
self.y_hetero_effect[self.hetero_inds] = np.random.uniform(.5 * hetero_strength, 1.5 * hetero_strength) / \
len(self.hetero_inds)
self.x_hetero_effect[self.hetero_inds] = np.random.uniform(.5 * hetero_strength, 1.5 * hetero_strength) / \
len(self.hetero_inds)
self.true_effect = np.zeros((self.n_periods, self.n_treatments))
self.true_effect[0] = self.epsilon
for t in np.arange(1, self.n_periods):
self.true_effect[t, :] = (self.zeta.reshape(
1, -1) @ np.linalg.matrix_power(self.Beta, t - 1) @ self.Alpha)
self.true_hetero_effect = np.zeros(
(self.n_periods, (self.n_x + 1) * self.n_treatments))
self.true_hetero_effect[0, :] = cross_product(add_constant(self.y_hetero_effect.reshape(1, -1), has_constant='add'),
self.epsilon.reshape(1, -1))
for t in np.arange(1, self.n_periods):
self.true_hetero_effect[t, :] = cross_product(add_constant(self.x_hetero_effect.reshape(1, -1), has_constant='add'),
self.zeta.reshape(1, -1) @ np.linalg.matrix_power(self.Beta, t - 1) @ self.Alpha)
return self
class PastTreatmentHeteroDynamicPanelDGP(DynamicPanelDGP):
def __init__(self, n_periods, n_treatments, n_x):
super().__init__(n_periods, n_treatments, n_x)
def create_instance(self, s_x, sigma_x, sigma_y, conf_str, hetero_strength=0, hetero_inds=None,
autoreg=.5, state_effect=.5, random_seed=123):
np.random.seed(random_seed)
self.s_x = s_x
self.conf_str = conf_str
self.sigma_x = sigma_x
self.sigma_y = sigma_y
self.hetero_inds = np.arange(self.n_x - self.n_treatments, self.n_x)
self.Alpha = state_effect * \
np.ones((self.n_x, self.n_treatments))/self.n_treatments
self.Alpha[-self.n_treatments:, -
self.n_treatments:] = state_effect * np.eye(self.n_treatments)
self.Beta = autoreg * np.eye(self.n_x)
self.epsilon = np.random.uniform(-1, 1, size=self.n_treatments)
self.zeta = np.zeros(self.n_x)
self.zeta[:self.s_x] = self.conf_str / self.s_x
self.y_hetero_effect = np.zeros(self.n_x)
self.x_hetero_effect = np.zeros(self.n_x)
if self.hetero_inds is not None:
self.y_hetero_effect[self.hetero_inds] = hetero_strength / \
len(self.hetero_inds)
self.x_hetero_effect[self.hetero_inds] = hetero_strength / \
len(self.hetero_inds)
self.true_effect = np.zeros((self.n_periods, self.n_treatments))
self.true_effect[0] = self.epsilon
for t in np.arange(1, self.n_periods):
self.true_effect[t, :] = (self.zeta.reshape(
1, -1) @ np.linalg.matrix_power(self.Beta, t - 1) @ self.Alpha)
self.true_hetero_effect = np.zeros(
(self.n_periods, (self.n_x + 1) * self.n_treatments))
self.true_hetero_effect[0, :] = cross_product(add_constant(self.y_hetero_effect.reshape(1, -1), has_constant='add'),
self.epsilon.reshape(1, -1))
for t in np.arange(1, self.n_periods):
self.true_hetero_effect[t, :] = cross_product(add_constant(self.x_hetero_effect.reshape(1, -1), has_constant='add'),
self.zeta.reshape(1, -1) @ | np.linalg.matrix_power(self.Beta, t - 1) | numpy.linalg.matrix_power |
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation, cm
from mpl_toolkits.mplot3d import Axes3D
# create a figure
fig = plt.figure()
# initialise 3D Axes
ax = Axes3D(fig)
# remove background grid, fill and axis
ax.grid(False)
ax.xaxis.pane.fill = ax.yaxis.pane.fill = ax.zaxis.pane.fill = False
plt.axis('off')
# tighter fit to window
plt.tight_layout()
# create surface values
x = np.arange(-5, 5, 0.25)
y = np.arange(-5, 5, 0.25)
xx, yy = np.meshgrid(x, y)
r = np.sqrt(xx ** 2 + yy ** 2)
z = | np.cos(r) | numpy.cos |
""" A collection of functions to generate a generic model
Statistics and boundary conditions used are documented in
TODO: Source Final Report
"""
import numpy as np
import pandas as pd
import logging as lg
from SystemComponentsFast import Agent, Building, Cell, SepBSLagent
lg.basicConfig(level=lg.WARNING)
def _addAgents(building, pAgent, pPHH, pAgriculture):
""" Add agents to building
Args:
building (Building): Object to represent building
pAgent (float32): Probability that agents is created
(Corresponds to the propotion of agents on
max. possible Agents in Building(s))
pPHH (float32): Proportion of PHH agents in Building
pAgriculture (float32): Proportion of BSL agents which are
agricultural
Returns:
Building: Building object with agents
"""
for aNr in range(building.n_max_agents):
if np.random.random() > pAgent:
continue
# determine agent type
if np.random.random() <= pPHH:
aType = 0
else:
if | np.random.random() | numpy.random.random |
import numpy as np
from numpy.ma.core import MaskedArray
from scipy.special import gammaln, digamma, polygamma
from math import log, exp
import cvxopt as cvx
from cvxopt import solvers
import time, pdb
from ribohmm import utils
from ribohmm.utils import Mappability, States
from collections import namedtuple
import logging
logger = logging.getLogger('viterbi_log')
solvers.options['maxiters'] = 300
solvers.options['show_progress'] = False
CandidateCDS = namedtuple('CandidateCDS', 'frame start stop')
def logistic(x):
return 1 / (1 + np.exp(x))
def nplog(x):
return np.nan_to_num(np.log(x))
def normalize(arr):
"""Compute the log-sum-exp of a real-valued vector,
avoiding numerical overflow issues.
Arguments:
x : numpy vector (float64)
Returns:
c : scalar (float64)
"""
arr_max = np.max(arr)
c = 0
for val in arr:
c += exp(val - arr_max)
c = log(c) + arr_max
return c
# cdef np.ndarray[np.float64_t, ndim=1] outsum(np.ndarray[np.float64_t, ndim=2] arr):
def outsum(arr):
"""Fast summation over the 0-th axis.
Faster than numpy.sum()
"""
# cdef np.ndarray thesum
return sum([a for a in arr])
class Data:
def __init__(self, riboseq_pileup, codon_map, transcript_normalization_factor, is_pos_mappable):
"""Instantiates a data object for a transcript and populates it
with observed ribosome-profiling data, expression RPKM as its
scaling factor, and the DNA sequence of each triplet in the
transcript in each frame and the missingness-type for each
triplet in the transcript in each frame.
footprint_counts (riboseq_pileup, formerly obs)
======================
List of size num_transcripts, where each element is an array of shape (len_transcript, num_footprint_lengths)
This is the riboseq pileup at each position of a transcript. This is a list of transcripts, where each
transcript is represented by an array of integers. The outer element is the position in the transcript, and the
inner element is for each footprint length.
codon_map
========
A dictionary with three keys: kozak, start, and stop. The values for each of those keys is an array of size
(num_codons, 3), where the 3 is for each possible reading frame.
The start array maps to the list of start codons in utils.STARTCODONS, and the stop array does the same.
ex:
[
[0 1 0],
[0 0 0],
[3 0 0]
]
means that there is an AUG codon in the first triplet of the second open reading frame, and an GUG codon in the
third triplet of the first open reading frame
rna_counts (scale)
==================
A scaling factor based on observed RNAseq counts. Is a scalar value that is transcript specific.
obs: footprint counts
codon_id: codon flags
scale: rna_counts
mappable: rna_mappability
"""
# cdef double r,m,f
# cdef np.ndarray ma, mapp
# length of transcript
self.transcript_length = riboseq_pileup.shape[0]
# length of HMM
self.n_triplets = int(self.transcript_length / 3) - 1
# number of distinct footprint lengths
self.n_footprint_lengths = riboseq_pileup.shape[1]
# observed ribosome-profiling data
self.riboseq_pileup = riboseq_pileup
# transcript expression RPKM as scaling factor
self.transcript_normalization_factor = transcript_normalization_factor
# mappability of each position for each footprint length, values are boolean
self.is_pos_mappable = is_pos_mappable
# ensure that all unmappable positions have a zero footprint count
self.riboseq_pileup[~self.is_pos_mappable] = 0
# codon type of each triplet in each frame
self.codon_map = codon_map
# missingness-type of each triplet in each frame for each footprint length
self.missingness_type = np.zeros((self.n_footprint_lengths, 3, self.n_triplets), dtype=np.uint8)
# total footprint count for each triplet in each frame for each footprint length
self.total_pileup = np.empty((3, self.n_triplets, self.n_footprint_lengths), dtype=np.uint64)
# Compute missingness type and total footprint count in each triplet
for frame_i in range(3):
for footprint_length_i in range(self.n_footprint_lengths):
# Get mappability information and reshapes into a 2-dim array, where the number of rows is equal to
# the number of triplets and the columns are for each frame index
frame_sequence_positions = slice(frame_i, 3 * self.n_triplets + frame_i)
per_triplet_mappability = (
self.is_pos_mappable[frame_sequence_positions, footprint_length_i]
.reshape(self.n_triplets, 3)
)
# missingness pattern of a triplet can belong to one of 8 types,
# depending on which of the 3 positions are unmappable
# Each triplet will be represented by an integer that corresponds to a value in utils.binarize
# Each value ma in each iteration represents one triplet (so will be length 3)
self.missingness_type[footprint_length_i, frame_i, :] = np.array([
utils.debinarize[triplet_mappability.tostring()]
for triplet_mappability in per_triplet_mappability
]).astype(np.uint8)
# Gets the total pileup count from the riboseq data for each triplet in this frame
self.total_pileup[frame_i, :, footprint_length_i] = (
np.sum(self.riboseq_pileup[frame_sequence_positions, footprint_length_i]
.reshape(self.n_triplets, 3), axis=1)
)
def compute_log_probability(self, emission):
"""Computes the log probability of the data given model parameters.
Log probability of data is the sum of log probability at positions
under the HMM and log probability at extra positions.
Arguments:
emission : instance of `Emission`
containing estimates of
emission model parameters
"""
# Create array to store log probability
# It is 3-dimensional:
# - 1st dim is frame index, of size 3
# - 2nd dim is triplet index, of size n_triplets
# - 3rd dim is state index, of size emission.S, which is 9
# In this case, log probability is the log of the likelihood that
self.log_probability = np.zeros((3, self.n_triplets, emission['S']), dtype=np.float64)
self.extra_log_probability = np.zeros((3,), dtype=np.float64)
# missingness-types where 1 out of 3 positions are unmappable
# This is based utils.binarize, the below indexes all have 1 position unmappable
# Except that isn't true? That's what the comment from the original code says, but as far as I can
# tell, this maps to the following, where False means unmappable:
# - [False, True, True]
# - [True, False, True]
# - [True, True, False]
# - [True, True, True]
# Why is 7 included in this?
# one_base_unmappable = np.array([3, 5, 6, 7]).reshape(4, 1)
one_base_unmappable = np.array([
Mappability.UMM,
Mappability.MUM,
Mappability.MMU,
Mappability.MMM
]).reshape(4, 1)
# loop over possible frames
for frame_i in range(3):
# loop over footprint lengths
for footprint_length_i in range(self.n_footprint_lengths):
# The local log probability for this frame index and footprint length index
log_probability = np.zeros((self.n_triplets, emission['S']), dtype=np.float64)
# Riboseq pileup for all the triplets in this frame index, then reshaped to where each row is a
# triplet with three values
frame_positions = slice(frame_i, 3 * self.n_triplets + frame_i)
frame_pileups = self.riboseq_pileup[frame_positions, footprint_length_i].reshape(self.n_triplets, 3)
# probability under periodicity model, accounting for mappability
# triplets with at most 1 unmappable position
# For each triplet in the transcript, for this footprint length and frame index, determine which
# triplets match one of the missingness types that have one unmappable position
triplet_one_base_unmappable = np.any(
self.missingness_type[footprint_length_i, frame_i, :] == one_base_unmappable,
axis=0
)
# Calculate the log probability of those triplets which have one unmappable position, for each
# possible state
log_probability[triplet_one_base_unmappable, :] = (
(
# Give total riboseq pileup for each triplet, for this footprint length and frame index, to
# the natural log of the gamma function (https://www.desmos.com/calculator/q4evkl4ekm)
gammaln(self.total_pileup[frame_i, triplet_one_base_unmappable, footprint_length_i] + 1)
# Base pileups for each triplet in this frame index, given to the natural log of the
# gamma function
- np.sum(gammaln(frame_pileups[triplet_one_base_unmappable, :] + 1), axis=1)
# Reshape to put each value in its own row, with 1 column
).reshape(triplet_one_base_unmappable.sum(), 1)
# Inner product of the base pileup for each triplet in this frame index and the emission
# log periodicity for this footprint length
+ np.dot(
frame_pileups[triplet_one_base_unmappable, :],
emission['logperiodicity'][footprint_length_i].T
)
)
# Iterate through each missingness type that has one unmappable position
# Subtract some log probability from each triplet which has one unmappable position
for mtype in one_base_unmappable[:3, 0]:
mapAB = self.missingness_type[footprint_length_i, frame_i, :] == mtype
log_probability[mapAB, :] -= np.dot(
self.total_pileup[frame_i, mapAB, footprint_length_i:footprint_length_i + 1],
utils.nplog(emission['rescale'][footprint_length_i:footprint_length_i + 1, :, mtype])
)
# probability under occupancy model, accounting for mappability
# The alpha and beta model parameters are arrays of size (n_footprint_lengths, n_states)
# alpha and beta below are 1-D arrays of size n_states
alpha = emission['rate_alpha'][footprint_length_i]
beta = emission['rate_beta'][footprint_length_i]
# The rescale variable ends up being an array of size n_triplets, where each values corresponds to
# the rescale value for that triplet's missingness type
rescale = emission['rescale'][footprint_length_i, :, self.missingness_type[footprint_length_i, frame_i, :]]
# Total pileup for each triplet, where each value is a single-element array
total = self.total_pileup[frame_i, :, footprint_length_i:footprint_length_i + 1]
rate_log_probability = (
alpha * beta * utils.nplog(beta) +
gammaln(alpha*beta + total) -
gammaln(alpha*beta) -
gammaln(total + 1) +
total * utils.nplog(self.transcript_normalization_factor * rescale) -
(alpha * beta + total) * utils.nplog(beta + self.transcript_normalization_factor * rescale)
)
# ensure that triplets with all positions unmappable
# do not contribute to the data probability
mask = self.missingness_type[footprint_length_i, frame_i, :] == Mappability.UUU
rate_log_probability[mask, :] = 0
# Store the log probability
self.log_probability[frame_i] += log_probability + rate_log_probability
# likelihood of extra positions in transcript
# Compute likelihood for bases before the core sequence of triplets
# TODO Consolidate this code, make it DRY
for extra_base_pos in range(frame_i):
if self.is_pos_mappable[extra_base_pos, footprint_length_i]:
self.extra_log_probability[frame_i] += (
alpha[States.ST_5PRIME_UTS] * beta[States.ST_5PRIME_UTS] * utils.nplog(beta[States.ST_5PRIME_UTS]) -
(alpha[States.ST_5PRIME_UTS] * beta[States.ST_5PRIME_UTS] + self.riboseq_pileup[extra_base_pos, footprint_length_i]) *
utils.nplog(beta[States.ST_5PRIME_UTS] + self.transcript_normalization_factor / 3.) +
gammaln(alpha[States.ST_5PRIME_UTS] * beta[States.ST_5PRIME_UTS]+self.riboseq_pileup[extra_base_pos, footprint_length_i]) -
gammaln(alpha[States.ST_5PRIME_UTS] * beta[States.ST_5PRIME_UTS]) +
self.riboseq_pileup[extra_base_pos, footprint_length_i] * utils.nplog(self.transcript_normalization_factor / 3.) -
gammaln(self.riboseq_pileup[extra_base_pos, footprint_length_i] + 1)
)
# Compute likelihood for bases after the core sequence of triplets
for extra_base_pos in range(3 * self.n_triplets + frame_i, self.transcript_length):
if self.is_pos_mappable[extra_base_pos, footprint_length_i]:
self.extra_log_probability[frame_i] += (
alpha[States.ST_3PRIME_UTS] * beta[States.ST_3PRIME_UTS] * utils.nplog(beta[States.ST_3PRIME_UTS]) -
(alpha[States.ST_3PRIME_UTS] * beta[States.ST_3PRIME_UTS] + self.riboseq_pileup[extra_base_pos, footprint_length_i]) *
utils.nplog(beta[States.ST_3PRIME_UTS] + self.transcript_normalization_factor / 3.) +
gammaln(alpha[States.ST_3PRIME_UTS] * beta[States.ST_3PRIME_UTS] + self.riboseq_pileup[extra_base_pos, footprint_length_i]) -
gammaln(alpha[States.ST_3PRIME_UTS] * beta[States.ST_3PRIME_UTS]) +
self.riboseq_pileup[extra_base_pos, footprint_length_i] * utils.nplog(self.transcript_normalization_factor / 3.) -
gammaln(self.riboseq_pileup[extra_base_pos, footprint_length_i] + 1)
)
# check for infs or nans in log likelihood
if np.isnan(self.log_probability).any() or np.isinf(self.log_probability).any():
print('Warning: Inf/Nan in data log likelihood')
pdb.set_trace()
if np.isnan(self.extra_log_probability).any() or np.isinf(self.extra_log_probability).any():
print('Warning: Inf/Nan in extra log likelihood')
pdb.set_trace()
def compute_log_probability_(self, emission):
self.log_likelihood = np.zeros((3, self.n_triplets, emission['S']), dtype=np.float64)
self.extra_log_likelihood = np.zeros((3,), dtype=np.float64)
self.missing = ~self.is_pos_mappable
for f in range(3):
for r in range(self.n_footprint_lengths):
log_likelihood = np.zeros((self.n_triplets,emission['S']), dtype=np.float64)
# periodicity likelihood
count_data = np.array([self.riboseq_pileup[3*m+f:3*m+3+f,r] for m in range(self.n_triplets)]).astype(np.uint64)
log_likelihood += np.dot(
count_data,
emission['logperiodicity'][r]
) + gammaln(self.total_pileup[f,:,r:r+1]+1) - utils.insum(gammaln(count_data+1),[1])
if True:
# abundance likelihood
rate_log_likelihood = (
emission['rate_alpha'][r] # A
* emission['rate_beta'][r] # B
* utils.nplog(emission['rate_beta'][r]) # C
- (emission['rate_alpha'][r]*emission['rate_beta'][r]+self.total_pileup[f,:,r:r+1]) # D
* utils.nplog(emission['rate_beta'][r] + self.transcript_normalization_factor) # E
+ gammaln(emission['rate_alpha'][r]*emission['rate_beta'][r]+self.total_pileup[f,:,r:r+1]) # F
- gammaln(emission['rate_alpha'][r]*emission['rate_beta'][r]) # G
+ self.total_pileup[f,:,r:r+1] # H
* utils.nplog(self.transcript_normalization_factor) # I
- gammaln(self.total_pileup[f,:,r:r+1]+1) # J
)
log_likelihood += rate_log_likelihood
# likelihood of extra positions
for l in range(f):
if not self.missing[l,r]:
self.extra_log_likelihood[f] += (
emission['rate_alpha'][r,0]
* emission['rate_beta'][r,0]
* utils.nplog(emission['rate_beta'][r,0])
- (emission['rate_alpha'][r,0]*emission['rate_beta'][r,0]+self.riboseq_pileup[l,r])
* utils.nplog(emission['rate_beta'][r,0]+self.transcript_normalization_factor/3.)
+ gammaln(emission['rate_alpha'][r,0]*emission['rate_beta'][r,0]+self.riboseq_pileup[l,r])
- gammaln(emission['rate_alpha'][r,0]*emission['rate_beta'][r,0])
+ self.riboseq_pileup[l,r]*utils.nplog(self.transcript_normalization_factor/3.)
- gammaln(self.riboseq_pileup[l,r]+1)
)
for l in range(3 * self.n_triplets + f, self.transcript_length):
if not self.missing[l,r]:
self.extra_log_likelihood[f] += (
emission['rate_alpha'][r,emission['S']-1]
* emission['rate_beta'][r,emission['S']-1]
* utils.nplog(emission['rate_beta'][r,emission['S']-1])
- (emission['rate_alpha'][r,emission['S']-1]*emission['rate_beta'][r,emission['S']-1]+ self.riboseq_pileup[l,r])
* utils.nplog(emission['rate_beta'][r,emission['S']-1]+self.transcript_normalization_factor/3.)
+ gammaln(emission['rate_alpha'][r,emission['S']-1]*emission['rate_beta'][r,emission['S']-1]+self.riboseq_pileup[l,r])
- gammaln(emission['rate_alpha'][r,emission['S']-1]*emission['rate_beta'][r,emission['S']-1])
+ self.riboseq_pileup[l,r]*utils.nplog(self.transcript_normalization_factor/3.)
- gammaln(self.riboseq_pileup[l,r]+1)
)
# account for mappability in main positions
missing = np.array([m for m in range(self.n_triplets) if np.any(self.missing[3*m+f:3*m+3+f,r])]).astype(np.int64)
log_likelihood[missing,:] = 0
self.log_likelihood[f] += log_likelihood
self.log_probability = self.log_likelihood
self.extra_log_probability = self.extra_log_likelihood
# if np.isnan(self.log_likelihood).any() \
# or np.isinf(self.log_likelihood).any():
# print("Warning: Inf/Nan in data log likelihood")
# pdb.set_trace()
#
# if np.isnan(self.extra_log_likelihood).any() \
# or np.isinf(self.extra_log_likelihood).any():
# print("Warning: Inf/Nan in extra log likelihood")
# pdb.set_trace()
def compute_observed_pileup_deviation(self, emission, return_sorted=True):
"""
For each ORF, for each read length, for the first two base positions in each triplet, computes a
difference between observed and expected pileup
:param candidate_orfs:
:param emission:
:return:
"""
orfs_with_errors = list()
for candidate_orf in self.get_candidate_cds_simple():
footprint_errors = list()
by_triplet_error = dict()
for footprint_length_i in range(self.n_footprint_lengths):
expected = emission['logperiodicity'][footprint_length_i]
observed_frame_i = candidate_orf.frame
observed_start = candidate_orf.start
observed_stop = candidate_orf.stop
orf_square_error = np.zeros(shape=(self.n_triplets, 3))
for triplet_i in range(self.n_triplets):
triplet_state = get_triplet_state(triplet_i, start_pos=observed_start, stop_pos=observed_stop)
state_expected = np.exp(expected[triplet_state])
# Get observed pileup proportions
triplet_positions = slice(triplet_i * 3 + observed_frame_i, 3 * triplet_i + observed_frame_i + 3)
triplet_pileups = self.riboseq_pileup[triplet_positions, footprint_length_i]
if triplet_pileups.sum() == 0:
triplet_proportions = np.ones(3) / 3 # TODO Should this be all 0s?
else:
triplet_proportions = triplet_pileups / triplet_pileups.sum()
square_error = (triplet_proportions - state_expected) ** 2
orf_square_error[triplet_i] = square_error
by_triplet_error[footprint_length_i] = np.sum(orf_square_error, axis=1)
orf_rmse = np.sqrt(np.sum(orf_square_error) / (self.n_triplets * 2))
footprint_errors.append(orf_rmse)
orf_error = np.mean(footprint_errors)
orfs_with_errors.append((candidate_orf, orf_error, by_triplet_error))
if not return_sorted:
return orfs_with_errors
return sorted(orfs_with_errors, key=lambda r: r[1])
def get_candidate_cds_simple(self, shifted_forward=True):
"""
Args:
shifted_forward: If True, shifts forward the codon map to directly represent the codon position
Returns:
"""
local_start_codon_map = self.codon_map['start'].copy()
local_stop_codon_map = self.codon_map['stop'].copy()
if shifted_forward:
local_start_codon_map = np.roll(local_start_codon_map, shift=1, axis=0)
local_start_codon_map[0] = [0, 0, 0] # np.roll wraps around, so set the first codon to 0s
local_stop_codon_map = np.roll(local_stop_codon_map, shift=1, axis=0)
local_stop_codon_map[0] = [0, 0, 0]
N_FRAMES = 3
n_triplets = local_start_codon_map.shape[0]
candidate_cds = list()
for pos_i in range(n_triplets):
for frame_i in range(N_FRAMES):
if local_start_codon_map[pos_i, frame_i] > 0:
for stop_i in range(pos_i, n_triplets):
if local_stop_codon_map[stop_i, frame_i] > 0:
candidate_cds.append(CandidateCDS(
frame=frame_i,
start=pos_i,
stop=stop_i
))
break
return candidate_cds
def get_state_sequence(self, n_triplets, start, stop):
seq = np.zeros(n_triplets, dtype=int)
try:
seq[start - 1] = 1
seq[start] = 2
seq[start + 1] = 3
seq[start + 2:stop - 1] = 4
seq[stop - 1] = 5
seq[stop] = 6
seq[stop + 1] = 7
seq[stop + 2:] = 8
except:
pass # Silently fail
return list(seq)
def orf_state_matrix(self):
"""
Returns () matrix of orf states,
"""
n_triplets = self.codon_map['start'].shape[0]
orf_state_matrix_ = [list(), list(), list()]
for candidate_cds in self.get_candidate_cds_simple():
state_seq = self.get_state_sequence(n_triplets, candidate_cds.start, candidate_cds.stop)
orf_state_matrix_[candidate_cds.frame].append(state_seq)
return [np.array(m) for m in orf_state_matrix_]
class Frame(object):
def __init__(self):
"""Instantiates a frame object for a transcript and initializes
a random posterior probability over all three frames.
"""
self.posterior = np.random.rand(3)
"""Why on Earth did I add a int() here? It isn't in the original code"""
# self.posterior = int(self.posterior/self.posterior.sum())
self.posterior = self.posterior/self.posterior.sum()
def update(self, data, state):
"""Update posterior probability over the three
frames for a transcript.
Arguments:
data : instance of `Datum`
state : instance of `State`
"""
self.posterior = outsum(state.likelihood) + data.extra_log_probability
self.posterior = self.posterior - self.posterior.max()
self.posterior = np.exp(self.posterior)
self.posterior = self.posterior / self.posterior.sum()
def __reduce__(self):
return (rebuild_Frame, (self.posterior,))
def rebuild_Frame(pos):
f = Frame()
f.posterior = pos
return f
class State(object):
def __init__(self, n_triplets):
# number of triplets
self.n_triplets = n_triplets
# number of states for the HMM
self.n_states = 9
# stores the (start,stop) and posterior for the MAP state for each frame
self.best_start = []
self.best_stop = []
self.max_posterior = np.empty(shape=(3,), dtype=np.float64)
def _forward_update(self, data, transition):
"""
Inflate serialized transition dictionary
"""
# Define one for each of the 9 States
logprior = nplog([1, 0, 0, 0, 0, 0, 0, 0, 0])
# swapidx = np.array([2, 3, 6, 7]).astype(np.uint8)
swapidx = np.array(
[States.ST_TIS, States.ST_TIS_PLUS, States.ST_TTS, States.ST_3PRIME_UTS_MINUS]
).astype(np.uint8)
# alpha_k(z_k) is P(z_k | x_1:k)
# In this case the three frames are three separate HMMs
self.alpha = np.zeros((3, self.n_triplets, self.n_states), dtype=np.float64)
self.likelihood = np.zeros((self.n_triplets, 3), dtype=np.float64)
# data.codon_map['kozak'] is shape (n_triplets, n_frames) and is the kozak values for each triplet in
# each frame
# transition['seqparam']['start'] is an 11-element array, one value for each defined Start codon, where 0 is
# defined as not a Start codon
# data.codon_map['start'] is an integer value for each triplet and frame that corresponds to a Start codon, or
# 0 if not any of the Start codons
# transition['seqparam']['start'][data.codon_map['start']]) is the broadcast of each Start codon seqparam value
# to the appropriate codon type
# The shape of P will be (n_triplets, n_frames)
# Q is essentially the same thing but with Stop codons
P = logistic(
-1 * (transition['seqparam']['kozak'] * data.codon_map['kozak'] +
transition['seqparam']['start'][data.codon_map['start']])
)
Q = logistic(-1 * transition['seqparam']['stop'][data.codon_map['stop']])
for frame_i in range(3):
# Determine the likelihood and alpha for the first triplet
# data.log_probability[frame_i, triplet_i, state_i]
# Both logprior and the log_probabilty are size (9,)
newalpha = logprior + data.log_probability[frame_i, 0, :]
normalized_new_alpha = normalize(newalpha)
# Set the likelihood and alpha for each state for the first triplet
for state_i in range(self.n_states):
self.alpha[frame_i, 0, state_i] = newalpha[state_i] - normalized_new_alpha
self.likelihood[0, frame_i] = normalized_new_alpha
# For all triplets after the first triplet
for triplet_i in range(1, self.n_triplets):
# states 2,3,6,7
# TIS, TIS+, TTS, 3'UTS-
for swap_state_i in swapidx:
newalpha[swap_state_i] = (
self.alpha[frame_i, triplet_i - 1, swap_state_i - 1]
+ data.log_probability[frame_i, triplet_i, swap_state_i]
)
# state 0,1
# 5'UTS, 5'UTS+
try:
# Get the alpha value from the previous triplet, state 5'UTS
p = self.alpha[frame_i, triplet_i - 1, States.ST_5PRIME_UTS] + log(1 - P[triplet_i, frame_i])
q = self.alpha[frame_i, triplet_i - 1, States.ST_5PRIME_UTS] + log(P[triplet_i, frame_i])
except ValueError: # log(x) where x <= 0
if P[triplet_i, frame_i] == 0.0:
p = self.alpha[frame_i, triplet_i - 1, States.ST_5PRIME_UTS]
q = utils.MIN
else:
p = utils.MIN
q = self.alpha[frame_i, triplet_i - 1, States.ST_5PRIME_UTS]
newalpha[States.ST_5PRIME_UTS] = p + data.log_probability[frame_i, triplet_i, States.ST_5PRIME_UTS]
newalpha[States.ST_5PRIME_UTS_PLUS] = q + data.log_probability[frame_i, triplet_i, States.ST_5PRIME_UTS_PLUS]
# state 4
# TES
p = self.alpha[frame_i, triplet_i - 1, States.ST_TIS_PLUS]
try:
q = self.alpha[frame_i, triplet_i - 1, States.ST_TES] + log(1 - Q[triplet_i, frame_i])
except ValueError:
q = utils.MIN
if p > q:
newalpha[States.ST_TES] = log(1 + exp(q - p)) + p + data.log_probability[frame_i, triplet_i, States.ST_TES]
else:
newalpha[States.ST_TES] = log(1 + exp(p - q)) + q + data.log_probability[frame_i, triplet_i, States.ST_TES]
# state 5
try:
newalpha[States.ST_TTS_MINUS] = self.alpha[frame_i, triplet_i - 1, States.ST_TES] + log(Q[triplet_i, frame_i]) + data.log_probability[frame_i, triplet_i, States.ST_TTS_MINUS]
except ValueError:
newalpha[States.ST_TTS_MINUS] = utils.MIN
# state 8
p = self.alpha[frame_i, triplet_i - 1, States.ST_3PRIME_UTS_MINUS]
q = self.alpha[frame_i, triplet_i - 1, States.ST_5PRIME_UTS]
if p > q:
newalpha[States.ST_5PRIME_UTS] = log(1 + exp(q - p)) + p + data.log_probability[frame_i, triplet_i, States.ST_5PRIME_UTS]
else:
newalpha[States.ST_5PRIME_UTS] = log(1 + exp(p - q)) + q + data.log_probability[frame_i, triplet_i, States.ST_5PRIME_UTS]
normalized_new_alpha = normalize(newalpha)
# for s from 0 <= s < self.S:
for s in range(self.n_states):
self.alpha[frame_i, triplet_i, s] = newalpha[s] - normalized_new_alpha
self.likelihood[triplet_i, frame_i] = normalized_new_alpha
# if np.isnan(self.alpha).any() or np.isinf(self.alpha).any():
# print('Warning: Inf/Nan in forward update step')
# pdb.set_trace()
def _reverse_update(self, data, transition):
swapidx = np.array([1, 2, 3, 5, 6, 7]).astype(np.uint8)
self.pos_first_moment = np.empty((3, self.n_triplets, self.n_states), dtype=np.float64)
self.pos_cross_moment_start = np.empty((3, self.n_triplets, 2), dtype=np.float64)
P = logistic(
-1 * (transition.seqparam['kozak'] * data.codon_map['kozak'] +
transition.seqparam['start'][data.codon_map['start']])
)
Q = logistic(-1 * transition.seqparam['stop'][data.codon_map['stop']])
# for f from 0 <= f < 3:
for f in range(3):
self.pos_first_moment[f, self.n_triplets - 1, :] = np.exp(self.alpha[f, self.n_triplets - 1, :])
newbeta = np.empty((self.n_states,), dtype=np.float64)
beta = np.zeros((self.n_states,), dtype=np.float64)
for m in range(self.n_triplets - 2, -1, -1):
for s in range(self.n_states):
beta[s] = beta[s] + data.log_probability[f, m + 1, s]
try:
pp = beta[0] + log(1 - P[m + 1, f])
except ValueError:
pp = utils.MIN
try:
p = beta[1] + log(P[m + 1, f])
except ValueError:
p = utils.MIN
try:
q = beta[5] + log(Q[m + 1, f])
except ValueError:
q = utils.MIN
try:
qq = beta[4] + log(1 - Q[m + 1, f])
except ValueError:
qq = utils.MIN
# pos cross moment at start
a = self.alpha[f, m, 0] - self.likelihood[m + 1, f]
self.pos_cross_moment_start[f, m + 1, 0] = exp(a + p)
self.pos_cross_moment_start[f, m + 1, 1] = exp(a + pp)
# states 1,2,3,5,6,7
for s in swapidx:
newbeta[s] = beta[s + 1]
newbeta[self.n_states - 1] = beta[self.n_states - 1]
# state 0
if p > pp:
newbeta[0] = log(1 + np.exp(pp - p)) + p
else:
newbeta[0] = log(1 + np.exp(p - pp)) + pp
# state 4
if qq > q:
newbeta[4] = log(1 + np.exp(q - qq)) + qq
else:
newbeta[4] = log(1 + np.exp(qq - q)) + q
# for s from 0 <= s < self.S:
for s in range(self.n_states):
beta[s] = newbeta[s] - self.likelihood[m + 1, f]
self.pos_first_moment[f, m, s] = exp(self.alpha[f, m, s] + beta[s])
self.pos_cross_moment_start[f, 0, 0] = 0
self.pos_cross_moment_start[f, 0, 1] = 0
if np.isnan(self.pos_first_moment).any() or np.isinf(self.pos_first_moment).any():
print('Warning: Inf/Nan in first moment')
pdb.set_trace()
if np.isnan(self.pos_cross_moment_start).any() or np.isinf(self.pos_cross_moment_start).any():
print('Warning: Inf/Nan in start cross moment')
pdb.set_trace()
def new_decode(self, data, transition):
P = logistic(-1 * (transition['seqparam']['kozak'] * data.codon_map['kozak']
+ transition['seqparam']['start'][data.codon_map['start']]))
Q = logistic(-1 * transition['seqparam']['stop'][data.codon_map['stop']])
N_FRAMES = 3
orf_state_matrix = data.orf_state_matrix()
orf_posteriors = list()
for frame_i in range(N_FRAMES):
n_orfs = orf_state_matrix[frame_i].shape[0]
orf_posteriors.append(np.zeros(shape=n_orfs))
for orf_i in range(n_orfs):
alpha = utils.nplog(1) + data.log_probability[frame_i, 0, 0]
for triplet_i in range(1, orf_state_matrix[frame_i].shape[1]):
current_state = orf_state_matrix[frame_i][orf_i, triplet_i]
prev_state = orf_state_matrix[frame_i][orf_i, triplet_i - 1]
if current_state == 0:
try:
newalpha = alpha + log(1 - P[triplet_i, frame_i]) # What do we do when this is log(0)?
except:
print(f'Got utils.MIN on triplet {triplet_i} | P[{triplet_i}, {frame_i}] = {P[triplet_i, frame_i]} | Exception 1****************')
newalpha = utils.MIN
elif current_state == 1:
try:
newalpha = alpha + log(P[triplet_i, frame_i])
except:
print(f'Got utils.MIN on triplet {triplet_i} | P[{triplet_i}, {frame_i}] = {P[triplet_i, frame_i]} | Exception 2')
newalpha = utils.MIN
elif current_state == 2:
newalpha = alpha + log(1)
elif current_state == 3:
newalpha = alpha + log(1)
elif current_state == 4:
if prev_state == 3:
newalpha = alpha + log(1)
else:
try:
newalpha = alpha + log(1 - Q[triplet_i, frame_i])
except:
print(f'Got utils.MIN on triplet {triplet_i} | Q[{triplet_i}, {frame_i}] = {Q[triplet_i, frame_i]} | Exception 3***************')
newalpha = utils.MIN
elif current_state == 5:
try:
newalpha = alpha + log(Q[triplet_i, frame_i])
except:
print(f'Got utils.MIN on triplet {triplet_i} | Q[{triplet_i}, {frame_i}] = {Q[triplet_i, frame_i]} | Exception 4')
newalpha = utils.MIN
elif current_state == 6:
newalpha = alpha + log(1)
elif current_state == 7:
newalpha = alpha + log(1)
else: # current_state == 8
newalpha = alpha + log(1) # Is it deterministic?
alpha = newalpha + data.log_probability[frame_i, triplet_i, current_state] # Last element is the state we're on?
orf_posteriors[frame_i][orf_i] = np.exp(alpha - np.sum(self.likelihood[:, frame_i]))
return orf_posteriors
def decode(self, data, transition):
P = logistic(-1*(transition['seqparam']['kozak'] * data.codon_map['kozak']
+ transition['seqparam']['start'][data.codon_map['start']]))
Q = logistic(-1*transition['seqparam']['stop'][data.codon_map['stop']])
logprior = utils.nplog([1, 0, 0, 0, 0, 0, 0, 0, 0])
swapidx = np.array(
[States.ST_TIS, States.ST_TIS_PLUS, States.ST_TTS, States.ST_3PRIME_UTS_MINUS]
).astype(np.uint8)
pointer = np.zeros((self.n_triplets, self.n_states), dtype=np.uint8)
pointer[0, 0] = np.array([0])
alpha = np.zeros((self.n_states,), dtype=np.float64)
self.decode_alphas = np.zeros((3, self.n_states), dtype=np.float64)
newalpha = np.zeros((self.n_states,), dtype=np.float64)
# Most likely hidden state for each triplet
state = np.zeros((self.n_triplets,), dtype=np.uint8)
# Iterate over each frame
for frame_i in range(3):
# find the state sequence with highest posterior
# data.log_probability is (frame_i, triplet_i, state_i)
# This frame, first triplet, all states
alpha = logprior + data.log_probability[frame_i, 0, :]
for triplet_i in range(1, self.n_triplets):
# states 2,3,6,7
for s in swapidx:
newalpha[s] = alpha[s - 1]
pointer[triplet_i, s] = s - 1
# state 0,1
try:
p = alpha[0] + log(1 - P[triplet_i, frame_i])
q = alpha[0] + log(P[triplet_i, frame_i])
except ValueError:
if P[triplet_i, frame_i] == 0.0:
p = alpha[0]
q = utils.MIN
else:
p = utils.MIN
q = alpha[0] + log(1)
pointer[triplet_i, 0] = 0
newalpha[0] = p
pointer[triplet_i, 1] = 0
newalpha[1] = q
# state 4
p = alpha[3]
try:
q = alpha[4] + log(1-Q[triplet_i, frame_i])
except ValueError:
q = utils.MIN
if p >= q:
newalpha[4] = p
pointer[triplet_i, 4] = 3
else:
newalpha[4] = q
pointer[triplet_i, 4] = 4
# state 5
try:
newalpha[5] = alpha[4] + log(Q[triplet_i, frame_i])
except ValueError:
newalpha[5] = utils.MIN
pointer[triplet_i, 5] = 4
# state 8
p = alpha[7]
q = alpha[8]
if p >= q:
newalpha[8] = p
pointer[triplet_i, 8] = 7
else:
newalpha[8] = q
pointer[triplet_i, 8] = 8
# for s from 0 <= s < self.n_states:
for s in range(self.n_states):
alpha[s] = newalpha[s] + data.log_probability[frame_i, triplet_i, s]
self.decode_alphas[frame_i] = alpha
# constructing the MAP state sequence
# alpha is 1-dim array of size n_states
state[self.n_triplets - 1] = np.argmax(alpha)
# Start on the second-to-last triplet, then count backward to the first triplet
for triplet_i in range(self.n_triplets - 2, 0, -1):
# Previous state in the sense that it was the last calculated state
# Since we're going backward, this is technically the next state in the sequence
prev_state = state[triplet_i + 1]
# Get the most likely state of this triplet
state[triplet_i] = pointer[triplet_i + 1, prev_state]
state[0] = pointer[0, 0]
# Calculate the max posterior using the HMM definition
# max_post = 0
# for triplet_i, state_ in enumerate(state):
# max_post += data.log_probability[frame_i, triplet_i, state_]
# max_post = np.exp(max_post)
self.max_posterior[frame_i] = np.exp(np.max(alpha) - np.sum(self.likelihood[:, frame_i]))
# identifying start codon position
# state is 1-dim array of size n_triplets
# This gives the position in the transcript, not the triplet index
# Returns the most upstream possible start codon
try:
self.best_start.append(np.where(state == States.ST_TIS)[0][0] * 3 + frame_i)
except IndexError:
self.best_start.append(None)
# identifying stop codon position
try:
# Should this be TTS?
self.best_stop.append(np.where(state == States.ST_3PRIME_UTS_MINUS)[0][0] * 3 + frame_i)
except IndexError:
self.best_stop.append(None)
# To allow us to extract out this function's alpha value
# self.alpha = np.empty((1, 1, 1), dtype=np.float64)
self.pos_cross_moment_start = np.empty((1, 1, 1), dtype=np.float64)
self.pos_cross_moment_stop = np.empty((1, 1, 1), dtype=np.float64)
self.pos_first_moment = np.empty((1, 1, 1), dtype=np.float64)
self.likelihood = np.empty((1, 1), dtype=np.float64)
def joint_probability(self, data, transition, state, frame):
# cdef long m
# cdef double p, q, joint_probability
joint_probability = data.log_probability[frame,0,state[0]]
# for m from 1 <= m < self.M:
for m in range(self.n_triplets):
if state[m-1]==0:
p = transition.seqparam['kozak'] * data.codon_map['kozak'][m,frame] \
+ transition.seqparam['start'][data.codon_map['start'][m,frame]]
try:
joint_probability = joint_probability - log(1+exp(-p))
if state[m]==0:
joint_probability = joint_probability - p
except OverflowError:
if state[m]==1:
joint_probability = joint_probability - p
elif state[m-1]==4:
q = transition.seqparam['stop'][data.codon_id['stop'][m,frame]]
try:
joint_probability = joint_probability - log(1+exp(-q))
if state[m]==4:
joint_probability = joint_probability - q
except OverflowError:
if state[m]==5:
joint_probability = joint_probability - q
joint_probability = joint_probability + data.log_probability[frame,m,state[m]]
return joint_probability
def compute_posterior(self, data, transition, start, stop):
# cdef long frame
# cdef double joint_prob, marginal_prob, posterior
# cdef np.ndarray state
frame = start%3
start = int((start-frame)/3)
stop = int((stop-frame)/3)
# construct state sequence given a start/stop pair
state = np.empty((self.n_triplets,), dtype=np.uint8)
state[:start-1] = 0
state[start-1] = 1
state[start] = 2
state[start+1] = 3
state[start+2:stop-2] = 4
state[stop-2] = 5
state[stop-1] = 6
state[stop] = 7
state[stop+1:] = 8
# compute joint probability
joint_prob = self.joint_probability(data, transition, state, frame)
# compute marginal probability
marginal_prob = np.sum(self.likelihood[:,frame])
posterior = exp(joint_prob - marginal_prob)
return posterior
def __reduce__(self):
return (rebuild_State, (self.best_start, self.best_stop, self.max_posterior, self.M))
def rebuild_State(bstart, bstop, mposterior, M):
s = State(M)
s.best_start = bstart
s.best_stop = bstop
s.max_posterior = mposterior
return s
class Transition(object):
def __init__(self):
"""Order of the states is
'5UTS','5UTS+','TIS','TIS+','TES','TTS-','TTS','3UTS-','3UTS'
"""
# number of states in HMM
self.S = 9
self.restrict = True
self.C = len(utils.STARTCODONS) + 1
self.seqparam = dict()
# initialize parameters for translation initiation
self.seqparam['kozak'] = np.random.rand()
self.seqparam['start'] = np.zeros((self.C,), dtype='float')
self.seqparam['start'][0] = utils.MIN
self.seqparam['start'][1] = 1+np.random.rand()
self.seqparam['start'][2:] = utils.MIN
# initialize parameters for translation termination
self.seqparam['stop'] = utils.MAX * np.ones((4,), dtype=np.float64)
self.seqparam['stop'][0] = utils.MIN
def __getitem__(self, item):
return self.__dict__[item]
def _serialize(self):
return {
'seqparam': {
'kozak': self.seqparam['kozak'],
'start': list(self.seqparam['start']),
'stop': list(self.seqparam['stop'])
}
}
# @cython.boundscheck(False)
# @cython.wraparound(False)
# @cython.nonecheck(False)
# cdef update(self, list data, list states, list frames):
# @njit
def update(self, data, states, frames):
# cdef bool optimized
# cdef long id, f, V
# cdef double p, q
# cdef np.ndarray[np.float64_t, ndim=1] xo, x_final
# cdef np.ndarray[np.float64_t, ndim=2] x_init
# cdef State state
# cdef Frame frame
# update 5'UTS -> 5'UTS+ transition parameter
# warm start for the optimization
optimized = False
if self.restrict:
xo = np.hstack((self.seqparam['kozak'], self.seqparam['start'][1:2]))
else:
xo = np.hstack((self.seqparam['kozak'], self.seqparam['start'][1:]))
V = xo.size
x_init = xo.reshape(V,1)
try:
x_final, optimized = optimize_transition_initiation(x_init, data, states, frames, self.restrict)
if optimized:
self.seqparam['kozak'] = x_final[0]
self.seqparam['start'][1] = x_final[1]
if not self.restrict:
self.seqparam['start'][2:] = x_final[2:]
except:
# if any error is thrown, skip updating at this iteration
pass
def __reduce__(self):
return (rebuild_Transition, (self.seqparam,self.restrict))
def rebuild_Transition(seqparam, restrict):
t = Transition()
t.seqparam = seqparam
t.restrict = restrict
return t
# @njit
def optimize_transition_initiation(x_init, data, states, frames, restrict):
# @njit
def func(x=None, z=None):
if x is None:
return 0, cvx.matrix(x_init)
xx = np.array(x).ravel().astype(np.float64)
if z is None:
# compute likelihood function and gradient
results = transition_func_grad(xx, data, states, frames, restrict)
fd = results[0]
Df = results[1]
# check for infs and nans, in function and gradient
if np.isnan(fd) or np.isinf(fd):
f = np.array([np.finfo(np.float32).max]).astype(np.float64)
else:
f = np.array([fd]).astype(np.float64)
if np.isnan(Df).any() or | np.isinf(Df) | numpy.isinf |
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 15 17:24:08 2021
@author: gawe
"""
# ========================================================================== #
# ========================================================================== #
# This section is to improve python compataibilty between py27 and py3
from __future__ import absolute_import, with_statement, absolute_import, division, print_function, unicode_literals
__metaclass__ = type
# ========================================================================== #
import numpy as _np
import matplotlib.pyplot as _plt
# ========================================================================== #
# ========================================================================== #
"""
Laplace Transform:
Maps complex-valued signal x(t) with real-valued
independent variable t to its complex-valued Laplace transform
with complex-valued independent variable s
Whether a Laplace transform X(s)=L{x(t)} exists depends on complex
frequency s and the signal x(t) itself.
All values s for which the Laplace transform converges form a
region of convergence (ROC). The Laplace transform of two different
signals may differe only wrt their ROCs. Conseqeuently, the ROC needs
to be explicitly given for a unique inversion of the Laplace transform.
Laplace transforms are extensively used for signals/systems analysis and
filter analysis/design with linear, time-invariant (LTI) systems.
The bilateral (+- time) Laplace transform of a causal signal is identical
to the unilateral (t>0) Laplace transform of that signal.
A rational Laplace transform (i.e., of an LTI system) can always be
written as either the quotient of two polynomials in s:
F(s) = P_n(s) / Q_m(s) where m>=n
or the same quotient with a constant damping factor
F(s) = (P_n(s) / Q_m(s))*exp[-a*s] where m>=n, a>0
Roots: zeros of the Laplace transform (where P_n = 0)
Poles: discontinuities of the Laplace transform (where Q_m = 0)
Special case:
The Laplace transform of the Dirac-delta function delta(t) is 1
L{delta(t)} = 1 for s an element of all complex-numbers
ROC covers the entire complex plane
-----
Laplace transform (unilateral): s = alpha + j*omega
F[u(t)] = U(s) = int_0^infty{ u(t)*exp[-(alpha+j*omega)*t]dt}
Laplace transform (bilateral): s = alpha + j*omega
F[u(t)] = U(s) = int_-infty^infty{ u(t)*exp[-(alpha+j*omega)*t]dt}
Fourier transform:
(just for this example we are normalizing on the inverse transform)
F[u(t)] = U(omega) = int_-infty^infty{ u(t)*exp[-j*omega*t]dt}
By inspection:
The unilateral Laplace transform is the Fourier transform of a causal
function multiplied by a decaying exponential
U(s) = F[ u(t)*H(t)*exp(-alpha*t) ] - H() is the Heaviside function
The bilateral Laplace transform is the Fourier transform of a generally
non-causal function multiplied by a decaying exponential
U(s) = F[ u(t)*exp(-alpha*t) ]
"""
def laplace():
pass
def laplace_1d(uin, real_sigma_interval=_np.arange(-1, 1 + 0.001, 0.001), nfft=None):
"""
Returns the Laplace transform of a signal using a brute-force method and
Fourier transforms,
first axis is the real range
second axis the imaginary range.
Complex numbers are returned.
"""
uin = _np.copy(uin)
if nfft is None:
uin = _np.atleast_1d(uin)
nfft = len(uin)
# end if
# The transform is from last timestep to first, so "x" is reversed
uin = | _np.array(uin) | numpy.array |
# ######################################################################
# Copyright (c) 2014, Brookhaven Science Associates, Brookhaven #
# National Laboratory. All rights reserved. #
# #
# Redistribution and use in source and binary forms, with or without #
# modification, are permitted provided that the following conditions #
# are met: #
# #
# * Redistributions of source code must retain the above copyright #
# notice, this list of conditions and the following disclaimer. #
# #
# * Redistributions in binary form must reproduce the above copyright #
# notice this list of conditions and the following disclaimer in #
# the documentation and/or other materials provided with the #
# distribution. #
# #
# * Neither the name of the Brookhaven Science Associates, Brookhaven #
# National Laboratory nor the names of its contributors may be used #
# to endorse or promote products derived from this software without #
# specific prior written permission. #
# #
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS #
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT #
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS #
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE #
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, #
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES #
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR #
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) #
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, #
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OTHERWISE) ARISING #
# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE #
# POSSIBILITY OF SUCH DAMAGE. #
########################################################################
"""
This module is for spectroscopy specific tools (spectrum fitting etc).
"""
from __future__ import absolute_import, division, print_function
import numpy as np
from six.moves import zip
from scipy.integrate import simps
from .fitting import fit_quad_to_peak
import logging
logger = logging.getLogger(__name__)
def align_and_scale(energy_list, counts_list, pk_find_fun=None):
"""
Parameters
----------
energy_list : iterable of ndarrays
list of ndarrays with the energy of each element
counts_list : iterable of ndarrays
list of ndarrays of counts/element
pk_find_fun : function or None
A function which takes two ndarrays and returns parameters
about the largest peak. If None, defaults to `find_largest_peak`.
For this demo, the output is (center, height, width), but this sould
be pinned down better.
Returns
-------
out_e : list of ndarray
The aligned/scaled energy arrays
out_c : list of ndarray
The count arrays (should be the same as the input)
"""
if pk_find_fun is None:
pk_find_fun = find_largest_peak
base_sigma = None
out_e, out_c = [], []
for e, c in zip(energy_list, counts_list):
E0, max_val, sigma = pk_find_fun(e, c)
if base_sigma is None:
base_sigma = sigma
out_e.append((e - E0) * base_sigma / sigma)
out_c.append(c)
return out_e, out_c
def find_largest_peak(x, y, window=None):
"""
Finds and estimates the location, width, and height of
the largest peak. Assumes the top of the peak can be
approximated as a Gaussian. Finds the peak properties
using least-squares fitting of a parabola to the log of
the counts.
The region around the peak can be approximated by
Y = Y0 * exp(- (X - X0)**2 / (2 * sigma **2))
Parameters
----------
x : ndarray
The independent variable
y : ndarary
Dependent variable sampled at positions X
window : int, optional
The size of the window around the maximum to use
for the fitting
Returns
-------
x0 : float
The location of the peak
y0 : float
The magnitude of the peak
sigma : float
Width of the peak
"""
# make sure they are _really_ arrays
x = np.asarray(x)
y = np.asarray(y)
# get the bin with the largest number of counts
j = np.argmax(y)
if window is not None:
roi = slice( | np.max(j - window, 0) | numpy.max |
from __future__ import division
from future.utils import viewitems
from builtins import int, zip
import concurrent.futures
import os
import itertools
from ._adaptive_threshold import threshold as athreshold
from .pool import pooler
from ._moving_window import moving_window
# from mpglue.raster_tools import create_raster
# from mpglue import moving_window
import numpy as np
import cv2
# SciPy
from scipy.ndimage.measurements import label as nd_label
from scipy.ndimage.measurements import mean as nd_mean
import scipy.stats as sci_stats
from scipy.stats import mode as sci_mode
from sklearn.preprocessing import StandardScaler
# Scikit-image
from skimage.exposure import rescale_intensity
from skimage.filters import threshold_local
from skimage.morphology import remove_small_objects, skeletonize
from skimage.morphology import thin as sk_thin
from skimage.feature import peak_local_max
from skimage.measure import regionprops
from skimage.measure import label as sk_label
import pymorph
from mahotas import thin as mthin
from mahotas.morph import hitmiss as mhitmiss
# from tqdm import tqdm
# from joblib import Parallel, delayed
def local_straightness(arr, kernel_filter, w, sigma_color, sigma_space):
"""
https://ieeexplore-ieee-org.ezproxy.library.uq.edu.au/document/1334256
https://docs.opencv.org/master/d4/d70/tutorial_anisotropic_image_segmentation_by_a_gst.html
Example:
>>> conv_kernels = set_kernel_pairs(methods=['compass'])
>>> kernel_filter = conv_kernels['compass']['kernels']
>>> local_straightness(array, kernel_filter, 3, 1, 1)
"""
diff_x = cv2.filter2D(np.float32(arr),
cv2.CV_32F,
kernel_filter[1],
borderType=cv2.BORDER_CONSTANT)
diff_y = cv2.filter2D(np.float32(arr),
cv2.CV_32F,
kernel_filter[0],
borderType=cv2.BORDER_CONSTANT)
diff_xy = diff_x * diff_y
diff_xx = diff_x * diff_x
diff_yy = diff_y * diff_y
c11 = cv2.boxFilter(np.float32(diff_xx), cv2.CV_32F, (w, w))
c22 = cv2.boxFilter(np.float32(diff_yy), cv2.CV_32F, (w, w))
c12 = cv2.boxFilter(np.float32(diff_xy), cv2.CV_32F, (w, w))
# c11 = cv2.bilateralFilter(np.float32(diff_xx), w, sigma_color, sigma_space)
# c22 = cv2.bilateralFilter(np.float32(diff_yy), w, sigma_color, sigma_space)
# c12 = cv2.bilateralFilter(np.float32(diff_xy), w, sigma_color, sigma_space)
gamma_max = (c11 + c22 + np.sqrt((c11 - c22)**2 + 4*c12**2)) / 2.0
gamma_min = (c11 + c22 - np.sqrt((c11 - c22)**2 + 4*c12**2)) / 2.0
s = 1.0 - (gamma_min / gamma_max)
return s
def logistic(x, **params):
return sci_stats.logistic.cdf(x, **params)
def sigmoid(x, a, b):
return 1.0 / (1.0 + np.exp(-b * (x - a)))
def log_transform(egm, scale=1e-6, logistic_alpha=1.6, logistic_beta=0.5):
"""
Transforms an EGM to probabilities
Args:
egm (2d array)
scale (Optional[float]): The scaling factor
logistic_alpha (Optional[float])
logistic_beta (Optional[float])
Returns:
Probabilities (2d array)
"""
# Mask
egm[egm == 0] = np.nan
log_min = np.nanpercentile(np.log(egm * scale), 2)
egm[np.isnan(egm)] = 0
# Log transform
egm_proba = np.where(egm > 0, np.log(egm * scale), log_min)
# Scale and clip
r, c = egm_proba.shape
zegm = np.where(egm_proba.ravel() > log_min)[0]
scaler = StandardScaler().fit(egm_proba.ravel()[zegm][:, np.newaxis])
egm_proba = scaler.transform(egm_proba.ravel()[:, np.newaxis]).reshape(r, c)
egm_proba = rescale_intensity(egm_proba, in_range=(-3, 3), out_range=(-3, 3))
# CDF
return logistic(egm_proba,
loc=logistic_alpha,
scale=logistic_beta)
def bayes(prior_a, prior_b, likelihood):
"""
Bayes rule
Args:
prior_a (float): The class prior probability.
prior_b (float): The class prior probability.
likelihood (float)
"""
posterior = (likelihood * prior_a) / (likelihood * prior_a + prior_b * (1.0 - prior_a))
posterior[np.isnan(posterior)] = 0
return posterior
class Params(object):
def __init__(self, **kwargs):
for k, v in viewitems(kwargs):
setattr(self, k, v)
def mopen(array2morph, se, iters=1):
return cv2.morphologyEx(np.uint8(array2morph),
cv2.MORPH_OPEN,
se,
iterations=iters)
def mclose(array2morph, se, iters=1):
return cv2.morphologyEx(np.uint8(array2morph),
cv2.MORPH_CLOSE,
se,
iterations=iters)
def merode(array2morph, se, iters=1):
return cv2.morphologyEx(np.uint8(array2morph),
cv2.MORPH_ERODE,
se,
iterations=iters)
def mdilate(array2morph, se, iters=1):
return cv2.morphologyEx(np.uint8(array2morph),
cv2.MORPH_DILATE,
se,
iterations=iters)
def closerec(array2morph, se, r=3, iters=5):
"""
Close by reconstruction
Args:
array2morph (2d array)
se (str)
r (Optional[int])
iters (Optional[int])
"""
if se == 'disk':
se = np.uint8(pymorph.sedisk(r=r))
elif se == 'cross':
se = np.uint8(pymorph.secross(r=r))
evi2_dist = np.float32(cv2.distanceTransform(np.uint8(np.where(array2morph >= 20, 1, 0)), cv2.DIST_L2, 3))
seed = np.uint8(np.where(evi2_dist >= 2,
cv2.morphologyEx(np.uint8(array2morph),
cv2.MORPH_OPEN,
se,
iterations=1),
0))
im_result = seed.copy()
for iter in range(0, iters):
im_dilated = cv2.morphologyEx(np.uint8(im_result),
cv2.MORPH_DILATE,
se,
iterations=1)
im_rec = np.minimum(im_dilated, array2morph)
im_result = im_rec.copy()
if np.allclose(seed, im_rec):
break
return im_result
def openrec(array2morph, se, iters=5):
"""
Open by reconstruction
Args:
array2morph (2d array)
se (2d array)
iters (Optional[int])
"""
evi2_dist = np.float32(cv2.distanceTransform(np.uint8(np.where(array2morph >= 20, 1, 0)), cv2.DIST_L2, 3))
seed = np.uint8(np.where(evi2_dist >= 2,
cv2.morphologyEx(np.uint8(array2morph),
cv2.MORPH_OPEN,
se,
iterations=1),
0))
im_result = seed.copy()
for iter in range(0, iters):
im_dilated = merode(im_result, se, iters=1)
im_rec = np.minimum(im_dilated, array2morph)
im_result = im_rec.copy()
if np.allclose(seed, im_rec):
break
return im_result
def set_kernel_pairs(methods=None):
"""
Creates 2d convolution kernels
Args:
methods (Optional[str list]): Choices are ['compass', 'kirsch', 'prewitt', 'roberts', 'scharr', 'sobel'].
Returns:
List of kernel filters
"""
returned_filters = dict()
if methods:
returned_filters['custom'] = dict(kernels=methods,
compass=True)
methods = ['compass', 'kirsch', 'prewitt', 'roberts', 'sobel']
# Prewitt compass
compass_filters = np.array([[[-1, -1, -1],
[1, -2, 1],
[1, 1, 1]],
[[-1, -1, 1],
[-1, -2, 1],
[1, 1, 1]],
[[-1, 1, 1],
[-1, -2, 1],
[-1, 1, 1]],
[[1, 1, 1],
[-1, -2, 1],
[-1, -1, 1]],
[[1, 1, 1],
[1, -2, 1],
[-1, -1, -1]],
[[1, 1, 1],
[1, -2, -1],
[1, -1, -1]],
[[1, 1, -1],
[1, -2, -1],
[1, 1, -1]]], dtype='float32')
# Sobel
sobel_filters = np.array([[[1, 2, 0],
[2, 0, -2],
[0, -2, -1]],
[[-1, -2, 0],
[-2, 0, 2],
[0, 2, 1]],
[[0, 2, 1],
[-2, 0, 2],
[-1, -2, 0]],
[[0, -2, -1],
[2, 0, -2],
[1, 2, 0]],
[[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]],
[[1, 0, -1],
[2, 0, -2],
[1, 0, -1]],
[[-1, -2, -1],
[0, 0, 0],
[1, 2, 1]],
[[1, 2, 1],
[0, 0, 0],
[-1, -2, -1]]], dtype='float32')
# Scharr
scharr_filters = np.array([[[10, 3, 0],
[3, 0, -3],
[0, -3, -10]],
[[-10, -3, 0],
[-3, 0, 3],
[0, 3, 10]],
[[0, 3, 10],
[-3, 0, 3],
[-10, -3, 0]],
[[0, -3, -10],
[3, 0, -3],
[10, 3, 0]],
[[-10, 0, 10],
[-3, 0, 3],
[-10, 0, 10]],
[[10, 0, -10],
[3, 0, -3],
[10, 0, -10]],
[[-10, -3, -10],
[0, 0, 0],
[10, 3, 10]],
[[10, 3, 10],
[0, 0, 0],
[-10, -3, -10]]], dtype='float32')
# Roberts cross
roberts_filters = np.array([[[0, -1],
[1, 0]],
[[0, 1],
[-1, 0]],
[[-1, 0],
[0, 1]],
[[1, 0],
[0, -1]]], dtype='float32')
# Prewitt
prewitt_filters = np.array([[[1, 1, 1],
[0, 0, 0],
[-1, -1, -1]],
[[-1, -1, -1],
[0, 0, 0],
[1, 1, 1]],
[[1, 1, 0],
[1, 0, -1],
[0, -1, -1]],
[[-1, -1, 0],
[-1, 0, 1],
[0, 1, 1]],
[[1, 0, -1],
[1, 0, -1],
[1, 0, -1]],
[[-1, 0, 1],
[-1, 0, 1],
[-1, 0, 1]],
[[0, 1, 1],
[-1, 0, 1],
[-1, -1, 0]],
[[0, -1, -1],
[1, 0, -1],
[1, 1, 0]]], dtype='float32')
# Kirsch compass
kirsch_filters = np.array([[[5, 5, 5],
[-3, 0, -3],
[-3, -3, -3]],
[[5, 5, -3],
[5, 0, -3],
[-3, -3, -3]],
[[5, -3, -3],
[5, 0, -3],
[5, -3, -3]],
[[-3, -3, -3],
[5, 0, -3],
[5, 5, -3]],
[[-3, -3, -3],
[-3, 0, -3],
[5, 5, 5]],
[[-3, -3, -3],
[-3, 0, 5],
[-3, 5, 5]],
[[-3, -3, 5],
[-3, 0, 5],
[-3, -3, 5]]], dtype='float32')
if 'compass' in methods:
returned_filters['compass'] = dict(kernels=compass_filters,
compass=True)
if 'kirsch' in methods:
returned_filters['kirsch'] = dict(kernels=kirsch_filters,
compass=True)
if 'prewitt' in methods:
returned_filters['prewitt'] = dict(kernels=prewitt_filters,
compass=False)
if 'roberts' in methods:
returned_filters['roberts'] = dict(kernels=roberts_filters,
compass=False)
if 'scharr' in methods:
returned_filters['scharr'] = dict(kernels=scharr_filters,
compass=False)
if 'sobel' in methods:
returned_filters['sobel'] = dict(kernels=sobel_filters,
compass=False)
return returned_filters
def find_circles(intensity_array, kernel_size):
"""
Finds circles
Args:
intensity_array (2d array)
kernel_size (int)
"""
kernel_radius = int(kernel_size / 2.0)
kernel_circle = np.uint8(pymorph.sedisk(r=kernel_radius,
dim=2,
metric='euclidean',
flat=True,
h=0) * 1)
kernel_square = np.uint8(pymorph.sebox(r=kernel_radius) * 1)
circles = cv2.filter2D(np.float32(intensity_array),
cv2.CV_32F,
kernel_circle,
borderType=cv2.BORDER_CONSTANT)
squares = cv2.filter2D(np.float32(intensity_array),
cv2.CV_32F,
kernel_square,
borderType=cv2.BORDER_CONSTANT)
diff = circles - squares
local_max_coords = peak_local_max(diff,
min_distance=kernel_size,
indices=True)
local_max = np.zeros(intensity_array.shape, dtype='uint8')
for local_coord in local_max_coords:
local_coord[0] -= kernel_radius
local_coord[1] -= kernel_radius
local_max[local_coord[0]:local_coord[0]+kernel_size,
local_coord[1]:local_coord[1]+kernel_size] = kernel_circle
se = np.array([[0, 1, 0],
[1, 1, 1],
[0, 1, 0]], dtype='uint8')
return cv2.morphologyEx(local_max,
cv2.MORPH_GRADIENT,
se)
def _get_magnitude(image2convolve, kernel_filter):
"""
Calculates the Edge Gradient Magnitude from x and y derivatives
Args:
image2convolve (2d array)
kernel_filter (tuple)
Returns:
EGM as 2d array
"""
return cv2.magnitude(cv2.filter2D(np.float32(image2convolve),
cv2.CV_32F,
kernel_filter[1],
borderType=cv2.BORDER_CONSTANT),
cv2.filter2D(np.float32(image2convolve),
cv2.CV_32F,
kernel_filter[0],
borderType=cv2.BORDER_CONSTANT))
def get_magnitude(im, kernels=None, pad=15):
"""
Gets the Edge Gradient Magnitude (EGM) over multiple edge kernels
Args:
im (2d array)
kernels (Optional[list]
pad (Optional[int])
Returns:
Gradient edge magnitude as 2d array.
[Mean EGM] * [Max EGM]
"""
n_rows, n_cols = im.shape
# Pad image edges.
if pad > 0:
im = np.float32(cv2.copyMakeBorder(im, pad, pad, pad, pad, cv2.BORDER_REFLECT))
# The convolution kernel pairs
conv_kernels = set_kernel_pairs(methods=kernels)
# Mean EGM
# mag_p = np.zeros((len(conv_kernels), im.shape[0], im.shape[1]), dtype='float32')
mag_p = np.zeros(im.shape, dtype='float32')
for kernel_name, kernel_dict in viewitems(conv_kernels):
kernel_filters = kernel_dict['kernels']
mag_c = np.zeros(im.shape, dtype='float32')
if kernel_dict['compass']:
if isinstance(kernel_filters, list):
kiter = len(kernel_filters)
# Get the maximum EGM over all kernel pairs.
for ki in range(0, kiter):
for kw in range(0, 2):
# Image convolution
temp_egm = cv2.filter2D(np.float32(im),
cv2.CV_32F,
np.array(kernel_filters[ki], dtype='float32')[kw],
borderType=cv2.BORDER_CONSTANT)
mag_c = np.maximum(mag_c, temp_egm)
else:
# Get the maximum EGM over all kernels.
for ki in range(0, kernel_filters.shape[0]):
# Image convolution
temp_egm = cv2.filter2D(np.float32(im),
cv2.CV_32F,
kernel_filters[ki],
borderType=cv2.BORDER_CONSTANT)
mag_c = np.maximum(mag_c, temp_egm)
else:
if isinstance(kernel_filters, list):
kiter = len(kernel_filters)
# Get the maximum EGM over all kernel pairs.
for ki in range(0, kiter):
# EGM
temp_egm = _get_magnitude(im, np.array(kernel_filters[ki], dtype='float32'))
mag_c = np.maximum(mag_c, temp_egm)
else:
kiter = kernel_filters.shape[0]
# Get the maximum EGM over all kernel pairs.
for ki in range(0, kiter, 2):
# EGM
temp_egm = _get_magnitude(im, kernel_filters[ki:ki+2])
mag_c = np.maximum(mag_c, temp_egm)
mag_p += mag_c
if pad > 0:
# mag_p = mag_p.mean(axis=0)[pad:n_rows+pad, pad:n_cols+pad] * mag_p.max(axis=0)[pad:n_rows+pad, pad:n_cols+pad]
mag_p = mag_p[pad:n_rows+pad, pad:n_cols+pad] / len(conv_kernels)
else:
# mag_p = mag_p.mean(axis=0) * mag_p.max(axis=0)
mag_p = mag_p / len(conv_kernels)
mag_p[np.isnan(mag_p) | np.isinf(mag_p)] = 0.0
return mag_p
def get_mag_egm(ts_array, ts_r, ts_c, kernels):
# EGM holder
mag_egm = np.zeros((ts_array.shape[0], ts_r, ts_c), dtype='float32')
se = np.array([[0, 1, 0],
[1, 1, 1],
[0, 1, 0]], dtype='uint8')
# count = np.zeros((ts_r, ts_c), dtype='uint8')
# Get the EGM from each day.
for ti in range(0, ts_array.shape[0]):
mask = mdilate(np.where(ts_array[ti] == 0, 1, 0), se, iters=10)
# count[mask == 0] += 1
# Get the EGM over all 'kernels'.
magg_ = get_magnitude(ts_array[ti],
kernels=kernels,
pad=0)
# magg_[mask == 1] = 0
magg_[mask == 1] = np.nan
mag_egm[ti] = magg_
# Get the mean EGM over all layers
# mag_egm_mean = mag_egm.sum(axis=0) / np.float32(count)
mag_egm_mean = np.nanmean(mag_egm, axis=0)
mag_egm_med = np.nanmedian(mag_egm, axis=0)
mag_egm_cv = np.nanstd(mag_egm, axis=0) / mag_egm_med
mag_egm_cv = ((mag_egm_cv + mag_egm_med) / 2.0) * 10000.0
return mag_egm_mean, mag_egm_cv
def get_mag_dist(ts_array, ts_r, ts_c, cvm):
# EGM holder
mag_dist = np.zeros((ts_r, ts_c), dtype='float32')
# Get the edge distance from each day.
for ti in range(0, ts_array.shape[0]-3):
mag_dist_ = moving_window(ts_array[ti:ti+3],
statistic='distance',
window_size=3,
weights=cvm)
mag_dist += mag_dist_
return mag_dist / float(ts_array.shape[0]-3)
def _do_clahe(image2adjust, clip_perc, grid_tile):
"""
Contrast Limited Adaptive Histogram Equalization (CLAHE)
Args:
image2adjust (2d array)
clip_perc (float)
grid_tile (int)
Returns:
CLAHE adjusted 2d array
"""
clahe = cv2.createCLAHE(clipLimit=clip_perc, tileGridSize=grid_tile)
return clahe.apply(image2adjust)
def local_hist_eq(image2adjust, clip_percentages=None, grid_tiles=None, method='mean'):
"""
Computes multi-scale Contrast Limited Adaptive Histogram Equalization (CLAHE)
Args:
image2adjust (ndarray): The edge gradient magnitude array to adjust. Should be uint8 data type.
clip_percentages (Optional[float list]): A list of clip percentages for CLAHE. Default is [1.].
grid_tiles (Optional[tuple list]): A list of grid tuples for CLAHE. Default is [(16, 16)].
method (Optional[str]): The aggregation method.
Returns:
Adjusted image as 2d array.
"""
if not clip_percentages:
clip_percentages = [1.]
if grid_tiles:
grid_tiles = [(gk, gk) for gk in grid_tiles]
else:
grid_tiles = [(16, 16)]
rws, cls = image2adjust.shape
if method == 'mean':
temp_arr_eq = np.zeros((rws, cls), dtype='uint64')
elif method == 'median' or method == 'min':
temp_arr_eq = np.zeros((len(clip_percentages) * len(grid_tiles), rws, cls), dtype='uint64')
counter = 0
# Iterate over each clip percentage.
for clip_perc in clip_percentages:
# Iterate over each grid tile.
for grid_tile in grid_tiles:
# Compute CLAHE and add it to the output array.
if method == 'mean':
temp_arr_eq += _do_clahe(image2adjust, clip_perc, grid_tile)
# temp_arr_eq += rescale_intensity(exposure.equalize_adapthist(image2adjust,
# kernel_size=grid_tile[0],
# clip_limit=clip_perc),
# in_range=(0., 1.), out_range=(0, 255))
elif method == 'median' or method == 'min':
temp_arr_eq[counter] = _do_clahe(image2adjust, clip_perc, grid_tile)
counter += 1
# Return the mean CLAHE-adjusted edge gradient magnitude
if method == 'mean':
return np.float32(temp_arr_eq / float(len(clip_percentages) * len(grid_tiles))) / 255.0
# return np.uint8(np.divide(temp_arr_eq, float(len(clip_percentages) * len(grid_tiles))) / 255.)
elif method == 'median':
return np.float32(np.median(temp_arr_eq, axis=0) / 255.0)
elif method == 'min':
return np.float32(temp_arr_eq.min(axis=0) / 255.0)
def locate_endpoints(edge_image, locations='all'):
"""
Locates edge endpoints
Args:
edge_image (2d array)
locations (Optional[str]): Choices are ['all', 'small', 'broken'].
Returns:
Image endpoints, where endpoints = 1.
"""
# Setup the endpoint structuring elements for
# hit or miss morphology.
if locations == 'all':
endpoints = [np.array([[0, 0, 0], [0, 1, 0], [2, 1, 2]], dtype='uint8'),
np.array([[0, 0, 0], [0, 1, 2], [0, 2, 1]], dtype='uint8'),
np.array([[0, 0, 2], [0, 1, 1], [0, 0, 2]], dtype='uint8'),
np.array([[0, 2, 1], [0, 1, 2], [0, 0, 0]], dtype='uint8'),
np.array([[2, 1, 2], [0, 1, 0], [0, 0, 0]], dtype='uint8'),
np.array([[1, 2, 0], [2, 1, 0], [0, 0, 0]], dtype='uint8'),
np.array([[2, 0, 0], [1, 1, 0], [2, 0, 0]], dtype='uint8'),
np.array([[0, 0, 0], [2, 1, 0], [1, 2, 0]], dtype='uint8'),
np.array([[0, 0, 0], [0, 1, 0], [1, 2, 1]], dtype='uint8'),
np.array([[0, 0, 1], [0, 1, 2], [0, 0, 1]], dtype='uint8'),
np.array([[1, 2, 1], [0, 1, 0], [0, 0, 0]], dtype='uint8')]
elif locations == 'small':
endpoints = [np.array([[0, 0, 0], [0, 1, 0], [1, 1, 1]], dtype='uint8'),
np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype='uint8'),
np.array([[0, 0, 1], [0, 1, 1], [0, 0, 1]], dtype='uint8'),
np.array([[0, 1, 1], [0, 1, 1], [0, 0, 0]], dtype='uint8'),
np.array([[1, 1, 1], [0, 1, 0], [0, 0, 0]], dtype='uint8'),
np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype='uint8'),
np.array([[1, 0, 0], [1, 1, 0], [1, 0, 0]], dtype='uint8'),
np.array([[0, 0, 0], [1, 1, 0], [1, 1, 0]], dtype='uint8'),
np.array([[0, 0, 0], [0, 1, 0], [1, 1, 1]], dtype='uint8'),
np.array([[0, 0, 1], [0, 1, 1], [0, 0, 1]], dtype='uint8'),
np.array([[1, 1, 1], [0, 1, 0], [0, 0, 0]], dtype='uint8'),
np.array([[1, 0, 0], [1, 1, 0], [1, 0, 0]], dtype='uint8')]
elif locations == 'broken':
endpoints = [np.array([[0, 0, 0], [0, 1, 0], [1, 0, 1]], dtype='uint8'),
np.array([[0, 0, 1], [0, 1, 0], [0, 0, 1]], dtype='uint8'),
np.array([[1, 0, 1], [0, 1, 0], [0, 0, 0]], dtype='uint8'),
np.array([[1, 0, 0], [0, 1, 0], [1, 0, 0]], dtype='uint8')]
end_points = np.zeros(edge_image.shape, dtype='uint8')
# Find the endpoints.
for endpoint in endpoints:
end_points += mhitmiss(np.uint8(edge_image), endpoint)
end_points[end_points > 1] = 1
return end_points
def _locate_islands(edge_image):
"""
Locates single pixel islands
Args:
edge_image (2d array)
Returns:
Image endpoint islands, where islands = 1.
"""
# Setup the endpoint structuring elements for
# hit or miss morphology.
endpoint = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype='uint8')
end_points = np.zeros(edge_image.shape, dtype='uint8')
end_points += mhitmiss(edge_image, endpoint)
end_points[end_points > 1] = 1
return end_points
def _trim_endpoints(edge_image,
iterations,
locations='all',
filter=False,
filter_ws=15,
filter_pct=.1,
skeleton=False):
"""
Trims unconnected lines, starting from endpoints
Args:
edge_image (2d array)
iterations (int)
locations (str)
filter (bool)
filter_ws (int)
filter_pct (float)
skeleton (bool)
"""
if filter:
edge_image_sum = moving_window(edge_image, statistic='sum', window_size=filter_ws)
for iter in range(0, iterations):
# Locate the endpoints
ep = locate_endpoints(edge_image, locations=locations)
# Filter high density areas.
if filter:
ep[edge_image_sum >= int((filter_ws * filter_ws) * filter_pct)] = 0
# Remove the endpoints from the edge image.
edge_image[ep == 1] = 0
# Fill small gaps after the first iteration.
if iter == 0:
edge_image = moving_window(edge_image, statistic='fill', window_size=3, n_neighbors=2)
# Remove remaining single pixels.
ep = _locate_islands(edge_image)
edge_image[ep == 1] = 0
if skeleton:
return _do_skeleton(edge_image)
else:
return edge_image
def _link_edge_endpoints(cr, max_gap, mag_image, **kwargs):
"""
Links edge endpoints
Args:
cr (2d array)
max_gap (int)
mag_image (2d array)
"""
# Link endpoints
cr = moving_window(np.uint8(cr*1),
statistic='link',
window_size=max_gap,
endpoint_array=locate_endpoints(np.uint8(cr*1)),
gradient_array=mag_image,
**kwargs)
# Fill broken links
# __--__ to
# ______
cr = _trim_endpoints(cr, 1, locations='broken')
cr = moving_window(cr, statistic='fill', window_size=3)
# A little cleanup before linking.
cr = _trim_endpoints(cr, 1, locations='all', filter=True, filter_ws=15, filter_pct=.1)
# Link endpoints.
return moving_window(cr * 1,
statistic='link',
window_size=max_gap,
endpoint_array=locate_endpoints(cr * 1),
gradient_array=mag_image,
**kwargs)
def canny_morphology(value_array, egm_array, l1, l2, k_size, l_egm, link_window):
"""
Args:
value_array (2d array): Float32 0-1
egm_array (2d array): Float32 0-1
l1 (int): Canny lower threshold.
l2 (int): Canny upper threshold.
k_size (int): Canny aperture size.
l_egm (float): The EGM lower threshold.
link_window (int): The link window size.
"""
canny_edge = cv2.Canny(np.uint8(value_array * 255.),
l1,
l2,
apertureSize=k_size,
L2gradient=True)
# canny_edge = moving_window(egm_array,
# window_size=3,
# weights=egd,
# statistic='suppression')
canny_edge[canny_edge > 0] = 1
canny_edge = _trim_endpoints(canny_edge, 1, locations='broken')
# Remove small edge objects.
# canny_edge = nd_label(canny_edge)[0]
canny_edge = sk_label(np.uint8(canny_edge), connectivity=2)
# canny_edge = np.uint64(remove_small_objects(canny_edge, min_size=5, connectivity=1))
# Remove objects with low EGM.
props = regionprops(canny_edge, intensity_image=egm_array)
canny_edge = np.float32(canny_edge)
for prop in props:
canny_edge[canny_edge == prop.label] = prop.mean_intensity
canny_edge[canny_edge <= l_egm] = 0
canny_edge[canny_edge > 0] = 1
# Link endpoints
canny_edge = _trim_endpoints(np.uint8(canny_edge), 1, locations='broken')
canny_edge = moving_window(np.uint8(canny_edge),
statistic='link',
window_size=link_window,
endpoint_array=locate_endpoints(np.uint8(canny_edge)),
gradient_array=egm_array,
smallest_allowed_gap=5)
# Remove small objects.
# canny_edge = nd_label(np.uint8(canny_edge))[0]
canny_edge = sk_label(np.uint8(canny_edge), connectivity=2)
canny_edge = np.uint64(remove_small_objects(canny_edge, min_size=10, connectivity=1))
# props = regionprops(canny_edge, intensity_image=egm_array)
# canny_edge = np.float32(canny_edge)
canny_edge[canny_edge > 0] = 1
return _trim_endpoints(canny_edge, 1)
# for prop in props:
#
# if (prop.eccentricity < .4) and (prop.area < 100):
# canny_edge[canny_edge == prop.label] = 0
#
# # if ((prop.major_axis_length + .00001) / (prop.minor_axis_length + .00001) < 2) and (prop.area < 100):
# # canny_edge[canny_edge == prop.label] = 0
#
# canny_edge[canny_edge > 0] = 1
# cannycv_r = cv2.threshold(np.uint8(canny_edge), 0, 1, cv2.THRESH_BINARY_INV)[1]
#
# dist = cv2.distanceTransform(np.uint8(cannycv_r), cv2.DIST_L2, 3)
#
# canny_edge = moving_window(dist, statistic='seg-dist', window_size=3)
#
# canny_edge = moving_window(np.uint8(canny_edge),
# statistic='link',
# window_size=link_window,
# endpoint_array=locate_endpoints(np.uint8(canny_edge)),
# gradient_array=egm_array,
# smallest_allowed_gap=5)
return canny_edge
def _do_skeleton(cr):
"""
Computes the morphological skeleton
Args:
cr (2d array)
Returns:
Image skeleton as 2d array
"""
# Fill holes to keep straighter skeleton lines.
return np.uint8(skeletonize(moving_window(np.uint8(cr), statistic='fill', window_size=3)))
def morphological_cleanup(cr,
min_line_size,
theta_45_iters=0,
theta_90_iters=0,
theta_180_iters=0,
pre_thin=False,
endpoint_iterations=0,
skeleton=False,
link_ends=False,
egm_array=None,
extend_endpoints=False,
max_gap=25,
min_egm=25,
smallest_allowed_gap=3,
medium_allowed_gap=7,
link_iters=1,
link_window_size=7,
extend_iters=1,
value_array=None):
"""
A function to morphologically clean binary edges
Args:
cr (2d array)
min_line_size (int)
theta_45_iters (Optional[int])
theta_90_iters (Optional[int])
theta_180_iters (Optional[int])
pre_thin (Optional[bool])
endpoint_iterations (Optional[int])
skeleton (Optional[bool])
link_ends (Optional[bool])
egm_array (Optional[2d array]): Edge gradient magnitude
extend_endpoints (Optional[bool])
max_gap (Optional[int])
min_egm (Optional[int])
smallest_allowed_gap (Optional[int])
medium_allowed_gap (Optional[int])
link_iters (Optional[int])
link_window_size (Optional[int])
extend_iters (Optional[int])
value_array (Optional[2d array])
Returns:
Morphologically cleaned edges as 2d array
"""
if isinstance(value_array, np.ndarray):
low_value_edge_idx = np.where((cr == 1) & (value_array < 0.2))
if pre_thin:
# Thin edges with 1 iteration
cr = pymorph.thin(pymorph.binary(cr), n=1, Iab=pymorph.endpoints())
# Remove small edge objects.
# cr = nd_label(cr)[0]
cr = sk_label(np.uint8(cr), connectivity=2)
cr = np.uint64(remove_small_objects(cr, min_size=min_line_size, connectivity=1))
cr[cr > 0] = 1
# Extend endpoints along
# the same gradient
# orientation.
if extend_endpoints:
# The edge gradient direction
egd_array = moving_window(egm_array,
window_size=link_window_size,
statistic='edge-direction')
for iter in range(0, extend_iters):
cr = moving_window(cr,
statistic='extend-endpoints',
window_size=3,
endpoint_array=locate_endpoints(cr),
gradient_array=egm_array*255.,
weights=egd_array)
# Thin edges
if (theta_180_iters > 0) and (theta_90_iters > 0) and (theta_45_iters > 0):
# cr = np.uint8(pymorph.thin(pymorph.binary(np.uint8(cr)), theta=180, n=theta_180_iters))
# cr2 = np.uint8(pymorph.thin(pymorph.binary(np.uint8(cr)), theta=90, n=theta_90_iters))
# cr3 = np.uint8(pymorph.thin(pymorph.binary(np.uint8(cr)), n=theta_45_iters))
#
# cr[(cr2 == 1) | (cr3 == 1)] = 1
cr = sk_thin(np.uint8(cr), max_iter=1)
else:
if theta_180_iters > 0:
cr = np.uint8(pymorph.thin(pymorph.binary(np.uint8(cr)), theta=180, n=theta_180_iters))
if theta_90_iters > 0:
cr = np.uint8(pymorph.thin(pymorph.binary(np.uint8(cr)), theta=90, n=theta_90_iters))
if theta_45_iters > 0:
cr = np.uint8(mthin(np.uint8(cr), max_iter=theta_45_iters))
# Remove small objects again after
# thinning and trimming.
if min_line_size > 0:
# cr, __ = nd_label(cr)
cr = sk_label(np.uint8(cr), connectivity=2)
cr = np.uint64(remove_small_objects(cr, min_size=min_line_size, connectivity=1))
cr[cr > 0] = 1
# if skeleton:
# crc = _do_skeleton(cr.copy())
# Link endpoints with small gaps.
if link_ends:
for link_iter in range(0, link_iters):
cr = _link_edge_endpoints(cr,
max_gap,
egm_array,
min_egm=min_egm,
smallest_allowed_gap=smallest_allowed_gap,
medium_allowed_gap=medium_allowed_gap)
cr = _trim_endpoints(cr, 1)
# import matplotlib.pyplot as plt
# cr = _do_skeleton(cr)
# plt.subplot(121)
# plt.imshow(crc)
# plt.subplot(122)
# plt.imshow(cr)
# plt.show()
# import sys
# sys.exit()
# Compute the morphological skeleton.
# The skeleton is morphological thinning with
# infinite iterations.
if skeleton:
cr = _do_skeleton(cr)
# Trim endpoints with ``endpoint_iterations`` iterations.
if endpoint_iterations > 0:
cr = _trim_endpoints(cr, endpoint_iterations, skeleton=True)
# Fill small holes
if isinstance(value_array, np.ndarray):
cr[low_value_edge_idx] = 1
cr = moving_window(cr, statistic='fill', window_size=3, n_neighbors=2)
# Fill broken links
# __--__ to
# ______
cr = _trim_endpoints(cr, 1, locations='broken')
return moving_window(cr, statistic='fill', window_size=3)
def init_distance(egm_array, threshold):
"""
Initializes a euclidean distance transform array
Args:
egm_array (2d array)
threshold (float or int)
"""
# Threshold the EGM into a binary edge/no edge array.
binary_array = np.uint8(np.where(egm_array < threshold, 1, 0))
# Get the euclidean distance from edge pixels.
dist = np.float32(cv2.distanceTransform(binary_array, cv2.DIST_L2, 3))
dist[dist < 0] = 0
dist /= dist.max()
return dist
def init_level_set(egm_array, threshold):
"""
Initializes a level set array
Args:
egm_array (2d array)
threshold (float or int)
"""
# Threshold the EGM into a binary edge/no edge array.
binary_array = np.uint8(np.where(egm_array < threshold, 1, 0))
# Get the euclidean distance from edge pixels.
dist = np.float32(cv2.distanceTransform(binary_array, cv2.DIST_L2, 3))
dist = np.where((binary_array == 1) & (dist > 1), dist, 0)
binary_array_r = np.uint8(cv2.threshold(binary_array, 0, 1, cv2.THRESH_BINARY_INV)[1])
dist_r = cv2.distanceTransform(binary_array_r, cv2.DIST_L2, 3)
return np.where(dist == 0, dist_r * -1., dist)
def multiscale_threshold(egm_array,
min_object_size,
windows=None,
link_ends=False,
theta_180_iters=1,
theta_90_iters=1,
theta_45_iters=1,
skeleton=False,
endpoint_iterations=1,
method='wmean',
ignore_thresh=15.0,
inverse_dist=True,
n_jobs=-1):
"""
Computes multi-scale adaptive threshold and morphological "cleaning"
Args:
egm_array (ndarray):
min_object_size (int):
windows (Optional[int list]):
link_ends (Optional[bool]):
theta_180_iters (Optional[int]):
theta_90_iters (Optional[int]):
theta_45_iters (Optional[int]):
skeleton (Optional[bool]):
endpoint_iterations (Optional[int]):
method (Optional[str]): Choices area ['gaussian', 'mean', 'median', 'weighted'].
ignore_thresh (Optional[float])
inverse_dist (Optional[bool])
n_jobs (Optional[int])
Returns:
Binary edges as 2d array
"""
if not isinstance(windows, list):
windows = [11, 21, 31, 41, 51, 61, 71]
# Get the image shape.
im_rows, im_cols = egm_array.shape
# Setup the output binary edge array holder.
thresholded_edges = np.zeros((im_rows, im_cols), dtype='uint8')
wp = 64
egm_array = cv2.copyMakeBorder(egm_array, wp, wp, wp, wp, cv2.BORDER_REFLECT)
for w in windows:
# Threshold the array with the current window size.
if method == 'gaussian':
# The gaussian threshold is a weighted sum of the window,
# where the weights are a gaussian window.
binary_adaptive_m = cv2.adaptiveThreshold(egm_array, 1,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, w, 15.)
elif method == 'mean-c':
binary_adaptive_m = cv2.adaptiveThreshold(egm_array, 1,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, w, 15.)
elif method == 'median':
binary_adaptive_m = threshold_local(egm_array, w, method=method)
elif method == 'wmean':
dist_transform = np.float64(init_distance(egm_array, 30))
dist_transform = np.float64(closerec(np.uint8(dist_transform*255.0), 'disk', r=3, iters=5))
dist_transform /= dist_transform.max()
binary_adaptive_m = athreshold(np.ascontiguousarray(egm_array, dtype='float64'),
w,
ignore_thresh=ignore_thresh,
rt=-25.0,
n_jobs=n_jobs,
method=method,
inverse_dist=inverse_dist,
edge_direction_array=None,
edge_distance_array=dist_transform)
elif method == 'bernson':
binary_adaptive_m = athreshold(np.ascontiguousarray(egm_array, dtype='float64'),
w,
ignore_thresh=15.,
rt=-10.,
n_jobs=n_jobs,
method=method)
elif method == 'niblack':
binary_adaptive_m = athreshold(np.ascontiguousarray(egm_array, dtype='float64'),
w,
ignore_thresh=15.,
rt=-10.,
k=-.01,
n_jobs=n_jobs,
method=method)
elif method == 'sauvola':
binary_adaptive_m = athreshold(np.ascontiguousarray(egm_array, dtype='float64'),
w,
ignore_thresh=15.,
rt=-10.,
k=-.01,
n_jobs=n_jobs,
method=method)
elif method == 'bradley':
binary_adaptive_m = athreshold(np.ascontiguousarray(egm_array, dtype='float64'),
w,
ignore_thresh=15.,
rt=1.,
n_jobs=n_jobs,
method=method)
elif method == 'otsu':
binary_adaptive_m = athreshold(np.ascontiguousarray(egm_array, dtype='float64'),
w,
ignore_thresh=15.,
rt=1.,
n_jobs=n_jobs,
method=method)
elif method == '60':
func = lambda arr: np.percentile(arr, 60)
binary_adaptive_m = threshold_local(egm_array, w, 'generic', param=func)
else:
raise ValueError('The method was not recognized.')
# Cleanup the binary edges with image morphology.
thresholded_edges += morphological_cleanup(binary_adaptive_m[wp:-wp, wp:-wp],
min_object_size,
theta_180_iters=theta_180_iters,
theta_90_iters=theta_90_iters,
theta_45_iters=theta_45_iters,
skeleton=skeleton,
endpoint_iterations=endpoint_iterations,
link_ends=link_ends,
egm_array=egm_array)
thresholded_edges[thresholded_edges > 1] = 1
return thresholded_edges
# def _remove_interior_islands(prop,
# min_area_int_,
# mean_threshold_,
# boundary_mean_,
# prop_area_weight_,
# bbox_pad,
# arows,
# acols,
# segments_g,
# original_binary_edge_g,
# se_cross):
def _remove_interior_islands(*args):
"""
Gets indices to remove interior island objects
"""
prop, min_area_int_, mean_threshold_, boundary_mean_, prop_area_weight_, bbox_pad, arows, acols, segments_g, original_binary_edge_g, se_cross = list(itertools.chain(*args))
# mean_threshold_ = 0.2 # The minimum EVI2 threshold allowed for objects
# boundary_mean_ = 0.25 # The maximum EVI2 threshold allowed for boundaries
# min_area_int_ = 222 # The minimum pixel count allowed for interior objects
# Get the bounding box of the current segment.
min_row, min_col, max_row, max_col = prop.bbox
# Expand the box.
min_row = min_row - bbox_pad if (min_row - bbox_pad) > 0 else 0
max_row = max_row + bbox_pad if (max_row + bbox_pad) < (arows - 1) else arows - 1
min_col = min_col - bbox_pad if (min_col - bbox_pad) > 0 else 0
max_col = max_col + bbox_pad if (max_col + bbox_pad) < (acols - 1) else acols - 1
# Get a subset of the current object.
labels_sub = segments_g[min_row:max_row, min_col:max_col]
# Get a subset of the pre-cleaned edges
if isinstance(original_binary_edge_g, np.ndarray):
binary_sub = original_binary_edge_g[min_row:max_row, min_col:max_col]
# Get the count of pre-cleaned
# edges in the object.
binary_edge_count = ((binary_sub == 1) & (labels_sub == prop.label)).sum()
# Don't include objects half covered by pre-cleaned edges.
if binary_edge_count >= int(prop.area * prop_area_weight_):
idx = list(np.where(labels_sub == prop.label))
idx[0] = idx[0] + min_row
idx[1] = idx[1] + min_col
return list(idx[0]), list(idx[1])
# Don't include objects with low EVI2.
if hasattr(prop, 'mean_intensity'):
if prop.mean_intensity < mean_threshold_:
idx = list(np.where(labels_sub == prop.label))
idx[0] = idx[0] + min_row
idx[1] = idx[1] + min_col
return list(idx[0]), list(idx[1])
# Get the current object.
labels_sub_center = np.uint8(np.where(labels_sub == prop.label, 1, 0))
# Get the boundary labels.
label_boundary = cv2.morphologyEx(labels_sub_center,
cv2.MORPH_DILATE,
se_cross,
iterations=2) - labels_sub_center
boundary_idx = np.where(label_boundary == 1)
# Check if the current object is completely
# surrounded by 1-2 other objects.
if | np.any(boundary_idx) | numpy.any |
import numpy as np
def _softmax(x):
''' A numberically stable way '''
x = x - np.max(x)
exp_x = np.exp(x)
res = exp_x/np.sum(exp_x)
return res
def sigmoid(x, epsilon=1.0):
sigm = 1. / (1. + np.exp(-x*epsilon))
return sigm
def triu_indice(k=1, pair_type='NoTies', labels=None):
'''
Get unique document pairs being consistent with the specified pair_type. This function is used to avoid duplicate computation.
All: pairs including both pairs of documents across different relevance levels and
pairs of documents having the same relevance level.
NoTies: the pairs consisting of two documents of the same relevance level are removed
No00: the pairs consisting of two non-relevant documents are removed
:param batch_mats: [batch, m, m]
:param k: the offset w.r.t. the diagonal line: k=0 means including the diagonal line, k=1 means upper triangular part without the diagonal line
:return:
'''
#assert pair_type in PAIR_TYPE
m = len(labels) # the number of documents
if pair_type == 'All':
row_inds, col_inds = np.triu_indices(m, k=k)
elif pair_type == 'No00':
row_inds, col_inds = np.triu_indices(m, k=k)
pairs = [e for e in zip(row_inds, col_inds) if not (0==labels[e[0]] and 0==labels[e[1]])] # remove pairs of 00 comparisons
row_inds = [e[0] for e in pairs]
col_inds = [e[1] for e in pairs]
elif pair_type == '00': # the pairs consisting of two non-relevant documents
row_inds, col_inds = np.triu_indices(m, k=k)
pairs = [e for e in zip(row_inds, col_inds) if (0 == labels[e[0]] and 0 == labels[e[1]])] # remove pairs of 00 comparisons
row_inds = [e[0] for e in pairs]
col_inds = [e[1] for e in pairs]
elif pair_type == 'NoTies':
row_inds, col_inds = np.triu_indices(m, k=k)
pairs = [e for e in zip(row_inds, col_inds) if labels[e[0]]!=labels[e[1]]] # remove pairs of documents of the same level
row_inds = [e[0] for e in pairs]
col_inds = [e[1] for e in pairs]
else:
raise NotImplementedError
return row_inds, col_inds
#todo the customized usage should be double-checked !!!
"""
# <1> using
# customized objective functions, arguments should be as follows:
grad, hess = self.func(labels, preds, dataset.get_group())
# <2> using argument: fobj
fobj : callable or None, optional (default=None)
Customized objective function.
Should accept two parameters: preds, train_data,
and return (grad, hess).
"""
FIRST_ORDER = False
CONSTANT_HESSIAN = 1.0
#-- LambdaLoss --#
WEIGHTING_TYPE = ['DeltaNDCG', 'DeltaGain']
def ideal_dcg(ideally_sorted_labels):
'''
:param ideally_sorted_labels:
:return:
'''
gains = np.power(2.0, ideally_sorted_labels) - 1.0
ranks = np.arange(len(ideally_sorted_labels)) + 1.0
discounts = np.log2(1.0 + ranks)
ideal_dcg = np.sum(gains / discounts)
return ideal_dcg
def get_delta_gains(labels_sorted_via_preds):
gains = np.power(2.0, labels_sorted_via_preds) - 1.0
gain_diffs = np.expand_dims(gains, axis=1) - np.expand_dims(gains, axis=0)
delta_gain = np.abs(gain_diffs) # absolute delta gains w.r.t. pairwise swapping
return delta_gain
def get_delta_ndcg(ideally_sorted_labels, labels_sorted_via_preds):
'''
Delta-nDCG w.r.t. pairwise swapping of the currently predicted ranking
'''
idcg = ideal_dcg(ideally_sorted_labels) # ideal discount cumulative gains
gains = np.power(2.0, labels_sorted_via_preds) - 1.0
n_gains = gains / idcg # normalised gains
ng_diffs = np.expand_dims(n_gains, axis=1) - np.expand_dims(n_gains, axis=0)
ranks = np.arange(len(labels_sorted_via_preds)) + 1.0
dists = 1.0 / np.log2(ranks + 1.0) # discount co-efficients
dists_diffs = np.expand_dims(dists, axis=1) - np.expand_dims(dists, axis=0)
mat_delta_ndcg = np.abs(ng_diffs) * np.abs(dists_diffs) # absolute changes w.r.t. pairwise swapping
return mat_delta_ndcg
def per_query_gradient_hessian_lambda(preds=None, labels=None, first_order=False, weighting=False, weighting_type='DeltaNDCG', pair_type='NoTies', epsilon=1.0):
'''
Compute the corresponding gradient & hessian
cf. LightGBM https://github.com/microsoft/LightGBM/blob/master/src/objective/rank_objective.hpp
cf. XGBoost https://github.com/dmlc/xgboost/blob/master/src/objective/rank_obj.cc
:param preds: 1-dimension predicted scores
:param labels: 1-dimension ground truth
:return:
'''
desc_inds = np.flip(np.argsort(preds)) # indice that sort the preds in a descending order
system_sorted_preds = preds[desc_inds]
labels_sorted_via_preds = labels[desc_inds]
row_inds, col_inds = triu_indice(labels=labels_sorted_via_preds, k=1, pair_type=pair_type)
# prediction difference
mat_s_ij = np.expand_dims(system_sorted_preds, axis=1) - np.expand_dims(system_sorted_preds, axis=0)
# S_ij in {-1, 0, 1} is the standard indicator
mat_S_ij = np.expand_dims(labels_sorted_via_preds, axis=1) - np.expand_dims(labels_sorted_via_preds, axis=0)
mat_S_ij = np.clip(mat_S_ij, a_min=-1.0, a_max=1.0)
num_docs, num_pairs = len(labels), len(row_inds)
if first_order:
grad = np.zeros((num_docs,))
else:
grad, hess = np.zeros((num_docs,)), np.zeros((num_docs,))
if weighting and weighting in WEIGHTING_TYPE:
if weighting_type == 'DeltaNDCG':
ideally_sorted_labels = np.flip(np.sort(labels))
mat_weights = get_delta_ndcg(ideally_sorted_labels=ideally_sorted_labels, labels_sorted_via_preds=labels_sorted_via_preds)
elif weighting_type == 'DeltaGain':
mat_weights = get_delta_gains(labels_sorted_via_preds=labels_sorted_via_preds)
for i in range(num_pairs): # iterate over pairs
r, c = row_inds[i], col_inds[i]
s_ij = mat_s_ij[r, c]
S_ij = mat_S_ij[r, c]
lambda_ij = epsilon*(sigmoid(s_ij, epsilon=epsilon) - 0.5*(1.0+S_ij)) # gradient w.r.t. s_i
if weighting and weighting in WEIGHTING_TYPE: lambda_ij *= mat_weights[r, c] # delta metric variance
lambda_ji = - lambda_ij # gradient w.r.t. s_j
grad[desc_inds[r]] += lambda_ij # desc_inds[r] denotes the original index of the document currently being at r-th position after a full-descending-ordering by predictions
grad[desc_inds[c]] += lambda_ji
if not first_order: # 2nd order hessian
lambda_ij_2order = np.power(epsilon, 2.0) * sigmoid(s_ij) * (1.0-sigmoid(s_ij))
lambda_ij_2order = np.maximum(lambda_ij_2order, 1e-16) # trick as XGBoost https://github.com/dmlc/xgboost/blob/master/src/objective/rank_obj.cc
if weighting and weighting in WEIGHTING_TYPE: lambda_ij_2order *= mat_weights[r, c]
lambda_ji_2order = -lambda_ij_2order
hess[desc_inds[r]] += lambda_ij_2order
hess[desc_inds[c]] += lambda_ji_2order
if first_order:
return grad, None
else:
return grad, hess
def lightgbm_custom_obj_ranknet(labels=None, preds=None, group=None):
"""
:param labels: numpy.ndarray of shape (size_data, )
:param preds:
:param group: # numpy.ndarray of shape (num_queries, )
:return:
"""
size_data = len(labels)
if FIRST_ORDER:
all_grad, all_hess = np.zeros((size_data,)), np.full((size_data,), fill_value=CONSTANT_HESSIAN)
else:
all_grad, all_hess = np.zeros((size_data,)), np.zeros((size_data,))
head = 0
for num_docs_per_query in group.astype(np.int):
labels_per_query = labels[head:head + num_docs_per_query]
preds_per_query = preds[head:head + num_docs_per_query]
grad_per_query, hess_per_query = per_query_gradient_hessian_lambda(preds=preds_per_query,
labels=labels_per_query, first_order=FIRST_ORDER, pair_type='All', epsilon=1.0, weighting=False)
all_grad[head:head + num_docs_per_query] = grad_per_query
if not FIRST_ORDER: all_hess[head:head + num_docs_per_query] = hess_per_query
head += num_docs_per_query
return all_grad, all_hess
def lightgbm_custom_obj_ranknet_fobj(preds, train_data):
'''
The traditional ranknet
:param preds: numpy.ndarray of shape (size_data, )
:param train_data:
:return:
'''
all_labels = train_data.get_label() # numpy.ndarray of shape (size_data, )
group = train_data.get_group() # numpy.ndarray of shape (num_queries, )
size_data = len(all_labels)
if FIRST_ORDER:
all_grad, all_hess = np.zeros((size_data,)), np.full((size_data,), fill_value=CONSTANT_HESSIAN)
else:
all_grad, all_hess = np.zeros((size_data,)), np.zeros((size_data,))
head = 0
for num_docs_per_query in group.astype(np.int):
labels_per_query = all_labels[head:head + num_docs_per_query]
preds_per_query = preds[head:head + num_docs_per_query]
grad_per_query, hess_per_query = per_query_gradient_hessian_lambda(preds=preds_per_query,
labels=labels_per_query, first_order=FIRST_ORDER, pair_type='All', epsilon=1.0, weighting=False)
all_grad[head:head + num_docs_per_query] = grad_per_query
if not FIRST_ORDER: all_hess[head:head + num_docs_per_query] = hess_per_query
head += num_docs_per_query
return all_grad, all_hess
def lightgbm_custom_obj_lambdarank(labels=None, preds=None, group=None):
"""
:param labels: numpy.ndarray of shape (size_data, )
:param preds:
:param group: numpy.ndarray of shape (num_queries, )
:return:
"""
size_data = len(labels)
if FIRST_ORDER:
all_grad, all_hess = np.zeros((size_data,)), np.full((size_data,), fill_value=CONSTANT_HESSIAN)
else:
all_grad, all_hess = np.zeros((size_data,)), np.zeros((size_data,))
head = 0
for num_docs_per_query in group.astype(np.int):
labels_per_query = labels[head:head + num_docs_per_query]
preds_per_query = preds[head:head + num_docs_per_query]
grad_per_query, hess_per_query = per_query_gradient_hessian_lambda(preds=preds_per_query,
labels=labels_per_query, first_order=FIRST_ORDER, pair_type='NoTies',
epsilon=1.0, weighting=True, weighting_type='DeltaNDCG')
all_grad[head:head + num_docs_per_query] = grad_per_query
if not FIRST_ORDER: all_hess[head:head + num_docs_per_query] = hess_per_query
head += num_docs_per_query
return all_grad, all_hess
def lightgbm_custom_obj_lambdarank_fobj(preds, train_data):
'''
:param preds: numpy.ndarray of shape (size_data, )
:param train_data:
:return:
'''
all_labels = train_data.get_label() # numpy.ndarray of shape (size_data, )
group = train_data.get_group() # numpy.ndarray of shape (num_queries, )
size_data = len(all_labels)
if FIRST_ORDER:
all_grad, all_hess = np.zeros((size_data,)), np.full((size_data,), fill_value=CONSTANT_HESSIAN)
else:
all_grad, all_hess = np.zeros((size_data,)), np.zeros((size_data,))
head = 0
for num_docs_per_query in group.astype(np.int):
labels_per_query = all_labels[head:head + num_docs_per_query]
preds_per_query = preds[head:head + num_docs_per_query]
grad_per_query, hess_per_query = per_query_gradient_hessian_lambda(preds=preds_per_query,
labels=labels_per_query, first_order=FIRST_ORDER, pair_type='NoTies', epsilon=1.0,
weighting=True, weighting_type='DeltaNDCG')
all_grad[head:head + num_docs_per_query] = grad_per_query
if not FIRST_ORDER: all_hess[head:head + num_docs_per_query] = hess_per_query
head += num_docs_per_query
return all_grad, all_hess
#-- ListNet --#
GAIN_TYPE = ['Power', 'Label']
def per_query_gradient_hessian_listnet(preds=None, labels=None, gain_type='Power', first_order=False):
'''
Compute the corresponding gradient & hessian
cf. LightGBM https://github.com/microsoft/LightGBM/blob/master/src/objective/rank_objective.hpp
cf. XGBoost https://github.com/dmlc/xgboost/blob/master/src/objective/rank_obj.cc
:param preds: 1-dimension predicted scores
:param labels: 1-dimension ground truth
:return:
'''
assert gain_type in GAIN_TYPE
if 'Power' == gain_type:
gains = np.power(2.0, labels) - 1.0
elif 'Label' == gain_type:
gains = labels
p_pred, p_truth = _softmax(preds), _softmax(gains)
grad = p_pred - p_truth
hess = None if first_order else p_pred * (1.0-p_pred)
return grad, hess
def lightgbm_custom_obj_listnet(labels=None, preds=None, group=None):
"""
:param labels: numpy.ndarray of shape (size_data, )
:param preds: numpy.ndarray of shape (size_data, )
:param group: numpy.ndarray of shape (num_queries, )
:return:
"""
size_data = len(labels)
if FIRST_ORDER:
all_grad, all_hess = np.zeros((size_data,)), np.full((size_data,), fill_value=CONSTANT_HESSIAN)
else:
all_grad, all_hess = np.zeros((size_data,)), np.zeros((size_data,))
head = 0
for num_docs_per_query in group.astype(np.int):
labels_per_query = labels[head:head + num_docs_per_query]
preds_per_query = preds[head:head + num_docs_per_query]
grad_per_query, hess_per_query = per_query_gradient_hessian_listnet(preds=preds_per_query,
labels=labels_per_query, gain_type='Power', first_order=FIRST_ORDER)
all_grad[head:head + num_docs_per_query] = grad_per_query
if not FIRST_ORDER: all_hess[head:head + num_docs_per_query] = hess_per_query
head += num_docs_per_query
return all_grad, all_hess
def lightgbm_custom_obj_listnet_fobj(preds, train_data):
'''
:param preds: numpy.ndarray of shape (size_data, )
:param train_data:
:return:
'''
all_labels = train_data.get_label() # numpy.ndarray of shape (size_data, )
group = train_data.get_group() # numpy.ndarray of shape (num_queries, )
size_data = len(all_labels)
if FIRST_ORDER:
all_grad, all_hess = np.zeros((size_data,)), np.full((size_data,), fill_value=CONSTANT_HESSIAN)
else:
all_grad, all_hess = np.zeros((size_data,)), | np.zeros((size_data,)) | numpy.zeros |
# -*- coding: utf-8 -*-
from __future__ import print_function, division, absolute_import
import matplotlib, warnings
import numpy as np
import CoolProp
from CoolProp.CoolProp import PropsSI
from CoolProp.Plots.Common import BasePlot, PropertyDict, SIunits
def SimpleCycle(Ref, Te, Tc, DTsh, DTsc, eta_a, Ts_Ph='Ph', **kwargs):
"""
This function plots a simple four-component cycle, on the current axis, or that given by the optional parameter *axis*
Required parameters:
* Ref : A string for the refrigerant
* Te : Evap Temperature in K
* Tc : Condensing Temperature in K
* DTsh : Evaporator outlet superheat in K
* DTsc : Condenser outlet subcooling in K
* eta_a : Adiabatic efficiency of compressor (no units) in range [0,1]
Optional parameters:
* Ts_Ph : 'Ts' for a Temperature-Entropy plot, 'Ph' for a Pressure-Enthalpy
* axis : An axis to use instead of the active axis
* skipPlot : If True, won't actually plot anything, just print COP
"""
warnings.warn("This function has been deprecated. Please consider converting it to an object inheriting from \"BaseCycle\".", DeprecationWarning)
for i in kwargs:
warnings.warn("This function has been deprecated, your input \"{0}: {1}\" will be ignored".format(i, kwargs[i]), DeprecationWarning)
from CoolProp.Plots import SimpleCompressionCycle
cycle = SimpleCompressionCycle(fluid_ref=Ref, graph_type=Ts_Ph)
cycle.simple_solve_dt(Te, Tc, DTsh, DTsc, eta_a, SI=True)
print(cycle.COP_cooling(), cycle.COP_heating())
def TwoStage(Ref, Q, Te, Tc, DTsh, DTsc, eta_oi, f_p, Tsat_ic, DTsh_ic, Ts_Ph='Ph', prints=False, skipPlot=False, axis=None, **kwargs):
"""
This function plots a two-stage cycle, on the current axis, or that given by the optional parameter *axis*
Required parameters:
* Ref : Refrigerant [string]
* Q : Cooling capacity [W]
* Te : Evap Temperature [K]
* Tc : Condensing Temperature [K]
* DTsh : Evaporator outlet superheat [K]
* DTsc : Condenser outlet subcooling [K]
* eta_oi : Adiabatic efficiency of compressor (no units) in range [0,1]
* f_p : fraction of compressor power lost as ambient heat transfer in range [0,1]
* Tsat_ic : Saturation temperature corresponding to intermediate pressure [K]
* DTsh_ic : Superheating at outlet of intermediate stage [K]
Optional parameters:
* Ts_Ph : 'Ts' for a Temperature-Entropy plot, 'Ph' for a Pressure-Enthalpy
* prints : True to print out some values
* axis : An axis to use instead of the active axis
* skipPlot : If True, won't actually plot anything, just print COP
"""
warnings.warn("This function has been deprecated. PLease consider converting it to an object inheriting from \"BaseCycle\".", DeprecationWarning)
T = np.zeros((8))
h = np.zeros_like(T)
p = np.zeros_like(T)
s = np.zeros_like(T)
rho = np.zeros_like(T)
T[0] = np.NAN
s[0] = np.NAN
T[1] = Te + DTsh
pe = PropsSI('P', 'T', Te, 'Q', 1.0, Ref)
pc = PropsSI('P', 'T', Tc, 'Q', 1.0, Ref)
pic = PropsSI('P', 'T', Tsat_ic, 'Q', 1.0, Ref)
Tbubble_c = PropsSI('T', 'P', pc, 'Q', 0, Ref)
Tbubble_e = PropsSI('T', 'P', pe, 'Q', 0, Ref)
h[1] = PropsSI('H', 'T', T[1], 'P', pe, Ref)
s[1] = PropsSI('S', 'T', T[1], 'P', pe, Ref)
rho[1] = PropsSI('D', 'T', T[1], 'P', pe, Ref)
T[5] = Tbubble_c - DTsc
h[5] = PropsSI('H', 'T', T[5], 'P', pc, Ref)
s[5] = PropsSI('S', 'T', T[5], 'P', pc, Ref)
rho[5] = PropsSI('D', 'T', T[5], 'P', pc, Ref)
mdot = Q / (h[1] - h[5])
rho1 = PropsSI('D', 'T', T[1], 'P', pe, Ref)
h2s = PropsSI('H', 'S', s[1], 'P', pic, Ref)
Wdot1 = mdot * (h2s - h[1]) / eta_oi
h[2] = h[1] + (1 - f_p) * Wdot1 / mdot
T[2] = PropsSI('T', 'H', h[2], 'P', pic, Ref)
s[2] = PropsSI('S', 'T', T[2], 'P', pic, Ref)
rho[2] = PropsSI('D', 'T', T[2], 'P', pic, Ref)
T[3] = 288
p[3] = pic
h[3] = PropsSI('H', 'T', T[3], 'P', pic, Ref)
s[3] = PropsSI('S', 'T', T[3], 'P', pic, Ref)
rho[3] = PropsSI('D', 'T', T[3], 'P', pic, Ref)
rho3 = PropsSI('D', 'T', T[3], 'P', pic, Ref)
h4s = PropsSI('H', 'T', s[3], 'P', pc, Ref)
Wdot2 = mdot * (h4s - h[3]) / eta_oi
h[4] = h[3] + (1 - f_p) * Wdot2 / mdot
T[4] = PropsSI('T', 'H', h[4], 'P', pc, Ref)
s[4] = PropsSI('S', 'T', T[4], 'P', pc, Ref)
rho[4] = PropsSI('D', 'T', T[4], 'P', pc, Ref)
sbubble_e = PropsSI('S', 'T', Tbubble_e, 'Q', 0, Ref)
sbubble_c = PropsSI('S', 'T', Tbubble_c, 'Q', 0, Ref)
sdew_e = PropsSI('S', 'T', Te, 'Q', 1, Ref)
sdew_c = PropsSI('S', 'T', Tc, 'Q', 1, Ref)
hsatL = PropsSI('H', 'T', Tbubble_e, 'Q', 0, Ref)
hsatV = PropsSI('H', 'T', Te, 'Q', 1, Ref)
ssatL = PropsSI('S', 'T', Tbubble_e, 'Q', 0, Ref)
ssatV = PropsSI('S', 'T', Te, 'Q', 1, Ref)
vsatL = 1 / PropsSI('D', 'T', Tbubble_e, 'Q', 0, Ref)
vsatV = 1 / PropsSI('D', 'T', Te, 'Q', 1, Ref)
x = (h[5] - hsatL) / (hsatV - hsatL)
s[6] = x * ssatV + (1 - x) * ssatL
T[6] = x * Te + (1 - x) * Tbubble_e
rho[6] = 1.0 / (x * vsatV + (1 - x) * vsatL)
h[6] = h[5]
h[7] = h[1]
s[7] = s[1]
T[7] = T[1]
p = [np.nan, pe, pic, pic, pc, pc, pe, pe]
COP = Q / (Wdot1 + Wdot2)
RE = h[1] - h[6]
if prints == True:
print('x5:', x)
print('COP:', COP)
print('COPH', (Q + Wdot1 + Wdot2) / (Wdot1 + Wdot2))
print(T[2] - 273.15, T[4] - 273.15, p[2] / p[1], p[4] / p[3])
print(mdot, mdot * (h[4] - h[5]), pic)
print('Vdot1', mdot / rho1, 'Vdisp', mdot / rho1 / (3500 / 60.) * 1e6 / 0.7)
print('Vdot2', mdot / rho3, 'Vdisp', mdot / rho3 / (3500 / 60.) * 1e6 / 0.7)
print(mdot * (h[4] - h[5]), Tc - 273.15)
for i in range(1, len(T) - 1):
print('%d & %g & %g & %g & %g & %g \\\\' % (i, T[i] - 273.15, p[i], h[i], s[i], rho[i]))
else:
print(Tsat_ic, COP)
if skipPlot == False:
if axis == None:
ax = matplotlib.pyplot.gca()
else:
ax = axis
if Ts_Ph in ['ph', 'Ph']:
ax.plot(h, p)
elif Ts_Ph in ['Ts', 'ts']:
s_copy = s.copy()
T_copy = T.copy()
for i in range(1, len(s) - 1):
ax.plot(s[i], T[i], 'bo', mfc='b', mec='b')
dT = [0, -5, 5, -20, 5, 5, 5]
ds = [0, 0.05, 0, 0, 0, 0, 0]
ax.text(s[i] + ds[i], T[i] + dT[i], str(i))
s = list(s)
T = list(T)
s.insert(7, sdew_e)
T.insert(7, Te)
s.insert(5, sbubble_c)
T.insert(5, Tbubble_c)
s.insert(5, sdew_c)
T.insert(5, Tc)
ax.plot(s, T)
s = s_copy
T = T_copy
else:
raise TypeError('Type of Ts_Ph invalid')
return COP
def EconomizedCycle(Ref, Qin, Te, Tc, DTsh, DTsc, eta_oi, f_p, Ti, Ts_Ph='Ts', skipPlot=False, axis=None, **kwargs):
"""
This function plots an economized cycle, on the current axis, or that given by the optional parameter *axis*
Required parameters:
* Ref : Refrigerant [string]
* Qin : Cooling capacity [W]
* Te : Evap Temperature [K]
* Tc : Condensing Temperature [K]
* DTsh : Evaporator outlet superheat [K]
* DTsc : Condenser outlet subcooling [K]
* eta_oi : Adiabatic efficiency of compressor (no units) in range [0,1]
* f_p : fraction of compressor power lost as ambient heat transfer in range [0,1]
* Ti : Saturation temperature corresponding to intermediate pressure [K]
Optional parameters:
* Ts_Ph : 'Ts' for a Temperature-Entropy plot, 'Ph' for a Pressure-Enthalpy
* axis : An axis to use instead of the active axis
* skipPlot : If True, won't actually plot anything, just print COP
"""
warnings.warn("This function has been deprecated. Please consider converting it to an object inheriting from \"BaseCycle\".", DeprecationWarning)
from scipy.optimize import newton
m = 1
T = np.zeros((11))
h = np.zeros_like(T)
p = np.zeros_like(T)
s = np.zeros_like(T)
rho = np.zeros_like(T)
T[0] = np.NAN
s[0] = np.NAN
T[1] = Te + DTsh
pe = PropsSI('P', 'T', Te, 'Q', 1.0, Ref)
pc = PropsSI('P', 'T', Tc, 'Q', 1.0, Ref)
pi = PropsSI('P', 'T', Ti, 'Q', 1.0, Ref)
p[1] = pe
h[1] = PropsSI('H', 'T', T[1], 'P', pe, Ref)
s[1] = PropsSI('S', 'T', T[1], 'P', pe, Ref)
rho[1] = PropsSI('D', 'T', T[1], 'P', pe, Ref)
h2s = PropsSI('H', 'S', s[1], 'P', pi, Ref)
wdot1 = (h2s - h[1]) / eta_oi
h[2] = h[1] + (1 - f_p[0]) * wdot1
p[2] = pi
# T[2]=T_hp(Ref,h[2],pi,T2s)
T[2] = PropsSI('T', 'H', h[2], 'P', pi, Ref)
s[2] = PropsSI('S', 'T', T[2], 'P', pi, Ref)
rho[2] = PropsSI('D', 'T', T[2], 'P', pi, Ref)
T[5] = Tc - DTsc
h[5] = PropsSI('H', 'T', T[5], 'P', pc, Ref)
s[5] = PropsSI('S', 'T', T[5], 'P', pc, Ref)
rho[5] = PropsSI('D', 'T', T[5], 'P', pc, Ref)
p[5] = pc
p[6] = pi
h[6] = h[5]
p[7] = pi
p[8] = pi
p[6] = pi
T[7] = Ti
h[7] = PropsSI('H', 'T', Ti, 'Q', 1, Ref)
s[7] = PropsSI('S', 'T', Ti, 'Q', 1, Ref)
rho[7] = PropsSI('D', 'T', Ti, 'Q', 1, Ref)
T[8] = Ti
h[8] = PropsSI('H', 'T', Ti, 'Q', 0, Ref)
s[8] = PropsSI('S', 'T', Ti, 'Q', 0, Ref)
rho[8] = PropsSI('D', 'T', Ti, 'Q', 0, Ref)
x6 = (h[6] - h[8]) / (h[7] - h[8]) # Vapor Quality
s[6] = s[7] * x6 + s[8] * (1 - x6)
rho[6] = 1.0 / (x6 / rho[7] + (1 - x6) / rho[8])
T[6] = Ti
# Injection mass flow rate
x = m * (h[6] - h[8]) / (h[7] - h[6])
p[3] = pi
h[3] = (m * h[2] + x * h[7]) / (m + x)
# T[3]=T_hp(Ref,h[3],pi,T[2])
T[3] = PropsSI('T', 'H', h[3], 'P', pi, Ref)
s[3] = PropsSI('S', 'T', T[3], 'P', pi, Ref)
rho[3] = PropsSI('D', 'T', T[3], 'P', pi, Ref)
T4s = newton(lambda T: PropsSI('S', 'T', T, 'P', pc, Ref) - s[3], T[2] + 30)
h4s = PropsSI('H', 'T', T4s, 'P', pc, Ref)
p[4] = pc
wdot2 = (h4s - h[3]) / eta_oi
h[4] = h[3] + (1 - f_p[1]) * wdot2
# T[4]=T_hp(Ref,h[4],pc,T4s)
T[4] = PropsSI('T', 'H', h[4], 'P', pc, Ref)
s[4] = PropsSI('S', 'T', T[4], 'P', pc, Ref)
rho[4] = PropsSI('D', 'T', T[4], 'P', pc, Ref)
p[9] = pe
h[9] = h[8]
T[9] = Te
hsatL_e = PropsSI('H', 'T', Te, 'Q', 0, Ref)
hsatV_e = PropsSI('H', 'T', Te, 'Q', 1, Ref)
ssatL_e = PropsSI('S', 'T', Te, 'Q', 0, Ref)
ssatV_e = PropsSI('S', 'T', Te, 'Q', 1, Ref)
vsatL_e = 1 / PropsSI('D', 'T', Te, 'Q', 0, Ref)
vsatV_e = 1 / PropsSI('D', 'T', Te, 'Q', 1, Ref)
x9 = (h[9] - hsatL_e) / (hsatV_e - hsatL_e) # Vapor Quality
s[9] = ssatV_e * x9 + ssatL_e * (1 - x9)
rho[9] = 1.0 / (x9 * vsatV_e + (1 - x9) * vsatL_e)
s[10] = s[1]
T[10] = T[1]
h[10] = h[1]
p[10] = p[1]
Tbubble_e = Te
Tbubble_c = Tc
sbubble_e = PropsSI('S', 'T', Tbubble_e, 'Q', 0, Ref)
sbubble_c = PropsSI('S', 'T', Tbubble_c, 'Q', 0, Ref)
sdew_e = PropsSI('S', 'T', Te, 'Q', 1, Ref)
sdew_c = PropsSI('S', 'T', Tc, 'Q', 1, Ref)
Wdot1 = m * wdot1
Wdot2 = (m + x) * wdot2
if skipPlot == False:
if axis == None:
ax = matplotlib.pyplot.gca()
else:
ax = axis
if Ts_Ph in ['ph', 'Ph']:
ax.plot(h, p)
ax.set_yscale('log')
elif Ts_Ph in ['Ts', 'ts']:
ax.plot(np.r_[s[7], s[3]], np.r_[T[7], T[3]], 'b')
s_copy = s.copy()
T_copy = T.copy()
dT = [0, -5, 5, -12, 5, 12, -12, 0, 0, 0]
ds = [0, 0.05, 0.05, 0, 0.05, 0, 0.0, 0.05, -0.05, -0.05]
for i in range(1, len(s) - 1):
ax.plot(s[i], T[i], 'bo', mfc='b', mec='b')
ax.text(s[i] + ds[i], T[i] + dT[i], str(i), ha='center', va='center')
s = list(s)
T = list(T)
s.insert(10, sdew_e)
T.insert(10, Te)
s.insert(5, sbubble_c)
T.insert(5, Tbubble_c)
s.insert(5, sdew_c)
T.insert(5, Tc)
ax.plot(s, T, 'b')
s = s_copy
T = T_copy
else:
raise TypeError('Type of Ts_Ph invalid')
COP = m * (h[1] - h[9]) / (m * (h[2] - h[1]) + (m + x) * (h[4] - h[3]))
for i in range(1, len(T) - 1):
print('%d & %g & %g & %g & %g & %g \\\\' % (i, T[i] - 273.15, p[i], h[i], s[i], rho[i]))
print(x, m * (h[1] - h[9]), (m * (h[2] - h[1]) + (m + x) * (h[4] - h[3])), COP)
mdot = Qin / (h[1] - h[9])
mdot_inj = x * mdot
print('x9', x9,)
print('Qcond', (mdot + mdot_inj) * (h[4] - h[5]), 'T4', T[4] - 273.15)
print(mdot, mdot + mdot_inj)
f = 3500 / 60.
eta_v = 0.7
print('Vdisp1: ', mdot / (rho[1] * f * eta_v) * 1e6, 'cm^3')
print('Vdisp2: ', (mdot + mdot_inj) / (rho[1] * f * eta_v) * 1e6, 'cm^3')
return COP
# class SimpleCycle(object):
# """A class that calculates a simple thermodynamic cycle"""
# def __init__(self, *args, **kwargs):
# object.__init__(self, *args, **kwargs)
# (states, steps, fluid):
# Parameters
# ----------
# x_type : int, str
# Either a letter or an integer that specifies the property type for the x-axis
# y_type : int, str
# Either a letter or an integer that specifies the property type for the y-axis
# states : list
# A collection of state points that follows a fixed scheme defined
# in the implementing subclass.
# fluid_ref : str, CoolProp.AbstractState
# The fluid property provider, either a subclass of CoolProp.AbstractState
# or a string that can be used to generate a CoolProp.AbstractState instance
# via :func:`Common.process_fluid_state`.
# steps : int
# The number of steps used for going from one state to another
#
# for more properties, see :class:`CoolProp.Plots.Common.Base2DObject`.
# # See http://stackoverflow.com/questions/1061283/lt-instead-of-cmp
# class ComparableMixin:
# """A mixin class that implements all comparing mathods except for __lt__"""
# def __eq__(self, other):
# return not self<other and not other<self
# def __ne__(self, other):
# return self<other or other<self
# def __gt__(self, other):
# return other<self
# def __ge__(self, other):
# return not self<other
# def __le__(self, other):
# return not other<self
class StatePoint(PropertyDict):
"""A simple fixed dimension dict represented by an object with attributes"""
# Significant digits in SI units
ROUND_DECIMALS = {
CoolProp.iDmass: 5,
CoolProp.iHmass: 5,
CoolProp.iP: 2,
CoolProp.iSmass: 5,
CoolProp.iT: 5,
CoolProp.iUmass: 5,
CoolProp.iQ: 5
}
def __iter__(self):
"""Make sure we always iterate in the same order"""
keys = [CoolProp.iDmass, CoolProp.iHmass, CoolProp.iP, CoolProp.iSmass, CoolProp.iT]
for key in sorted(keys):
yield key
def __str__(self):
return str(self.__dict__)
def __prop_compare(self, other, typ):
# TODO
if self[typ] is None and other[typ] is None: return 0
elif self[typ] is None and other[typ] is not None: return -1
elif self[typ] is not None and other[typ] is None: return 1
else:
A = np.round(self[typ], self.ROUND_DECIMALS[typ])
B = np.round(other[typ], self.ROUND_DECIMALS[typ])
if A > B: return 1
elif A < B: return -1
elif A == B: return 0
else: raise ValueError("Comparison failed.")
def __eq__(self, other):
for i in self:
if not self.__prop_compare(other, i) == 0:
return False
return True
def __hash__(self):
return hash(repr(self))
class StateContainer(object):
"""A collection of values for the main properties, built to mixin with :class:`CoolProp.Plots.Common.PropertyDict`
Examples
--------
This container has overloaded accessor methods. Just pick your own flavour
or mix the styles as you like:
>>> from __future__ import print_function
>>> import CoolProp
>>> from CoolProp.Plots.SimpleCycles import StateContainer
>>> T0 = 300.000; p0 = 200000.000; h0 = 112745.749; s0 = 393.035
>>> cycle_states = StateContainer()
>>> cycle_states[0,'H'] = h0
>>> cycle_states[0]['S'] = s0
>>> cycle_states[0][CoolProp.iP] = p0
>>> cycle_states[0,CoolProp.iT] = T0
>>> cycle_states[1,"T"] = 300.064
>>> print(cycle_states)
Stored State Points:
state T (K) p (Pa) d (kg/m3) h (J/kg) s (J/kg/K)
0 300.000 200000.000 - 112745.749 393.035
1 300.064 - - - -
"""
def __init__(self, unit_system=SIunits()):
self._points = {}
self._units = unit_system
@property
def points(self): return self._points
@points.setter
def points(self, value): self._points = value
@property
def units(self): return self._units
@units.setter
def units(self, value): self._units = value
def get_point(self, index, SI=True):
if SI:
state = self[index]
else:
state = self[index]
for i in state:
state[i] = self.units[i].from_SI(state[i])
return state
def set_point(self, index, value, SI=True):
if SI:
self._points[index] = value
else:
for i in value:
self._points[index][i] = self.units[i].to_SI(value[i])
def _list_like(self, value):
"""Try to detect a list-like structure excluding strings"""
return (not hasattr(value, "strip") and
(hasattr(value, "__getitem__") or
hasattr(value, "__iter__")))
# return is_sequence(value) # use from pandas.core.common import is_sequence
def __len__(self):
"""Some cheating to get the correct behaviour"""
return len(self._points)
def __iter__(self):
"""Make sure we iterate in the righ order"""
for key in sorted(self._points):
yield key
def __getitem__(self, index):
"""Another tweak that changes the default access path"""
if self._list_like(index):
len_var = len(index)
if len_var == 0:
raise IndexError("Received empty index.")
elif len_var == 1:
return self._points[index[0]]
elif len_var == 2:
return self._points[index[0]][index[1]]
else:
raise IndexError("Received too long index.")
return self._points[index]
def __setitem__(self, index, value):
"""Another tweak that changes the default access path"""
if self._list_like(index):
len_var = len(index)
if len_var == 0:
raise IndexError("Received empty index.")
elif len_var == 1:
self._points[index[0]] = value
elif len_var == 2:
# safeguard against empty entries
if index[0] not in self._points:
self._points[index[0]] = StatePoint()
self._points[index[0]][index[1]] = value
else:
raise IndexError("Received too long index.")
else:
self._points[index] = value
def __str__(self):
out = "Stored State Points:\n"
keys = True
for i in self._points:
if keys:
row = [u"{0:>5s}".format("state")]
for j in self._points[i]:
label = u"{0:s} ({1:s})".format(self.units[j].symbol, self.units[j].unit)
row.append(u"{0:>11s}".format(label))
out = out + u" ".join(row) + "\n"
keys = False
row = [u"{0:>5s}".format(str(i))]
for j in self._points[i]:
try:
row.append(u"{0:11.3f}".format(self.units[j].from_SI(self._points[i][j])))
except:
row.append(u"{0:>11s}".format("-"))
out = out + u" ".join(row) + "\n"
return out
def append(self, new):
i = 0 + self.__len__()
for j in new:
self[i, j] = new[j]
return self
def extend(self, new):
i = 0 + self.__len__()
for j in new:
for k in new[j]:
self[i, k] = new[j][k]
i = i + 1
return self
@property
def D(self): return np.array([self._points[k].D for k in self])
@property
def H(self): return | np.array([self._points[k].H for k in self]) | numpy.array |
import numpy as np
import numexpr as ne
#numexpr-ized problem 2
#this one is blazing fast
def perona_malik_ne(u, lbda, sigma, reps):
#expects array of 32 bit floats
sinv = np.float32(1./sigma)
lbda32 = np.float32(lbda)
unew = u.copy()
#make some views of the same data as u
uN = u[:-1]
uS = u[1:]
uW = u[:,:-1]
uE = u[:,1:]
#make similar views for unew
uNnew = unew[:-1]
uSnew = unew[1:]
uWnew = unew[:,:-1]
uEnew = unew[:,1:]
temp = np.empty_like(u)
vtemp = temp[:-1]
htemp = temp[:,:-1]
for i in xrange(reps):
ne.evaluate('lbda32*exp(-(sinv*(uS-uN))**2)*(uS-uN)', out=vtemp)
ne.evaluate('uNnew+vtemp', out=uNnew)
ne.evaluate('uSnew-vtemp', out=uSnew)
ne.evaluate('lbda32*exp(-(sinv*(uE-uW))**2)*(uE-uW)', out=htemp)
ne.evaluate('uWnew+htemp', out=uWnew)
ne.evaluate('uEnew-htemp', out=uEnew)
u[:] = unew
#problem 2
#vanilla numpy version
#based on diferent views of the same data which
#are made by slicing the arrays involved.
#It is less straightforward, but much shorter.
#This one could probably be better optimized by
#pre-allocation of all needed temporary arrays.
def perona_malik(u, lbda, sigma, reps):
unew = u.copy()
#make some views of the same data as u
uN = u[:-1]
uS = u[1:]
uW = u[:,:-1]
uE = u[:,1:]
#make similar views for unew
uNnew = unew[:-1]
uSnew = unew[1:]
uWnew = unew[:,:-1]
uEnew = unew[:,1:]
temp = np.empty_like(u)
vtemp = temp[:-1]
htemp = temp[:,:-1]
difs = np.empty_like(u)
vdifs = difs[:-1]
hdifs = difs[:,:-1]
for i in xrange(reps):
vdifs[:] = uS - uN
vtemp[:] = vdifs / sigma
np.square(vtemp, out=vtemp)
vtemp *= -1
np.exp(vtemp, out=vtemp)
vtemp *= lbda
vtemp *= vdifs
uNnew += vtemp
uSnew -= vtemp
hdifs[:] = uE - uW
htemp[:] = hdifs / sigma
np.square(htemp, out=htemp)
htemp *= -1
np.exp(htemp, out=htemp)
htemp *= lbda
htemp *= hdifs
uWnew += htemp
uEnew -= htemp
u[:] = unew
#problem 3
#vanilla numpy version based on array views
def perona_malik_color(u, lbda, sigma, iters):
unew = u.copy()
#transposes are necessary so that broadcasting can work later.
uNT = u[:-1].T
uST = u[1:].T
uWT = u[:,:-1].T
uET = u[:,1:].T
uNnewT = unew[:-1].T
uSnewT = unew[1:].T
uWnewT = unew[:,:-1].T
uEnewT = unew[:,1:].T
vdifs = np.empty_like(uNT[0])
hdifs = np.empty_like(uWT[0])
temp = np.empty_like(u)
vtemp = temp[:-1].T
htemp = temp[:,:-1].T
temp2 = np.empty_like(temp)
vtemp2 = temp2[:-1].T
htemp2 = temp2[:,:-1].T
for n in xrange(iters):
#I lined the computations up in this way so as to
#avoid unnecessary memory allocation and deallocation
#as we go through the for loop.
vtemp[:] = uST - uNT
np.fabs(vtemp, out=vtemp2)
np.max(vtemp2, axis=0, out=vdifs)
vdifs /= sigma
np.square(vdifs, out=vdifs)
vdifs *= -1
np.exp(vdifs, out=vdifs)
vdifs *= lbda
vtemp *= vdifs #broadcasting across color dimension
uNnewT += vtemp
uSnewT -= vtemp
htemp[:] = uET-uWT
np.fabs(htemp, out=htemp2)
np.max(htemp2, axis=0, out=hdifs)
hdifs /= sigma
np.square(hdifs, out=hdifs)
hdifs *= -1
np.exp(hdifs, out=hdifs)
hdifs *= lbda
htemp *= hdifs #broadcasting across color dimension
uWnewT += htemp
uEnewT -= htemp
u[:] = unew
#problem 3
#using numexpr and array slices
def perona_malik_color_ne(u, lbda, sigma, iters):
sinv = np.float32(1./sigma)
lbda32 = np.float32(lbda)
unew = u.copy()
uNT = u[:-1].T
uST = u[1:].T
uWT = u[:,:-1].T
uET = u[:,1:].T
uNnewT = unew[:-1].T
uSnewT = unew[1:].T
uWnewT = unew[:,:-1].T
uEnewT = unew[:,1:].T
vdifs = np.empty_like(uNT[0])
hdifs = np.empty_like(uWT[0])
temp = np.empty_like(u)
vtemp = temp[:-1].T
htemp = temp[:,:-1].T
temp2 = np.empty_like(temp)
vtemp2 = temp2[:-1].T
htemp2 = temp2[:,:-1].T
for n in xrange(iters):
ne.evaluate('uST-uNT', out=vtemp)
ne.evaluate('abs(vtemp)', out=vtemp2)
np.max(vtemp2, axis=0, out=vdifs)
ne.evaluate('lbda32*exp(-(sinv*(vdifs))**2)', out=vdifs)
vtemp *= vdifs #broadcasting
ne.evaluate('uNnewT+vtemp', out=uNnewT)
ne.evaluate('uSnewT-vtemp', out=uSnewT)
ne.evaluate('uET-uWT', out=htemp)
ne.evaluate('abs(htemp)', out=htemp2)
np.max(htemp2, axis=0, out=hdifs)
ne.evaluate('lbda32*exp(-(sinv*(hdifs))**2)', out=hdifs)
htemp *= hdifs #broadcasting
ne.evaluate('uWnewT+htemp', out=uWnewT)
ne.evaluate('uEnewT-htemp', out=uEnewT)
u[:] = unew
#vanilla numpy version for problem 4
def min_bias_color(u, lbda, reps):
#this uses a good bit of excess memory...
#the approach is based on the approach I took with the
#optimized versions of problems 2 and 3 below
difs = np.empty_like(u)
uN = u[:-1]
uS = u[1:]
uW = u[:,:-1]
uE = u[:,1:]
uNW = u[:-1,:-1]
uNE = u[:-1,1:]
uSW = u[1:,:-1]
uSE = u[1:,1:]
Ndifs = difs[:-1]
Sdifs = difs[1:]
Wdifs = difs[:,:-1]
Edifs = difs[:,1:]
temp = np.empty_like(u)
#coefs is used to store the coefficients that we use
#to control how much diffusion we allow at each pixel
coefs = np.empty_like(temp[:,:,0])
vtemp = temp[:-1]
htemp = temp[:,:-1]
dtemp = temp[:-1,:-1]
vdifs = np.empty_like(vtemp[:,:,0])
hdifs = np.empty_like(htemp[:,:,0])
ldifs = np.empty_like(dtemp[:,:,0])
udifs = | np.empty_like(dtemp[:,:,0]) | numpy.empty_like |
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
import felis
from astropy.io import fits
import scipy.signal
import pdb
import matplotlib.pyplot as plt
import datetime
import pickle
import sys
import os
import numpy as np
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
def match_templates2specs(templates,spectra,speczs,picklename,wavewindow=[50.0],wavecen_restframe=[1908.0],
vshift=None,min_template_level=1e-4,plotdir=None,plot_allCCresults=False,
subtract_spec_median=True,overwrite=False,verbose=True):
"""
Wrapper around felis cross-correlation template matching, to match a list of spectra with a list of templtes.
--- INPUT ---
spectra fits spectra to find a (cross-correlation) match to template for
templates fits templates to correlate with
speczs Spectroscopic redshifts to perform cross-correlation in rest-frame (shifting the spectrum).
subtract_spec_median Subtract median value of spectrum (approximating the continuum level)
picklename Name of pickle file to store final cross-correlation results in
wavewindow Window (wavecen_restframe * (1+speczs) +/- wavewindow) to perform template matching over.
wavecen_restframe Central rest-frame wavelength of the region to match
vshift If a velcotiy shift is known, provide it here and it will be stored in output (not used)
min_template_level The template is interpolated to the wavelength grid of the spectrum and extrapolated
beyond it's edges if nescessary. In this extrapolation (assuming the template goes to ~0
at the edges), very small values (e.g., <1e-20) can be returned. To set these to 0.0
provide a level below which all values in the interpolated template are treated as 0s.
plotdir Directory to store plots to
plot_allCCresults To plot all the cross-correlation plots, set this to True
overwrite Overwrite existing pickle file if it already exists?
verbose Toggle verbosity
--- EXAMPLE OF USE ---
import felis
import glob
specdir = '/Users/kschmidt/work/MUSE/uvEmissionlineSearch/felis_testing/'
#specs = glob.glob(specdir+'uves_felis_mock_MUSEspectrum_noisesigma*3p0.fits')
specs = glob.glob(specdir+'uves_felis_mock_MUSEspectrum_noisesigma*.fits')
speczs = [3.5]*len(specs)
tempdir = '/Users/kschmidt/work/MUSE/uvEmissionlineSearch/felis_testing/'
#temps = glob.glob(specdir+'uves_felis_template_CIIIdoublet_sig_0p25_fluxCIII1_4p0_flux*.fits')
temps = glob.glob(specdir+'uves_felis_template_CIIIdoublet_*fits')
temps = glob.glob(specdir+'uves_felis_template_CIVdoublet_*fits')
plotdir = '/Users/kschmidt/work/MUSE/uvEmissionlineSearch/felis_testing/plots_CCresults180615/'
pickle = '/Users/kschmidt/work/MUSE/uvEmissionlineSearch/felis_testing/CCresults180615_RENAME_.pkl'
specs = ['/Volumes/DATABCKUP1/TDOSEextractions/171201_TDOSEextraction/Modelimg/tdose_spectra/tdose_spectrum_candels-cdfs-15_modelimg_0115003085-0115003085.fits']
speczs = [3.2585198879241943]
ccdic = felis.match_templates2specs(temps,specs,speczs,pickle,wavewindow=[60]*len(specs),plotdir=plotdir,wavecen_restframe=[1549.0]*len(specs))
--- OUTPUT ---
This wrapper will collect all the cross-correlation results in a main dictionary.
The dictionary will be returned directly but also saved to disk as a pickled filed.
This file can be loaded with: felis.load_picklefile(picklefilename)
The returned dictionary has the following format:
dictionary.keys() = the list of spectra that have been crossmatched (input = 'spectra')
Each entry in the dictionary (dictionary[key]) contains the following entries:
'wavelengths' : The wavelength vector used for the cross-correlation matching of
each of the N templates
'templatevec' : list of each of the N templates matched to spectrum
'zspec' : Spectroscopic redshift for spectrum
'zCCmaxvec' : the redshift corresponding to max S/N for each of the N templates matched
'ccresultsarray_flux' : fluc vectors for each of the N templates matched
'ccresultsarray_variance' : Variance vecotrs for each of the N templates matched
'ccresultsarr_S2N' : S/N vector for each of the N templates matched
'ccresultsarr_chi2' : chi squared values for the cross-correlation of each of the N templates matched
'ccresultsarr_Ngoodent' : The number of good pixels used in the cross correlation for each of
the N templates matched
'S2NCCmaxvec' : vector with max(S/N) values for N templates matched
'continuumlevel' : The 'continuum level' of the spectrum removed in the cross-correlation.
Currently the value is simply the median of the spectrum.
'vshift' : If a velocity shift was provided for the template match this is stored here
The picklefile can be used to assemble sub-sample results (e.g., S/N cuts) based on the
template cross-correlations with
felis.selection_from_picklefile()
And individual entries can be plotted using
felis.plot_picklefilecontent()
"""
ccresultdic = {}
if verbose: print(' - Starting cross-correlation of the '+str(len(spectra))+' spectra and '+
str(len(templates))+' templates')
startstring = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
if verbose: print(' '+startstring+'\n')
if len(spectra) == 0:
sys.exit(' No spectra provided')
if len(templates) == 0:
sys.exit(' No templates provided')
for ss, spec in enumerate(spectra):
# Nwave = pyfits.open(spec)[1].header['NAXIS2']
spec_namebase = spec.split('/')[-1].split('.fit')[0]
for tt, temp in enumerate(templates):
temp_namebase = temp.split('/')[-1].split('.fit')[0]
wavecenter = wavecen_restframe[ss] * (1.0 + speczs[ss])
waverange = [wavecenter-wavewindow[ss],wavecenter+wavewindow[ss]]
wave, ccresults, max_S2N, max_z, continuumlevel = \
felis.cross_correlate_template(spec,temp,z_restframe=speczs[ss],spec_median_sub=subtract_spec_median,
waverange=waverange,min_template_level=min_template_level,verbose=verbose)
if tt == 0:
ccresultsarr_flux = np.array(ccresults[:,0])
ccresultsarr_variance = ccresults[:,1]
ccresultsarr_S2N = ccresults[:,2]
ccresultsarr_chi2 = ccresults[:,3]
ccresultsarr_Ngoodent = ccresults[:,4]
templatevec = np.array([temp])
S2NCCmaxvec = np.array([max_S2N])
zCCmaxvec = np.array([max_z])
#print('-------------------------->'+str(np.max(ccresultsarr_S2N))+' '+str(max_S2N))
else:
ccresultsarr_flux = np.vstack((ccresultsarr_flux,ccresults[:,0]))
ccresultsarr_variance = np.vstack((ccresultsarr_variance,ccresults[:,1]))
ccresultsarr_S2N = np.vstack((ccresultsarr_S2N,ccresults[:,2]))
ccresultsarr_chi2 = np.vstack((ccresultsarr_chi2,ccresults[:,3]))
ccresultsarr_Ngoodent = np.vstack((ccresultsarr_Ngoodent,ccresults[:,4]))
templatevec = np.append(templatevec,temp)
S2NCCmaxvec = np.append(S2NCCmaxvec,max_S2N)
zCCmaxvec = | np.append(zCCmaxvec,max_z) | numpy.append |
import glob
import itertools
import math
import os
import typing
from collections import OrderedDict
import gym
import numpy as np
import yaml
from ray.rllib.env import MultiAgentEnv
from ray.tune.registry import register_env
if os.environ.get("USE_PY_NATIVERL"):
import pathmind_training.pynativerl as nativerl
else:
import nativerl
import pathmind_training.utils
from pathmind_training.pynativerl import Continuous
from pathmind_training.utils import get_class_from_string
OR_GYM_ENVS = [
"Knapsack-v0",
"Knapsack-v1",
"Knapsack-v2",
"Knapsack-v3",
"BinPacking-v0",
"Newsvendor-v0",
"VMPacking-v0",
"VMPacking-v1",
"VehicleRouting-v0",
"InvManagement-v0",
"InvManagement-v1",
"PortfolioOpt-v0",
"TSP-v0",
"TSP-v1",
]
def make_env(env_name):
if env_name in OR_GYM_ENVS:
import or_gym
return or_gym.make(env_name)
else:
return gym.make(env_name)
def get_gym_environment(environment_name: str):
if "." in environment_name: # a python module, like "cartpole.CartPoleEnv"
env_class = pathmind_training.utils.get_class_from_string(environment_name)
def env_creator(env_config):
return env_class()
env_name = env_class.__name__
else: # built-in gym envs retrieved by name, e.g. "CartPole-v0"
env_name = environment_name
try:
make_env(env_name)
except Exception:
raise Exception(
f"Could not find gym environment '{env_name}'. Make sure to check for typos."
)
def env_creator(env_config):
return make_env(env_name)
# Register the environment as string
register_env(env_name, env_creator)
return env_name, env_creator
def get_environment(
jar_dir: str,
environment_name: str,
is_multi_agent: bool = True,
max_memory_in_mb: int = 4096,
is_pathmind_simulation: bool = False,
obs_selection=None,
):
base_class = MultiAgentEnv if is_multi_agent else gym.Env
simple_name = environment_name.split(".")[-1]
class PathmindEnvironment(base_class):
def __init__(self, env_config):
# AnyLogic needs this to find its database
os.chdir(jar_dir)
# Put all JAR files found here in the class path
jars = glob.glob(jar_dir + "/**/*.jar", recursive=True)
# Initialize nativerl
nativerl.init(
[
"-Djava.class.path=" + os.pathsep.join(jars + [jar_dir]),
f"-Xmx{max_memory_in_mb}m",
]
)
# Instantiate the native environment, or mock it with pynativerl
if is_pathmind_simulation:
self.nativeEnv = get_native_env_from_simulation(
environment_name, obs_selection
)
else:
self.nativeEnv = nativerl.createEnvironment(environment_name)
self.action_space = self.define_action_space()
self.observation_space = self.define_observation_space()
self.id = simple_name
if not is_multi_agent:
self.unwrapped.spec = self
self.use_reward_terms = env_config["use_reward_terms"]
self.num_reward_terms = env_config["num_reward_terms"]
self.alphas = env_config["alphas"]
self.betas = np.ones(self.num_reward_terms)
self.term_contributions_dict = {}
self.term_contributions = np.zeros(self.num_reward_terms)
def define_action_space(self):
i = 0
action_space = self.nativeEnv.getActionSpace(i)
action_spaces = []
while action_space is not None:
if isinstance(action_space, nativerl.Discrete):
action_spaces += [
gym.spaces.Discrete(action_space.n)
for _ in range(action_space.size)
]
else: # Continuous spaces have "shape"
action_spaces += [
gym.spaces.Box(
0, 1, | np.array(action_space.shape) | numpy.array |
# Source:
# https://github.com/lucidrains/denoising-diffusion-pytorch/blob/master/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
import math
from functools import partial
from inspect import isfunction
from typing import List
import jax
import jax.numpy as jnp
import numpy as np
import pax
from einops import rearrange
from pax import GroupNorm, LayerNorm
def exists(x):
return x is not None
def default(val, d):
if exists(val):
return val
return d() if isfunction(d) else d
class Residual(pax.Module):
def __init__(self, fn):
super().__init__()
self.fn = fn
def __call__(self, x, *args, **kwargs):
return self.fn(x, *args, **kwargs) + x
class SinusoidalPosEmbed(pax.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def __call__(self, x):
half_dim = self.dim // 2
emb = math.log(10_000) / (half_dim - 1)
emb = jnp.exp(jnp.arange(0, half_dim) * (-emb))
emb = x[:, None] * emb[None, :]
emb = jnp.concatenate((jnp.sin(emb), jnp.cos(emb)), axis=-1)
return emb
class Mish(pax.Module):
def __call__(self, x):
return x * jnp.tanh(jax.nn.softplus(x))
class Upsample(pax.Module):
def __init__(self, dim):
super().__init__()
self.conv = pax.Conv2DTranspose(dim, dim, 4, 2, padding="SAME")
def __call__(self, x):
return self.conv(x)
class Downsample(pax.Module):
def __init__(self, dim):
super().__init__()
self.conv = pax.Conv2D(dim, dim, 3, 2, padding="SAME")
def __call__(self, x):
return self.conv(x)
class PreNorm(pax.Module):
def __init__(self, dim, fn):
super().__init__()
self.fn = fn
self.norm = LayerNorm(dim, -1, True, True)
def __call__(self, x):
x = self.norm(x)
return self.fn(x)
class Block(pax.Module):
def __init__(self, dim, dim_out, groups: int = 8):
super().__init__()
self.blocks = pax.Sequential(
pax.Conv2D(dim, dim_out, 3, padding="SAME"),
GroupNorm(groups, dim_out),
Mish(),
)
def __call__(self, x):
return self.blocks(x)
class ResnetBlock(pax.Module):
def __init__(self, dim, dim_out, *, time_emb_dim=None, groups=8):
super().__init__()
self.mlp = (
pax.Sequential(Mish(), pax.Linear(time_emb_dim, dim_out))
if exists(time_emb_dim)
else None
)
self.block1 = Block(dim, dim_out, groups=groups)
self.block2 = Block(dim_out, dim_out, groups=groups)
if dim != dim_out:
self.res_conv = pax.Conv2D(dim, dim_out, 1)
else:
self.res_conv = pax.Identity()
def __call__(self, x, time_emb):
h = self.block1(x)
if exists(self.mlp):
h = h + self.mlp(time_emb)[:, None, None, :]
h = self.block2(h)
return h + self.res_conv(x)
class LinearAttention(pax.Module):
def __init__(self, dim, heads=4, dim_head=32):
super().__init__()
self.heads = heads
hidden_dim = dim_head * heads
self.to_qkv = pax.Conv2D(dim, hidden_dim * 3, 1, with_bias=False)
self.to_out = pax.Conv2D(hidden_dim, dim, 1)
def __call__(self, x):
b, h, w, c = x.shape
qkv = self.to_qkv(x)
q, k, v = rearrange(
qkv, "b h w (qkv heads c) -> qkv b heads c (h w)", heads=self.heads, qkv=3
)
k = jax.nn.softmax(k, axis=-1)
context = jnp.einsum("bhdn,bhen->bhde", k, v)
out = jnp.einsum("bhde,bhdn->bhen", context, q)
out = rearrange(
out, "b heads c (h w) -> b h w (heads c)", heads=self.heads, h=h, w=w
)
return self.to_out(out)
### model
class UNet(pax.Module):
ups: List[List[pax.Module]]
downs: List[List[pax.Module]]
def __init__(
self,
dim,
out_dim=None,
dim_mults=(1, 2, 4, 8),
groups=8,
channels=3,
with_time_emb=True,
):
super().__init__()
self.channels = channels
dims = [channels] + [dim * m for m in dim_mults]
in_out = list(zip(dims[:-1], dims[1:]))
if with_time_emb:
time_dim = dim
self.time_mlp = pax.Sequential(
SinusoidalPosEmbed(dim),
pax.Linear(dim, dim * 4),
Mish(),
pax.Linear(dim * 4, dim),
)
else:
time_dim = None
self.time_mlp = None
self.downs = []
self.ups = []
num_resolutions = len(in_out)
for ind, (dim_in, dim_out) in enumerate(in_out):
is_last = ind >= (num_resolutions - 1)
self.downs.append(
[
ResnetBlock(dim_in, dim_out, time_emb_dim=time_dim, groups=groups),
ResnetBlock(dim_out, dim_out, time_emb_dim=time_dim, groups=groups),
Residual(PreNorm(dim_out, LinearAttention(dim_out))),
Downsample(dim_out) if not is_last else pax.Identity(),
]
)
mid_dim = dims[-1]
self.mid_block1 = ResnetBlock(
mid_dim, mid_dim, time_emb_dim=time_dim, groups=groups
)
self.mid_attn = Residual(PreNorm(mid_dim, LinearAttention(mid_dim)))
self.mid_block2 = ResnetBlock(
mid_dim, mid_dim, time_emb_dim=time_dim, groups=groups
)
for ind, (dim_in, dim_out) in enumerate(reversed(in_out[1:])):
is_last = ind >= (num_resolutions - 1)
self.ups.append(
[
ResnetBlock(
dim_out * 2, dim_in, time_emb_dim=time_dim, groups=groups
),
ResnetBlock(dim_in, dim_in, time_emb_dim=time_dim, groups=groups),
Residual(PreNorm(dim_in, LinearAttention(dim_in))),
Upsample(dim_in) if not is_last else pax.Identity(),
]
)
out_dim = default(out_dim, channels)
self.final_conv = pax.Sequential(
Block(dim, dim, groups=groups),
pax.Conv2D(dim, out_dim, 1),
)
def __call__(self, x, time):
t = self.time_mlp(time) if exists(self.time_mlp) else None
h = []
for resnet, resnet2, attn, downsample in self.downs:
x = resnet(x, t)
x = resnet2(x, t)
x = attn(x)
h.append(x)
x = downsample(x)
x = self.mid_block1(x, t)
x = self.mid_attn(x)
x = self.mid_block2(x, t)
for resnet, resnet2, attn, upsample in self.ups:
x = jnp.concatenate((x, h.pop()), axis=-1)
x = resnet(x, t)
x = resnet2(x, t)
x = attn(x)
x = upsample(x)
return self.final_conv(x)
def extract(a, t, x_shape):
b, *_ = t.shape
out = jnp.take_along_axis(a, t, axis=-1)
out = jnp.reshape(out, (b,) + (1,) * (len(x_shape) - 1))
return out
def noise_like(rng_key, shape, repeat=False):
repeat_noise = lambda: jnp.tile(
jax.random.normal(rng_key, (1, *shape[1:])),
(shape[0],) + (1,) * (len(shape) - 1),
)
noise = lambda: jax.random.normal(rng_key, shape)
return repeat_noise() if repeat else noise()
def cosine_beta_schedule(timesteps, s=0.008):
"""
cosine schedule
as proposed in https://openreview.net/forum?id=-NEXDKk8gZ
"""
steps = timesteps + 1
x = np.linspace(0, steps, steps)
alphas_cumprod = np.cos(((x / steps) + s) / (1 + s) * np.pi * 0.5) ** 2
alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
return np.clip(betas, a_min=0, a_max=0.999)
class GaussianDiffusion(pax.Module):
def __init__(
self,
denoise_fn,
*,
image_size,
channels=3,
timesteps=1000,
loss_type="l1",
betas=None,
random_seed=42,
):
super().__init__()
self.channels = channels
self.image_size = image_size
self.denoise_fn = denoise_fn
self.rng_seq = pax.RngSeq(random_seed)
if exists(betas):
betas = jnp.array(betas)
else:
betas = cosine_beta_schedule(timesteps)
alphas = 1.0 - betas
alphas_cumprod = np.cumprod(alphas, axis=0)
alphas_cumprod_prev = | np.append(1.0, alphas_cumprod[:-1]) | numpy.append |
from __future__ import division
from itertools import product
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import pytest
from .. import relational as rel
from ..palettes import color_palette
from ..utils import categorical_order, sort_df
class TestRelationalPlotter(object):
def scatter_rgbs(self, collections):
rgbs = []
for col in collections:
rgb = tuple(col.get_facecolor().squeeze()[:3])
rgbs.append(rgb)
return rgbs
def colors_equal(self, *args):
equal = True
for c1, c2 in zip(*args):
c1 = mpl.colors.colorConverter.to_rgb(np.squeeze(c1))
c2 = mpl.colors.colorConverter.to_rgb(np.squeeze(c1))
equal &= c1 == c2
return equal
def paths_equal(self, *args):
equal = True
for p1, p2 in zip(*args):
equal &= np.array_equal(p1.vertices, p2.vertices)
equal &= np.array_equal(p1.codes, p2.codes)
return equal
@pytest.fixture
def wide_df(self):
columns = list("abc")
index = pd.Int64Index(np.arange(10, 50, 2), name="wide_index")
values = np.random.randn(len(index), len(columns))
return pd.DataFrame(values, index=index, columns=columns)
@pytest.fixture
def wide_array(self):
return np.random.randn(20, 3)
@pytest.fixture
def flat_array(self):
return np.random.randn(20)
@pytest.fixture
def flat_series(self):
index = pd.Int64Index(np.arange(10, 30), name="t")
return pd.Series(np.random.randn(20), index, name="s")
@pytest.fixture
def wide_list(self):
return [np.random.randn(20), np.random.randn(10)]
@pytest.fixture
def wide_list_of_series(self):
return [pd.Series(np.random.randn(20), np.arange(20), name="a"),
pd.Series(np.random.randn(10), np.arange(5, 15), name="b")]
@pytest.fixture
def long_df(self):
n = 100
rs = np.random.RandomState()
df = pd.DataFrame(dict(
x=rs.randint(0, 20, n),
y=rs.randn(n),
a=np.take(list("abc"), rs.randint(0, 3, n)),
b=np.take(list("mnop"), rs.randint(0, 4, n)),
c=np.take(list([0, 1]), rs.randint(0, 2, n)),
d=np.repeat(np.datetime64('2005-02-25'), n),
s=np.take([2, 4, 8], rs.randint(0, 3, n)),
f=np.take(list([0.2, 0.3]), rs.randint(0, 2, n)),
))
df["s_cat"] = df["s"].astype("category")
return df
@pytest.fixture
def repeated_df(self):
n = 100
rs = np.random.RandomState()
return pd.DataFrame(dict(
x=np.tile(np.arange(n // 2), 2),
y=rs.randn(n),
a=np.take(list("abc"), rs.randint(0, 3, n)),
u=np.repeat(np.arange(2), n // 2),
))
@pytest.fixture
def missing_df(self):
n = 100
rs = np.random.RandomState()
df = pd.DataFrame(dict(
x=rs.randint(0, 20, n),
y=rs.randn(n),
a=np.take(list("abc"), rs.randint(0, 3, n)),
b=np.take(list("mnop"), rs.randint(0, 4, n)),
s=np.take([2, 4, 8], rs.randint(0, 3, n)),
))
for col in df:
idx = rs.permutation(df.index)[:10]
df.loc[idx, col] = np.nan
return df
@pytest.fixture
def null_column(self):
return pd.Series(index=np.arange(20))
def test_wide_df_variables(self, wide_df):
p = rel._RelationalPlotter()
p.establish_variables(data=wide_df)
assert p.input_format == "wide"
assert p.semantics == ["x", "y", "hue", "style"]
assert len(p.plot_data) == np.product(wide_df.shape)
x = p.plot_data["x"]
expected_x = np.tile(wide_df.index, wide_df.shape[1])
assert np.array_equal(x, expected_x)
y = p.plot_data["y"]
expected_y = wide_df.values.ravel(order="f")
assert np.array_equal(y, expected_y)
hue = p.plot_data["hue"]
expected_hue = np.repeat(wide_df.columns.values, wide_df.shape[0])
assert np.array_equal(hue, expected_hue)
style = p.plot_data["style"]
expected_style = expected_hue
assert np.array_equal(style, expected_style)
assert p.plot_data["size"].isnull().all()
assert p.x_label == wide_df.index.name
assert p.y_label is None
assert p.hue_label == wide_df.columns.name
assert p.size_label is None
assert p.style_label == wide_df.columns.name
def test_wide_df_variables_check(self, wide_df):
p = rel._RelationalPlotter()
wide_df = wide_df.copy()
wide_df.loc[:, "not_numeric"] = "a"
with pytest.raises(ValueError):
p.establish_variables(data=wide_df)
def test_wide_array_variables(self, wide_array):
p = rel._RelationalPlotter()
p.establish_variables(data=wide_array)
assert p.input_format == "wide"
assert p.semantics == ["x", "y", "hue", "style"]
assert len(p.plot_data) == np.product(wide_array.shape)
nrow, ncol = wide_array.shape
x = p.plot_data["x"]
expected_x = np.tile(np.arange(nrow), ncol)
assert np.array_equal(x, expected_x)
y = p.plot_data["y"]
expected_y = wide_array.ravel(order="f")
assert np.array_equal(y, expected_y)
hue = p.plot_data["hue"]
expected_hue = np.repeat(np.arange(ncol), nrow)
assert np.array_equal(hue, expected_hue)
style = p.plot_data["style"]
expected_style = expected_hue
assert np.array_equal(style, expected_style)
assert p.plot_data["size"].isnull().all()
assert p.x_label is None
assert p.y_label is None
assert p.hue_label is None
assert p.size_label is None
assert p.style_label is None
def test_flat_array_variables(self, flat_array):
p = rel._RelationalPlotter()
p.establish_variables(data=flat_array)
assert p.input_format == "wide"
assert p.semantics == ["x", "y"]
assert len(p.plot_data) == np.product(flat_array.shape)
x = p.plot_data["x"]
expected_x = np.arange(flat_array.shape[0])
assert np.array_equal(x, expected_x)
y = p.plot_data["y"]
expected_y = flat_array
assert np.array_equal(y, expected_y)
assert p.plot_data["hue"].isnull().all()
assert p.plot_data["style"].isnull().all()
assert p.plot_data["size"].isnull().all()
assert p.x_label is None
assert p.y_label is None
assert p.hue_label is None
assert p.size_label is None
assert p.style_label is None
def test_flat_series_variables(self, flat_series):
p = rel._RelationalPlotter()
p.establish_variables(data=flat_series)
assert p.input_format == "wide"
assert p.semantics == ["x", "y"]
assert len(p.plot_data) == len(flat_series)
x = p.plot_data["x"]
expected_x = flat_series.index
assert np.array_equal(x, expected_x)
y = p.plot_data["y"]
expected_y = flat_series
assert np.array_equal(y, expected_y)
assert p.x_label is None
assert p.y_label is None
assert p.hue_label is None
assert p.size_label is None
assert p.style_label is None
def test_wide_list_variables(self, wide_list):
p = rel._RelationalPlotter()
p.establish_variables(data=wide_list)
assert p.input_format == "wide"
assert p.semantics == ["x", "y", "hue", "style"]
assert len(p.plot_data) == sum(len(l) for l in wide_list)
x = p.plot_data["x"]
expected_x = np.concatenate([np.arange(len(l)) for l in wide_list])
assert np.array_equal(x, expected_x)
y = p.plot_data["y"]
expected_y = np.concatenate(wide_list)
assert np.array_equal(y, expected_y)
hue = p.plot_data["hue"]
expected_hue = np.concatenate([
np.ones_like(l) * i for i, l in enumerate(wide_list)
])
assert np.array_equal(hue, expected_hue)
style = p.plot_data["style"]
expected_style = expected_hue
assert np.array_equal(style, expected_style)
assert p.plot_data["size"].isnull().all()
assert p.x_label is None
assert p.y_label is None
assert p.hue_label is None
assert p.size_label is None
assert p.style_label is None
def test_wide_list_of_series_variables(self, wide_list_of_series):
p = rel._RelationalPlotter()
p.establish_variables(data=wide_list_of_series)
assert p.input_format == "wide"
assert p.semantics == ["x", "y", "hue", "style"]
assert len(p.plot_data) == sum(len(l) for l in wide_list_of_series)
x = p.plot_data["x"]
expected_x = np.concatenate([s.index for s in wide_list_of_series])
assert np.array_equal(x, expected_x)
y = p.plot_data["y"]
expected_y = np.concatenate(wide_list_of_series)
assert np.array_equal(y, expected_y)
hue = p.plot_data["hue"]
expected_hue = np.concatenate([
np.full(len(s), s.name, object) for s in wide_list_of_series
])
assert np.array_equal(hue, expected_hue)
style = p.plot_data["style"]
expected_style = expected_hue
assert np.array_equal(style, expected_style)
assert p.plot_data["size"].isnull().all()
assert p.x_label is None
assert p.y_label is None
assert p.hue_label is None
assert p.size_label is None
assert p.style_label is None
def test_long_df(self, long_df):
p = rel._RelationalPlotter()
p.establish_variables(x="x", y="y", data=long_df)
assert p.input_format == "long"
assert p.semantics == ["x", "y"]
assert np.array_equal(p.plot_data["x"], long_df["x"])
assert np.array_equal(p.plot_data["y"], long_df["y"])
for col in ["hue", "style", "size"]:
assert p.plot_data[col].isnull().all()
assert (p.x_label, p.y_label) == ("x", "y")
assert p.hue_label is None
assert p.size_label is None
assert p.style_label is None
p.establish_variables(x=long_df.x, y="y", data=long_df)
assert p.semantics == ["x", "y"]
assert np.array_equal(p.plot_data["x"], long_df["x"])
assert np.array_equal(p.plot_data["y"], long_df["y"])
assert (p.x_label, p.y_label) == ("x", "y")
p.establish_variables(x="x", y=long_df.y, data=long_df)
assert p.semantics == ["x", "y"]
assert np.array_equal(p.plot_data["x"], long_df["x"])
assert np.array_equal(p.plot_data["y"], long_df["y"])
assert (p.x_label, p.y_label) == ("x", "y")
p.establish_variables(x="x", y="y", hue="a", data=long_df)
assert p.semantics == ["x", "y", "hue"]
assert np.array_equal(p.plot_data["hue"], long_df["a"])
for col in ["style", "size"]:
assert p.plot_data[col].isnull().all()
assert p.hue_label == "a"
assert p.size_label is None and p.style_label is None
p.establish_variables(x="x", y="y", hue="a", style="a", data=long_df)
assert p.semantics == ["x", "y", "hue", "style"]
assert np.array_equal(p.plot_data["hue"], long_df["a"])
assert np.array_equal(p.plot_data["style"], long_df["a"])
assert p.plot_data["size"].isnull().all()
assert p.hue_label == p.style_label == "a"
assert p.size_label is None
p.establish_variables(x="x", y="y", hue="a", style="b", data=long_df)
assert p.semantics == ["x", "y", "hue", "style"]
assert np.array_equal(p.plot_data["hue"], long_df["a"])
assert np.array_equal(p.plot_data["style"], long_df["b"])
assert p.plot_data["size"].isnull().all()
p.establish_variables(x="x", y="y", size="y", data=long_df)
assert p.semantics == ["x", "y", "size"]
assert np.array_equal(p.plot_data["size"], long_df["y"])
assert p.size_label == "y"
assert p.hue_label is None and p.style_label is None
def test_bad_input(self, long_df):
p = rel._RelationalPlotter()
with pytest.raises(ValueError):
p.establish_variables(x=long_df.x)
with pytest.raises(ValueError):
p.establish_variables(y=long_df.y)
with pytest.raises(ValueError):
p.establish_variables(x="not_in_df", data=long_df)
with pytest.raises(ValueError):
p.establish_variables(x="x", y="not_in_df", data=long_df)
with pytest.raises(ValueError):
p.establish_variables(x="x", y="not_in_df", data=long_df)
def test_empty_input(self):
p = rel._RelationalPlotter()
p.establish_variables(data=[])
p.establish_variables(data=np.array([]))
p.establish_variables(data=pd.DataFrame())
p.establish_variables(x=[], y=[])
def test_units(self, repeated_df):
p = rel._RelationalPlotter()
p.establish_variables(x="x", y="y", units="u", data=repeated_df)
assert np.array_equal(p.plot_data["units"], repeated_df["u"])
def test_parse_hue_null(self, wide_df, null_column):
p = rel._LinePlotter(data=wide_df)
p.parse_hue(null_column, "Blues", None, None)
assert p.hue_levels == [None]
assert p.palette == {}
assert p.hue_type is None
assert p.cmap is None
def test_parse_hue_categorical(self, wide_df, long_df):
p = rel._LinePlotter(data=wide_df)
assert p.hue_levels == wide_df.columns.tolist()
assert p.hue_type == "categorical"
assert p.cmap is None
# Test named palette
palette = "Blues"
expected_colors = color_palette(palette, wide_df.shape[1])
expected_palette = dict(zip(wide_df.columns, expected_colors))
p.parse_hue(p.plot_data.hue, palette, None, None)
assert p.palette == expected_palette
# Test list palette
palette = color_palette("Reds", wide_df.shape[1])
p.parse_hue(p.plot_data.hue, palette, None, None)
expected_palette = dict(zip(wide_df.columns, palette))
assert p.palette == expected_palette
# Test dict palette
colors = color_palette("Set1", 8)
palette = dict(zip(wide_df.columns, colors))
p.parse_hue(p.plot_data.hue, palette, None, None)
assert p.palette == palette
# Test dict with missing keys
palette = dict(zip(wide_df.columns[:-1], colors))
with pytest.raises(ValueError):
p.parse_hue(p.plot_data.hue, palette, None, None)
# Test list with wrong number of colors
palette = colors[:-1]
with pytest.raises(ValueError):
p.parse_hue(p.plot_data.hue, palette, None, None)
# Test hue order
hue_order = ["a", "c", "d"]
p.parse_hue(p.plot_data.hue, None, hue_order, None)
assert p.hue_levels == hue_order
# Test long data
p = rel._LinePlotter(x="x", y="y", hue="a", data=long_df)
assert p.hue_levels == categorical_order(long_df.a)
assert p.hue_type == "categorical"
assert p.cmap is None
# Test default palette
p.parse_hue(p.plot_data.hue, None, None, None)
hue_levels = categorical_order(long_df.a)
expected_colors = color_palette(n_colors=len(hue_levels))
expected_palette = dict(zip(hue_levels, expected_colors))
assert p.palette == expected_palette
# Test default palette with many levels
levels = pd.Series(list("abcdefghijklmnopqrstuvwxyz"))
p.parse_hue(levels, None, None, None)
expected_colors = color_palette("husl", n_colors=len(levels))
expected_palette = dict(zip(levels, expected_colors))
assert p.palette == expected_palette
# Test binary data
p = rel._LinePlotter(x="x", y="y", hue="c", data=long_df)
assert p.hue_levels == [0, 1]
assert p.hue_type == "categorical"
df = long_df[long_df["c"] == 0]
p = rel._LinePlotter(x="x", y="y", hue="c", data=df)
assert p.hue_levels == [0]
assert p.hue_type == "categorical"
df = long_df[long_df["c"] == 1]
p = rel._LinePlotter(x="x", y="y", hue="c", data=df)
assert p.hue_levels == [1]
assert p.hue_type == "categorical"
# Test Timestamp data
p = rel._LinePlotter(x="x", y="y", hue="d", data=long_df)
assert p.hue_levels == [pd.Timestamp('2005-02-25')]
assert p.hue_type == "categorical"
# Test numeric data with category type
p = rel._LinePlotter(x="x", y="y", hue="s_cat", data=long_df)
assert p.hue_levels == categorical_order(long_df.s_cat)
assert p.hue_type == "categorical"
assert p.cmap is None
# Test categorical palette specified for numeric data
palette = "deep"
p = rel._LinePlotter(x="x", y="y", hue="s",
palette=palette, data=long_df)
expected_colors = color_palette(palette, n_colors=len(levels))
hue_levels = categorical_order(long_df["s"])
expected_palette = dict(zip(hue_levels, expected_colors))
assert p.palette == expected_palette
assert p.hue_type == "categorical"
def test_parse_hue_numeric(self, long_df):
p = rel._LinePlotter(x="x", y="y", hue="s", data=long_df)
hue_levels = list(np.sort(long_df.s.unique()))
assert p.hue_levels == hue_levels
assert p.hue_type == "numeric"
assert p.cmap.name == "seaborn_cubehelix"
# Test named colormap
palette = "Purples"
p.parse_hue(p.plot_data.hue, palette, None, None)
assert p.cmap is mpl.cm.get_cmap(palette)
# Test colormap object
palette = mpl.cm.get_cmap("Greens")
p.parse_hue(p.plot_data.hue, palette, None, None)
assert p.cmap is palette
# Test cubehelix shorthand
palette = "ch:2,0,light=.2"
p.parse_hue(p.plot_data.hue, palette, None, None)
assert isinstance(p.cmap, mpl.colors.ListedColormap)
# Test default hue limits
p.parse_hue(p.plot_data.hue, None, None, None)
assert p.hue_limits == (p.plot_data.hue.min(), p.plot_data.hue.max())
# Test specified hue limits
hue_norm = 1, 4
p.parse_hue(p.plot_data.hue, None, None, hue_norm)
assert p.hue_limits == hue_norm
assert isinstance(p.hue_norm, mpl.colors.Normalize)
assert p.hue_norm.vmin == hue_norm[0]
assert p.hue_norm.vmax == hue_norm[1]
# Test Normalize object
hue_norm = mpl.colors.PowerNorm(2, vmin=1, vmax=10)
p.parse_hue(p.plot_data.hue, None, None, hue_norm)
assert p.hue_limits == (hue_norm.vmin, hue_norm.vmax)
assert p.hue_norm is hue_norm
# Test default colormap values
hmin, hmax = p.plot_data.hue.min(), p.plot_data.hue.max()
p.parse_hue(p.plot_data.hue, None, None, None)
assert p.palette[hmin] == pytest.approx(p.cmap(0.0))
assert p.palette[hmax] == pytest.approx(p.cmap(1.0))
# Test specified colormap values
hue_norm = hmin - 1, hmax - 1
p.parse_hue(p.plot_data.hue, None, None, hue_norm)
norm_min = (hmin - hue_norm[0]) / (hue_norm[1] - hue_norm[0])
assert p.palette[hmin] == pytest.approx(p.cmap(norm_min))
assert p.palette[hmax] == pytest.approx(p.cmap(1.0))
# Test list of colors
hue_levels = list(np.sort(long_df.s.unique()))
palette = color_palette("Blues", len(hue_levels))
p.parse_hue(p.plot_data.hue, palette, None, None)
assert p.palette == dict(zip(hue_levels, palette))
palette = color_palette("Blues", len(hue_levels) + 1)
with pytest.raises(ValueError):
p.parse_hue(p.plot_data.hue, palette, None, None)
# Test dictionary of colors
palette = dict(zip(hue_levels, color_palette("Reds")))
p.parse_hue(p.plot_data.hue, palette, None, None)
assert p.palette == palette
palette.pop(hue_levels[0])
with pytest.raises(ValueError):
p.parse_hue(p.plot_data.hue, palette, None, None)
# Test invalid palette
palette = "not_a_valid_palette"
with pytest.raises(ValueError):
p.parse_hue(p.plot_data.hue, palette, None, None)
# Test bad norm argument
hue_norm = "not a norm"
with pytest.raises(ValueError):
p.parse_hue(p.plot_data.hue, None, None, hue_norm)
def test_parse_size(self, long_df):
p = rel._LinePlotter(x="x", y="y", size="s", data=long_df)
# Test default size limits and range
default_linewidth = mpl.rcParams["lines.linewidth"]
default_limits = p.plot_data["size"].min(), p.plot_data["size"].max()
default_range = .5 * default_linewidth, 2 * default_linewidth
p.parse_size(p.plot_data["size"], None, None, None)
assert p.size_limits == default_limits
size_range = min(p.sizes.values()), max(p.sizes.values())
assert size_range == default_range
# Test specified size limits
size_limits = (1, 5)
p.parse_size(p.plot_data["size"], None, None, size_limits)
assert p.size_limits == size_limits
# Test specified size range
sizes = (.1, .5)
p.parse_size(p.plot_data["size"], sizes, None, None)
assert p.size_limits == default_limits
# Test size values with normalization range
sizes = (1, 5)
size_norm = (1, 10)
p.parse_size(p.plot_data["size"], sizes, None, size_norm)
normalize = mpl.colors.Normalize(*size_norm, clip=True)
for level, width in p.sizes.items():
assert width == sizes[0] + (sizes[1] - sizes[0]) * normalize(level)
# Test size values with normalization object
sizes = (1, 5)
size_norm = mpl.colors.LogNorm(1, 10, clip=False)
p.parse_size(p.plot_data["size"], sizes, None, size_norm)
assert p.size_norm.clip
for level, width in p.sizes.items():
assert width == sizes[0] + (sizes[1] - sizes[0]) * size_norm(level)
# Test specified size order
var = "a"
levels = long_df[var].unique()
sizes = [1, 4, 6]
size_order = [levels[1], levels[2], levels[0]]
p = rel._LinePlotter(x="x", y="y", size=var, data=long_df)
p.parse_size(p.plot_data["size"], sizes, size_order, None)
assert p.sizes == dict(zip(size_order, sizes))
# Test list of sizes
var = "a"
levels = categorical_order(long_df[var])
sizes = list(np.random.rand(len(levels)))
p = rel._LinePlotter(x="x", y="y", size=var, data=long_df)
p.parse_size(p.plot_data["size"], sizes, None, None)
assert p.sizes == dict(zip(levels, sizes))
# Test dict of sizes
var = "a"
levels = categorical_order(long_df[var])
sizes = dict(zip(levels, np.random.rand(len(levels))))
p = rel._LinePlotter(x="x", y="y", size=var, data=long_df)
p.parse_size(p.plot_data["size"], sizes, None, None)
assert p.sizes == sizes
# Test sizes list with wrong length
sizes = list(np.random.rand(len(levels) + 1))
with pytest.raises(ValueError):
p.parse_size(p.plot_data["size"], sizes, None, None)
# Test sizes dict with missing levels
sizes = dict(zip(levels, np.random.rand(len(levels) - 1)))
with pytest.raises(ValueError):
p.parse_size(p.plot_data["size"], sizes, None, None)
# Test bad sizes argument
sizes = "bad_size"
with pytest.raises(ValueError):
p.parse_size(p.plot_data["size"], sizes, None, None)
# Test bad norm argument
size_norm = "not a norm"
p = rel._LinePlotter(x="x", y="y", size="s", data=long_df)
with pytest.raises(ValueError):
p.parse_size(p.plot_data["size"], None, None, size_norm)
def test_parse_style(self, long_df):
p = rel._LinePlotter(x="x", y="y", style="a", data=long_df)
# Test defaults
markers, dashes = True, True
p.parse_style(p.plot_data["style"], markers, dashes, None)
assert p.markers == dict(zip(p.style_levels, p.default_markers))
assert p.dashes == dict(zip(p.style_levels, p.default_dashes))
# Test lists
markers, dashes = ["o", "s", "d"], [(1, 0), (1, 1), (2, 1, 3, 1)]
p.parse_style(p.plot_data["style"], markers, dashes, None)
assert p.markers == dict(zip(p.style_levels, markers))
assert p.dashes == dict(zip(p.style_levels, dashes))
# Test dicts
markers = dict(zip(p.style_levels, markers))
dashes = dict(zip(p.style_levels, dashes))
p.parse_style(p.plot_data["style"], markers, dashes, None)
assert p.markers == markers
assert p.dashes == dashes
# Test style order with defaults
style_order = np.take(p.style_levels, [1, 2, 0])
markers = dashes = True
p.parse_style(p.plot_data["style"], markers, dashes, style_order)
assert p.markers == dict(zip(style_order, p.default_markers))
assert p.dashes == dict(zip(style_order, p.default_dashes))
# Test too many levels with style lists
markers, dashes = ["o", "s"], False
with pytest.raises(ValueError):
p.parse_style(p.plot_data["style"], markers, dashes, None)
markers, dashes = False, [(2, 1)]
with pytest.raises(ValueError):
p.parse_style(p.plot_data["style"], markers, dashes, None)
# Test too many levels with style dicts
markers, dashes = {"a": "o", "b": "s"}, False
with pytest.raises(ValueError):
p.parse_style(p.plot_data["style"], markers, dashes, None)
markers, dashes = False, {"a": (1, 0), "b": (2, 1)}
with pytest.raises(ValueError):
p.parse_style(p.plot_data["style"], markers, dashes, None)
# Test mixture of filled and unfilled markers
markers, dashes = ["o", "x", "s"], None
with pytest.raises(ValueError):
p.parse_style(p.plot_data["style"], markers, dashes, None)
def test_subset_data_quantities(self, long_df):
p = rel._LinePlotter(x="x", y="y", data=long_df)
assert len(list(p.subset_data())) == 1
# --
var = "a"
n_subsets = len(long_df[var].unique())
p = rel._LinePlotter(x="x", y="y", hue=var, data=long_df)
assert len(list(p.subset_data())) == n_subsets
p = rel._LinePlotter(x="x", y="y", style=var, data=long_df)
assert len(list(p.subset_data())) == n_subsets
n_subsets = len(long_df[var].unique())
p = rel._LinePlotter(x="x", y="y", size=var, data=long_df)
assert len(list(p.subset_data())) == n_subsets
# --
var = "a"
n_subsets = len(long_df[var].unique())
p = rel._LinePlotter(x="x", y="y", hue=var, style=var, data=long_df)
assert len(list(p.subset_data())) == n_subsets
# --
var1, var2 = "a", "s"
n_subsets = len(set(list(map(tuple, long_df[[var1, var2]].values))))
p = rel._LinePlotter(x="x", y="y", hue=var1, style=var2,
data=long_df)
assert len(list(p.subset_data())) == n_subsets
p = rel._LinePlotter(x="x", y="y", hue=var1, size=var2, style=var1,
data=long_df)
assert len(list(p.subset_data())) == n_subsets
# --
var1, var2, var3 = "a", "s", "b"
cols = [var1, var2, var3]
n_subsets = len(set(list(map(tuple, long_df[cols].values))))
p = rel._LinePlotter(x="x", y="y", hue=var1, size=var2, style=var3,
data=long_df)
assert len(list(p.subset_data())) == n_subsets
def test_subset_data_keys(self, long_df):
p = rel._LinePlotter(x="x", y="y", data=long_df)
for (hue, size, style), _ in p.subset_data():
assert hue is None
assert size is None
assert style is None
# --
var = "a"
p = rel._LinePlotter(x="x", y="y", hue=var, data=long_df)
for (hue, size, style), _ in p.subset_data():
assert hue in long_df[var].values
assert size is None
assert style is None
p = rel._LinePlotter(x="x", y="y", style=var, data=long_df)
for (hue, size, style), _ in p.subset_data():
assert hue is None
assert size is None
assert style in long_df[var].values
p = rel._LinePlotter(x="x", y="y", hue=var, style=var, data=long_df)
for (hue, size, style), _ in p.subset_data():
assert hue in long_df[var].values
assert size is None
assert style in long_df[var].values
p = rel._LinePlotter(x="x", y="y", size=var, data=long_df)
for (hue, size, style), _ in p.subset_data():
assert hue is None
assert size in long_df[var].values
assert style is None
# --
var1, var2 = "a", "s"
p = rel._LinePlotter(x="x", y="y", hue=var1, size=var2, data=long_df)
for (hue, size, style), _ in p.subset_data():
assert hue in long_df[var1].values
assert size in long_df[var2].values
assert style is None
def test_subset_data_values(self, long_df):
p = rel._LinePlotter(x="x", y="y", data=long_df)
_, data = next(p.subset_data())
expected = sort_df(p.plot_data.loc[:, ["x", "y"]], ["x", "y"])
assert np.array_equal(data.values, expected)
p = rel._LinePlotter(x="x", y="y", data=long_df, sort=False)
_, data = next(p.subset_data())
expected = p.plot_data.loc[:, ["x", "y"]]
assert | np.array_equal(data.values, expected) | numpy.array_equal |
# 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]) | numpy.array |
# Copyright 2022 Google LLC.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for ensemble routing.
We will use the following abbreviations:
G = number of groups
S = group size
E = total number of experts
K = number of selected experts
M = number of ensemble members, also referred to as ensemble size.
H = hidden size (a.k.a. number of dimensions of each token).
"""
from unittest import mock
from absl.testing import absltest
from absl.testing import parameterized
import chex
import jax
import jax.numpy as jnp
import numpy as np
from vmoe.nn import ensemble_routing as ens_routing
from vmoe.nn import routing
NoisyTopExpertsPerItemEnsembleRouter = ens_routing.NoisyTopExpertsPerItemEnsembleRouter
class NoisyTopExpertsPerItemEnsembleRouterTest(parameterized.TestCase):
# We mock get_top_experts_per_item_dispatcher to avoid having to specify the
# parameters of the dispatcher during testing. The output of the
# NoisyTopExpertsPerItemEnsembleRouter is supposed to be a dispatcher, but we
# will simply return the `gates_softmax`, which is fine for testing purposes.
@parameterized.named_parameters(
('G=1, M=1', 1, 1, (1, 1)), ('G=1, M=2', 1, 2, (1, 2)),
('G=2, M=1', 2, 1, (2, 1)), ('G=2, M=2', 2, 2, (2, 2)))
@mock.patch.object(
routing.vmoe.moe,
'get_top_experts_per_item_dispatcher',
side_effect=lambda x, **_: x)
def test_forward_deterministic(self, num_groups, ens_size,
expected_output_shape, unused_mock):
"""Tests that output is the same given two different gating PRNG seeds."""
num_experts = 4
num_selected_experts = 2
batch_size = 6
batch_size_with_repeat = batch_size * ens_size
dim_x = num_experts
product_shape = dim_x * batch_size_with_repeat * num_groups
x = jnp.arange(product_shape)
x = x.reshape(num_groups, batch_size_with_repeat, dim_x).astype(jnp.float32)
kernel = jnp.eye(dim_x).reshape(dim_x, ens_size, num_experts // ens_size)
variables = {'params': {'dense': {'kernel': kernel}}}
layer = NoisyTopExpertsPerItemEnsembleRouter(
num_experts=num_experts,
ensemble_size=ens_size,
num_selected_experts=num_selected_experts,
noise_std=1.0,
deterministic=True)
# y's are dispatch weights, m's are metrics.
y1, m1 = layer.apply(variables, x, rngs={'gating': jax.random.PRNGKey(0)})
y2, m2 = layer.apply(variables, x, rngs={'gating': jax.random.PRNGKey(1)})
chex.assert_trees_all_close(y1, y2)
chex.assert_trees_all_close(m1, m2)
for loss in m1.values():
self.assertEqual(loss.shape, expected_output_shape)
@parameterized.named_parameters(
('G=1, M=1', 1, 1, (1, 1)), ('G=1, M=2', 1, 2, (1, 2)),
('G=2, M=1', 2, 1, (2, 1)), ('G=2, M=2', 2, 2, (2, 2)))
@mock.patch.object(
routing.vmoe.moe,
'get_top_experts_per_item_dispatcher',
side_effect=lambda x, **_: x)
def test_forward_not_deterministic(self, num_groups, ens_size,
expected_output_shape, unused_mock):
"""Tests that output is different given two different gating PRNG seeds."""
num_experts = 4
num_selected_experts = 2
batch_size = 6
batch_size_with_repeat = batch_size * ens_size
dim_x = num_experts
product_shape = dim_x * batch_size_with_repeat * num_groups
x = jnp.arange(product_shape)
x = x.reshape(num_groups, batch_size_with_repeat, dim_x).astype(jnp.float32)
kernel = jnp.eye(dim_x).reshape(dim_x, ens_size, num_experts // ens_size)
variables = {'params': {'dense': {'kernel': kernel}}}
layer = NoisyTopExpertsPerItemEnsembleRouter(
num_experts=num_experts,
ensemble_size=ens_size,
num_selected_experts=num_selected_experts,
noise_std=1.0,
deterministic=False)
# y's are dispatch weights, m's are metrics.
y1, m1 = layer.apply(variables, x, rngs={'gating': jax.random.PRNGKey(0)})
y2, m2 = layer.apply(variables, x, rngs={'gating': jax.random.PRNGKey(1)})
different_fn = lambda x, y: jnp.abs(x - y).sum() > 1e-3
error_msg_fn = lambda x, y: f'{x} is too close to {y}'
chex.assert_trees_all_equal_comparator(different_fn, error_msg_fn, y1, y2)
# Importance loss is applied before adding noise, so it should be identical.
chex.assert_trees_all_close(m1['importance_loss'], m2['importance_loss'])
del m1['importance_loss']
del m2['importance_loss']
chex.assert_trees_all_equal_comparator(different_fn, error_msg_fn, m1, m2)
for loss1, loss2 in zip(m1.values(), m2.values()):
self.assertEqual(loss1.shape, expected_output_shape)
self.assertEqual(loss2.shape, expected_output_shape)
@mock.patch.object(
routing.vmoe.moe,
'get_top_experts_per_item_dispatcher',
side_effect=lambda x, **_: x)
def test_expert_partitioning_in_forward_deterministic(self, unused_mock):
"""Tests that experts are selected according to their partitioning."""
ens_size = 2
dim_x = 3
num_experts = 4 # With ens_size=2, partition {0, 1}, {2, 3}.
num_selected_experts = 1
batch_size = 1
batch_size_with_repeat = batch_size * ens_size
num_groups = 1
x = jnp.arange(batch_size_with_repeat * dim_x)
x = x.reshape(num_groups, batch_size_with_repeat, dim_x).astype(jnp.float32)
# The kernel is such that x * kernel leads to select expert 3 and 1 for
# the first and second part of the batch. But the partitioning enforces a
# selection in respectively {0, 1} and {2, 3}.
kernel = [[[1.0, 1.0], [-1.0, -1.0]],
[[-1.0, 1.0], [-1.0, -1.0]],
[[-1.0, -1.0], [-1.0, 1.0]]]
kernel = jnp.asarray(kernel)
variables = {'params': {'dense': {'kernel': kernel}}}
layer = NoisyTopExpertsPerItemEnsembleRouter(
num_experts=num_experts,
ensemble_size=ens_size,
num_selected_experts=num_selected_experts,
noise_std=1.0,
deterministic=False)
rngs = {'gating': jax.random.PRNGKey(0)}
gates_softmax, _ = layer.apply(variables, x, rngs=rngs)
selected_experts = jnp.argmax(gates_softmax, axis=-1)
# Only one group, hence the first 0 index.
self.assertIn(selected_experts[0, 0], (0, 1))
self.assertIn(selected_experts[0, 1], (2, 3))
selected_experts_no_partitioning = jnp.argmax(
jnp.dot(x, kernel.reshape(dim_x, num_experts)), -1)
# Only one group, hence the first 0 index.
self.assertNotEqual(selected_experts_no_partitioning[0, 0],
selected_experts[0, 0])
self.assertNotEqual(selected_experts_no_partitioning[0, 1],
selected_experts[0, 1])
def test_diag_blocks(self):
"""Test the utils to manipulate the block-diagonal representations."""
rows = 2
cols = 3
ens_size = 4
diag_blocks1 = jnp.asarray(
[k * jnp.ones((rows, cols)) for k in range(1, ens_size + 1)])
full_block_diag_matrix1 = jax.scipy.linalg.block_diag(*diag_blocks1)
diag_blocks2 = jnp.asarray(
[-k * jnp.ones((rows, cols)) for k in range(1, ens_size + 1)])
full_block_diag_matrix2 = jax.scipy.linalg.block_diag(*diag_blocks2)
diag_blocks12 = jnp.asarray([diag_blocks1, diag_blocks2])
full_block_diag_matrix12 = jnp.asarray(
[full_block_diag_matrix1, full_block_diag_matrix2])
def dist(u, v):
return float(jnp.sum(jnp.abs(u - v)))
out12 = ens_routing.reshape_from_diag_blocks(diag_blocks12)
self.assertAlmostEqual(dist(out12, full_block_diag_matrix12), 0.0)
def test_reshape_to_and_from_group_representation(self):
num_images = 4
ensemble_size = 2
num_rep_images = num_images * ensemble_size
num_tokens_per_image = 3
hidden_size = 1
num_groups = 2
group_size = (num_rep_images * num_tokens_per_image) // num_groups
def generate_image_tokens_with_repeat_ensemble_structure():
x = []
for i in range(num_images):
for e in range(ensemble_size):
# (i, e, t) are the image, ensemble member and token indices.
# The inner-most [] accounts for hidden_size = 1.
x += [[[f'image={i},ensemble={e},token={t}']
for t in range(num_tokens_per_image)]]
return | np.array(x) | numpy.array |
'''
episodestats.py
implements statistic that are used in producing employment statistics for the
lifecycle model
'''
import h5py
import numpy as np
import numpy_financial as npf
import matplotlib.pyplot as plt
import matplotlib as mpl
import seaborn as sns
from scipy.stats import norm
#import locale
from tabulate import tabulate
import pandas as pd
import scipy.optimize
from tqdm import tqdm_notebook as tqdm
from . empstats import Empstats
from scipy.stats import gaussian_kde
#locale.setlocale(locale.LC_ALL, 'fi_FI')
def modify_offsettext(ax,text):
'''
For y axis
'''
x_pos = 0.0
y_pos = 1.0
horizontalalignment='left'
verticalalignment='bottom'
offset = ax.yaxis.get_offset_text()
#value=offset.get_text()
# value=float(value)
# if value>=1e12:
# text='biljoonaa'
# elif value>1e9:
# text=str(value/1e9)+' miljardia'
# elif value==1e9:
# text=' miljardia'
# elif value>1e6:
# text=str(value/1e6)+' miljoonaa'
# elif value==1e6:
# text='miljoonaa'
# elif value>1e3:
# text=str(value/1e3)+' tuhatta'
# elif value==1e3:
# text='tuhatta'
offset.set_visible(False)
ax.text(x_pos, y_pos, text, transform=ax.transAxes,
horizontalalignment=horizontalalignment,
verticalalignment=verticalalignment)
class Labels():
def get_labels(self,language='English'):
labels={}
if language=='English':
labels['osuus tilassa x']='Proportion in state {} [%]'
labels['age']='Age [y]'
labels['ratio']='Proportion [%]'
labels['unemp duration']='Length of unemployment [y]'
labels['scaled freq']='Scaled frequency'
labels['probability']='probability'
labels['telp']='Employee pension premium'
labels['sairausvakuutus']='Health insurance'
labels['työttömyysvakuutusmaksu']='Unemployment insurance'
labels['puolison verot']='Partners taxes'
labels['taxes']='Taxes'
labels['asumistuki']='Housing benefit'
labels['toimeentulotuki']='Supplementary benefit'
labels['tyottomyysturva']='Unemployment benefit'
labels['paivahoito']='Daycare'
labels['elake']='Pension'
labels['tyollisyysaste']='Employment rate'
labels['tyottomien osuus']='Proportion of unemployed'
labels['havainto']='Observation'
labels['tyottomyysaste']='Unemployment rate [%]'
labels['tyottomien osuus']='Proportion of unemployed [%]'
labels['tyollisyysaste %']='Employment rate [%]'
labels['ero osuuksissa']='Difference in proportions [%]'
labels['osuus']='proportion'
labels['havainto, naiset']='data, women'
labels['havainto, miehet']='data, men'
labels['palkkasumma']='Palkkasumma [euroa]'
labels['Verokiila %']='Verokiila [%]'
labels['Työnteko [hlö/htv]']='Työnteko [hlö/htv]'
labels['Työnteko [htv]']='Työnteko [htv]'
labels['Työnteko [hlö]']='Työnteko [hlö]'
labels['Työnteko [miljoonaa hlö/htv]']='Työnteko [miljoonaa hlö/htv]'
labels['Työnteko [miljoonaa htv]']='Työnteko [miljoonaa htv]'
labels['Työnteko [miljoonaa hlö]']='Työnteko [miljoonaa hlö]'
labels['Osatyönteko [%-yks]']='Osa-aikatyössä [%-yks]'
labels['Muut tulot [euroa]']='Muut tulot [euroa]'
labels['Henkilöitä']='Henkilöitä'
labels['Verot [euroa]']='Verot [euroa]'
labels['Verot [[miljardia euroa]']='Verot [[miljardia euroa]'
labels['Verokertymä [euroa]']='Verokertymä [euroa]'
labels['Verokertymä [miljardia euroa]']='Verokertymä [miljardia euroa]'
labels['Muut tarvittavat tulot [euroa]']='Muut tarvittavat tulot [euroa]'
labels['Muut tarvittavat tulot [miljardia euroa]']='Muut tarvittavat tulot [miljardia euroa]'
labels['malli']='Life cycle model'
else:
labels['osuus tilassa x']='Osuus tilassa {} [%]'
labels['age']='Ikä [v]'
labels['ratio']='Osuus tilassa [%]'
labels['unemp duration']='työttömyysjakson pituus [v]'
labels['scaled freq']='skaalattu taajuus'
labels['probability']='todennäköisyys'
labels['telp']='TEL-P'
labels['sairausvakuutus']='Sairausvakuutus'
labels['työttömyysvakuutusmaksu']='Työttömyysvakuutusmaksu'
labels['puolison verot']='puolison verot'
labels['taxes']='Verot'
labels['asumistuki']='Asumistuki'
labels['toimeentulotuki']='Toimeentulotuki'
labels['tyottomyysturva']='Työttömyysturva'
labels['paivahoito']='Päivähoito'
labels['elake']='Eläke'
labels['tyollisyysaste']='työllisyysaste'
labels['tyottomien osuus']='työttömien osuus'
labels['havainto']='havainto'
labels['tyottomyysaste']='Työttömyysaste [%]'
labels['tyottomien osuus']='Työttömien osuus väestöstö [%]'
labels['tyollisyysaste %']='Työllisyysaste [%]'
labels['ero osuuksissa']='Ero osuuksissa [%]'
labels['osuus']='Osuus'
labels['havainto, naiset']='havainto, naiset'
labels['havainto, miehet']='havainto, miehet'
labels['palkkasumma']='Palkkasumma [euroa]'
labels['Verokiila %']='Verokiila [%]'
labels['Työnteko [hlö/htv]']='Työnteko [hlö/htv]'
labels['Työnteko [htv]']='Työnteko [htv]'
labels['Työnteko [hlö]']='Työnteko [hlö]'
labels['Työnteko [miljoonaa hlö/htv]']='Työnteko [miljoonaa hlö/htv]'
labels['Työnteko [miljoonaa htv]']='Työnteko [miljoonaa htv]'
labels['Työnteko [miljoonaa hlö]']='Työnteko [miljoonaa hlö]'
labels['Osatyönteko [%-yks]']='Osa-aikatyössä [%-yks]'
labels['Muut tulot [euroa]']='Muut tulot [euroa]'
labels['Henkilöitä']='Henkilöitä'
labels['Verot [euroa]']='Verot [euroa]'
labels['Verot [[miljardia euroa]']='Verot [[miljardia euroa]'
labels['Verokertymä [euroa]']='Verokertymä [euroa]'
labels['Verokertymä [miljardia euroa]']='Verokertymä [miljardia euroa]'
labels['Muut tarvittavat tulot [euroa]']='Muut tarvittavat tulot [euroa]'
labels['Muut tarvittavat tulot [miljardia euroa]']='Muut tarvittavat tulot [miljardia euroa]'
labels['malli']='elinkaarimalli'
return labels
class EpisodeStats():
def __init__(self,timestep,n_time,n_emps,n_pop,env,minimal,min_age,max_age,min_retirementage,year=2018,version=3,params=None,gamma=0.92,lang='English'):
self.version=version
self.gamma=gamma
self.params=params
self.lab=Labels()
self.reset(timestep,n_time,n_emps,n_pop,env,minimal,min_age,max_age,min_retirementage,year,params=params,lang=lang)
print('version',version)
def reset(self,timestep,n_time,n_emps,n_pop,env,minimal,min_age,max_age,min_retirementage,year,version=None,params=None,lang=None,dynprog=False):
self.min_age=min_age
self.max_age=max_age
self.min_retirementage=min_retirementage
self.minimal=minimal
if params is not None:
self.params=params
if lang is None:
self.language='English'
else:
self.language=lang
if version is not None:
self.version=version
self.setup_labels()
self.n_employment=n_emps
self.n_time=n_time
self.timestep=timestep # 0.25 = 3kk askel
self.inv_timestep=int(np.round(1/self.timestep)) # pitää olla kokonaisluku
self.n_pop=n_pop
self.year=year
self.env=env
self.reaalinen_palkkojenkasvu=0.016
self.palkkakerroin=(0.8*1+0.2*1.0/(1+self.reaalinen_palkkojenkasvu))**self.timestep
self.elakeindeksi=(0.2*1+0.8*1.0/(1+self.reaalinen_palkkojenkasvu))**self.timestep
self.dynprog=dynprog
if self.minimal:
self.version=0
if self.version in set([0,101]):
self.n_groups=1
else:
self.n_groups=6
self.empstats=Empstats(year=self.year,max_age=self.max_age,n_groups=self.n_groups,timestep=self.timestep,n_time=self.n_time,
min_age=self.min_age)
self.init_variables()
def init_variables(self):
n_emps=self.n_employment
self.empstate=np.zeros((self.n_time,n_emps))
self.gempstate=np.zeros((self.n_time,n_emps,self.n_groups))
self.deceiced=np.zeros((self.n_time,1))
self.alive=np.zeros((self.n_time,1))
self.galive=np.zeros((self.n_time,self.n_groups))
self.rewstate=np.zeros((self.n_time,n_emps))
self.poprewstate=np.zeros((self.n_time,self.n_pop))
self.salaries_emp=np.zeros((self.n_time,n_emps))
#self.salaries=np.zeros((self.n_time,self.n_pop))
self.actions=np.zeros((self.n_time,self.n_pop))
self.popempstate=np.zeros((self.n_time,self.n_pop))
self.popunemprightleft=np.zeros((self.n_time,self.n_pop))
self.popunemprightused=np.zeros((self.n_time,self.n_pop))
self.tyoll_distrib_bu=np.zeros((self.n_time,self.n_pop))
self.unemp_distrib_bu=np.zeros((self.n_time,self.n_pop))
self.siirtyneet=np.zeros((self.n_time,n_emps))
self.siirtyneet_det=np.zeros((self.n_time,n_emps,n_emps))
self.pysyneet=np.zeros((self.n_time,n_emps))
self.aveV=np.zeros((self.n_time,self.n_pop))
self.time_in_state=np.zeros((self.n_time,n_emps))
self.stat_tyoura=np.zeros((self.n_time,n_emps))
self.stat_toe=np.zeros((self.n_time,n_emps))
self.stat_pension=np.zeros((self.n_time,n_emps))
self.stat_paidpension=np.zeros((self.n_time,n_emps))
self.out_of_work=np.zeros((self.n_time,n_emps))
self.stat_unemp_len=np.zeros((self.n_time,self.n_pop))
self.stat_wage_reduction=np.zeros((self.n_time,n_emps))
self.stat_wage_reduction_g=np.zeros((self.n_time,n_emps,self.n_groups))
self.infostats_group=np.zeros((self.n_pop,1))
self.infostats_taxes=np.zeros((self.n_time,1))
self.infostats_wagetaxes=np.zeros((self.n_time,1))
self.infostats_taxes_distrib=np.zeros((self.n_time,n_emps))
self.infostats_etuustulo=np.zeros((self.n_time,1))
self.infostats_etuustulo_group=np.zeros((self.n_time,self.n_groups))
self.infostats_perustulo=np.zeros((self.n_time,1))
self.infostats_palkkatulo=np.zeros((self.n_time,1))
self.infostats_palkkatulo_eielakkeella=np.zeros((self.n_time,1))
self.infostats_palkkatulo_group=np.zeros((self.n_time,self.n_groups))
self.infostats_palkkatulo_eielakkeella_group=np.zeros((self.n_time,1))
self.infostats_ansiopvraha=np.zeros((self.n_time,1))
self.infostats_ansiopvraha_group=np.zeros((self.n_time,self.n_groups))
self.infostats_asumistuki= | np.zeros((self.n_time,1)) | numpy.zeros |
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
import unittest as ut
import nnetsauce as ns
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer, load_wine
class TestAdaBoost(ut.TestCase):
def test_AdaBoost(self):
breast_cancer = load_breast_cancer()
X = breast_cancer.data
y = breast_cancer.target
np.random.seed(123)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=123
)
wine = load_wine()
Z = wine.data
t = wine.target
Z_train, Z_test, t_train, t_test = train_test_split(
Z, t, test_size=0.2, random_state=123
)
clf = DecisionTreeClassifier(max_depth=1, random_state=123)
fit_obj = ns.AdaBoostClassifier(
clf,
n_hidden_features=np.int(11.22338867),
direct_link=True,
n_estimators=5,
learning_rate=0.01126343,
col_sample=0.72684326,
row_sample=0.86429443,
dropout=0.63078613,
n_clusters=0,
verbose=0,
seed=123,
reg_lambda=0,
reg_alpha=0,
method="SAMME.R",
)
clf2 = DecisionTreeClassifier(max_depth=1, random_state=123)
fit_obj2 = ns.AdaBoostClassifier(
clf2,
n_hidden_features=np.int(8.21154785e01),
direct_link=True,
n_estimators=5,
learning_rate=2.96252441e-02,
col_sample=4.22766113e-01,
row_sample=7.87268066e-01,
dropout=1.56909180e-01,
n_clusters=0,
verbose=0,
seed=123,
reg_lambda=0,
reg_alpha=0,
method="SAMME",
)
clf3 = DecisionTreeClassifier(max_depth=1, random_state=123)
fit_obj3 = ns.AdaBoostClassifier(
clf3,
n_hidden_features=np.int(11.22338867),
direct_link=True,
n_estimators=5,
learning_rate=0.01126343,
col_sample=0.72684326,
row_sample=0.86429443,
dropout=0.63078613,
n_clusters=0,
verbose=0,
seed=123,
reg_lambda=0.1,
reg_alpha=0.5,
method="SAMME.R",
)
clf4 = DecisionTreeClassifier(max_depth=1, random_state=123)
fit_obj4 = ns.AdaBoostClassifier(
clf4,
n_hidden_features=np.int(11.22338867),
direct_link=True,
n_estimators=5,
learning_rate=0.01126343,
col_sample=0.72684326,
row_sample=0.86429443,
dropout=0.63078613,
n_clusters=2,
cluster_encode=False,
verbose=0,
seed=123,
reg_lambda=0.1,
reg_alpha=0.5,
method="SAMME.R",
)
fit_obj.fit(X_train, y_train)
preds1 = fit_obj.predict_proba(X_test)
fit_obj2.fit(Z_train, t_train)
preds2 = fit_obj2.predict_proba(Z_test)
fit_obj3.fit(Z_train, t_train)
preds3 = fit_obj3.predict_proba(Z_test)
fit_obj4.fit(Z_train, t_train)
preds4 = fit_obj4.predict_proba(Z_test)
self.assertTrue(np.allclose(preds1[0, 0], 0.0010398157809255607))
self.assertTrue(np.allclose(preds1[0, 1], 0.9989601842190745))
self.assertTrue(np.allclose(preds2[0, 0], 0.28646471034732585))
self.assertFalse(np.allclose(preds3[0, 0], 1000))
self.assertFalse(np.allclose(preds4[0, 0], 1000))
self.assertTrue(
np.allclose(fit_obj.predict(X_test)[0], 1)
& np.allclose(fit_obj2.predict(X_test)[0], 1)
)
def test_score(self):
breast_cancer = load_breast_cancer()
X = breast_cancer.data
y = breast_cancer.target
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=123
)
clf = LogisticRegression(solver="liblinear", multi_class="ovr")
fit_obj = ns.AdaBoostClassifier(
clf,
n_hidden_features=np.int(11.22338867),
direct_link=True,
n_estimators=5,
learning_rate=0.01126343,
col_sample=0.72684326,
row_sample=0.86429443,
dropout=0.63078613,
n_clusters=0,
verbose=0,
seed=123,
reg_lambda=0,
reg_alpha=0,
method="SAMME.R",
)
clf2 = LogisticRegression(solver="liblinear", multi_class="ovr")
fit_obj2 = ns.AdaBoostClassifier(
clf2,
n_hidden_features=np.int(8.21154785e01),
direct_link=True,
n_estimators=5,
learning_rate=2.96252441e-02,
col_sample=4.22766113e-01,
row_sample=7.87268066e-01,
dropout=1.56909180e-01,
n_clusters=0,
verbose=0,
seed=123,
reg_lambda=0,
reg_alpha=0,
method="SAMME",
)
fit_obj3 = ns.AdaBoostClassifier(
clf,
n_hidden_features=np.int(11.22338867),
direct_link=True,
n_estimators=5,
learning_rate=0.01126343,
col_sample=0.72684326,
row_sample=0.86429443,
dropout=0.63078613,
n_clusters=0,
verbose=0,
seed=123,
reg_lambda=0.1,
reg_alpha=0.5,
method="SAMME.R",
)
fit_obj.fit(X_train, y_train)
score1 = fit_obj.score(X_test, y_test)
fit_obj2.fit(X_train, y_train)
score2 = fit_obj2.score(X_test, y_test)
fit_obj3.fit(X_train, y_train)
score3 = fit_obj3.score(X_test, y_test)
self.assertTrue(
np.allclose(score1, 0.9210526315789473)
& | np.allclose(score2, 0.7807017543859649) | numpy.allclose |
"""
Generating data from the CarRacing gym environment.
!!! DOES NOT WORK ON TITANIC, DO IT AT HOME, THEN SCP !!!
"""
import argparse
from os.path import join, exists
import gym
import numpy as np
import random
import gym_minigrid
from gym_minigrid.wrappers import *
from gym_minigrid.window import Window
import cv2
from models import MDRNNCell, VAE
import torch
def generate_data(rollouts, data_dir, noise_type): # pylint: disable=R0914
""" Generates data """
assert exists(data_dir), "The data directory does not exist..."
mdir = 'D:\steps1000'
vae_file, rnn_file, ctrl_file = \
[join(mdir, m, 'best.tar') for m in ['vae', 'mdrnn', 'ctrl']]
assert exists(vae_file) and exists(rnn_file),\
"Either vae or mdrnn is untrained."
vae_state, rnn_state= [
torch.load(fname, map_location={'cuda:0': str('cuda')})
for fname in (vae_file, rnn_file)]
for m, s in (('VAE', vae_state), ('MDRNN', rnn_state)):
print("Loading {} at epoch {} "
"with test loss {}".format(
m, s['epoch'], s['precision']))
vae = VAE(3, 32).to('cuda')
vae.load_state_dict(vae_state['state_dict'])
mdrnn = MDRNNCell(32, 1, 256, 5).to('cuda')
mdrnn.load_state_dict({k.strip('_l0'): v for k, v in rnn_state['state_dict'].items()})
hidden = [torch.zeros(1, 256).to('cuda') for _ in range(2)]
env = gym.make('MiniGrid-MultiRoom-N6-v0')
env.reset()
#env = RGBImgPartialObsWrapper(env) # Get pixel observations
seq_len = 1000
for i in range(rollouts):
#env.reset() #uncomment this if a new environment must be produced every episode
#env.env.viewer.window.dispatch_events()
s_rollout = []
r_rollout = []
d_rollout = []
a_rollout = []
h_rollout = []
t = 0
while True:
action = random.randint(0, env.action_space.n - 1)
t += 1
#env.render()
s, r, done, _ = env.step(action)
#tu = cv2.resize(s['image'],(64,64))
tu = s['image']
obs = torch.tensor(tu.flatten(),dtype = torch.float32).unsqueeze(0).to('cuda')
reconx, latent_mu, logsigma = vae(obs)
#print(hidden[0])
act = torch.Tensor([[action]]).to('cuda')
_, _, _, _, _, hidden = mdrnn(act, latent_mu, tuple(hidden))
#env.env.viewer.window.dispatch_events()
s_rollout += [tu]
if t == 125:
d = True
else:
d= False
r_rollout += [r]
d_rollout += [d]
a_rollout += [[action]]
h_rollout.append(np.array(hidden[0].cpu().detach().numpy()))
if t ==125:
print("> End of rollout {}, {} frames...".format(i, len(s_rollout)))
np.savez(join(data_dir, 'rollout_{}'.format(i)),
observations=np.array(s_rollout),
rewards= | np.array(r_rollout) | numpy.array |
# --------------------------------------------------------
# DaSiamRPN
# Licensed under The MIT License
# Written by <NAME> (wangqiang2015 at ia.ac.cn)
# --------------------------------------------------------
import cv2
import torch
import numpy as np
def to_numpy(tensor):
if torch.is_tensor(tensor):
return tensor.cpu().numpy()
elif type(tensor).__module__ != 'numpy':
raise ValueError("Cannot convert {} to numpy array"
.format(type(tensor)))
return tensor
def to_torch(ndarray):
if type(ndarray).__module__ == 'numpy':
return torch.from_numpy(ndarray)
elif not torch.is_tensor(ndarray):
raise ValueError("Cannot convert {} to torch tensor"
.format(type(ndarray)))
return ndarray
def im_to_numpy(img):
img = to_numpy(img)
img = np.transpose(img, (1, 2, 0)) # H*W*C
return img
def im_to_torch(img):
img = np.transpose(img, (2, 0, 1)) # C*H*W
img = to_torch(img).float()
return img
def torch_to_img(img):
img = to_numpy(torch.squeeze(img, 0))
img = np.transpose(img, (1, 2, 0)) # H*W*C
return img
def get_subwindow_tracking(im, pos, model_sz, original_sz, avg_chans, out_mode='torch'):
if isinstance(pos, float):
pos = [pos, pos]
sz = original_sz
im_sz = im.shape
c = (original_sz+1) // 2
context_xmin = round(pos[0] - c) # floor(pos(2) - sz(2) / 2);
context_xmax = context_xmin + sz - 1
context_ymin = round(pos[1] - c) # floor(pos(1) - sz(1) / 2);
context_ymax = context_ymin + sz - 1
left_pad = int(max(0., -context_xmin))
top_pad = int(max(0., -context_ymin))
right_pad = int(max(0., context_xmax - im_sz[1] + 1))
bottom_pad = int(max(0., context_ymax - im_sz[0] + 1))
context_xmin = context_xmin + left_pad
context_xmax = context_xmax + left_pad
context_ymin = context_ymin + top_pad
context_ymax = context_ymax + top_pad
# zzp: a more easy speed version
r, c, k = im.shape
if any([top_pad, bottom_pad, left_pad, right_pad]):
te_im = | np.zeros((r + top_pad + bottom_pad, c + left_pad + right_pad, k), np.uint8) | numpy.zeros |
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 19 19:38:28 2018
@author: User
"""
import numpy as np
import cv2
import os
import time
os.getcwd()
os.chdir(r'C:\Users\jmunozb\OneDrive - Universidad EAFIT\Reto AI disruptive')
#Videos
os.chdir(r'C:\Users\jmunozb\OneDrive - Universidad EAFIT\Reto AI disruptive\videos')
#Imagenes
os.chdir(r'C:\Users\jmunozb\OneDrive - Universidad EAFIT\Reto AI disruptive\2. DATASET PLACAS\1. Placas Originales')
##Control
#control=0 #0 es video, 1 es imagenes
archivos=os.listdir()
os.listdir()
#Trackbar to see Yellow for contour
def nothing(x):
pass
cv2.namedWindow('image')
cv2.resizeWindow('image',650,320)
cv2.createTrackbar('Hmin','image',0,180,nothing)
cv2.createTrackbar('Smin','image',0,255,nothing)
cv2.createTrackbar('Vmin','image',0,255,nothing)
cv2.createTrackbar('Hmax','image',0,180,nothing)
cv2.createTrackbar('Smax','image',0,255,nothing)
cv2.createTrackbar('Vmax','image',0,255,nothing)
cv2.createTrackbar('Control','image',0,1,nothing)
cv2.setTrackbarPos('Hmin','image',10)
cv2.setTrackbarPos('Smin','image',87)
cv2.setTrackbarPos('Vmin','image',93)
cv2.setTrackbarPos('Hmax','image',39)
cv2.setTrackbarPos('Smax','image',255)
cv2.setTrackbarPos('Vmax','image',255)
ret=False
i=0 #contador de archivos
v=0
showtime=3 #tiempo para mostrar imagenes
t_inicial=time.time()
control_previo=0
pausa=False
saveImages=False
recortadas=True
contImages=0
while True:
#print(cv2.getTrackbarPos('Control','image'))
control=cv2.getTrackbarPos('Control','image')
if control==control_previo:
pass
else:
i=0
if control==0: #Videos
os.chdir(r'C:\Users\jmunozb\OneDrive - Universidad EAFIT\Reto AI disruptive\videos')
archivos=os.listdir()
if v==0:
cap = cv2.VideoCapture(archivos[i])
ret, frame = cap.read()
v=1
else:
if pausa==False:
ret, frame = cap.read()
else:
if recortadas:
os.chdir(r'C:\Users\jmunozb\OneDrive - Universidad EAFIT\Reto AI disruptive\ImagesDetection') #Imagenes
else:
os.chdir(r'C:\Users\jmunozb\OneDrive - Universidad EAFIT\Reto AI disruptive\2. DATASET PLACAS\1. Placas Originales')
archivos=os.listdir()
frame=cv2.imread(archivos[i])
ret=True
v=0
control_previo=control
if ret:
frame=cv2.resize(frame,(640,360),interpolation=cv2.INTER_AREA)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
frame_or=frame.copy()
low_green=np.array([cv2.getTrackbarPos('Hmin','image'),cv2.getTrackbarPos('Smin','image'),cv2.getTrackbarPos('Vmin','image')])
upper_green=np.array([cv2.getTrackbarPos('Hmax','image'),cv2.getTrackbarPos('Smax','image'),cv2.getTrackbarPos('Vmax','image')])
mask2=cv2.inRange(hsv,low_green,upper_green)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
lower_range = np.array([15,100,100])
upper_range = np.array([45,255,255])
mask = cv2.inRange(hsv, lower_range, upper_range)
output = cv2.bitwise_and(frame, frame, mask = mask2)
im2, contours, hierarchy = cv2.findContours(mask2.copy(),cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
contours=sorted(contours,key=cv2.contourArea, reverse=True)[:20]
# print('contours',len(contours))
for cnt in contours:
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.022 * peri, True)
lx,ly,_=frame.shape
area_frame=lx*ly
area=cv2.contourArea(cnt)
#print(len(approx),peri,area/peri,area/area_frame)
# if our approximated contour has four points, then
# we can assume that we have found our screen
if 2 <len(approx)< 9 and peri > 35 and area/area_frame<0.03 and 18>area/peri>2.5 :
rect = cv2.minAreaRect(cnt)
box = cv2.boxPoints(rect)
box = np.int0(box)
lim_sup=3.5
lim_inf=1.25
width,height=np.int0(rect[1])
if width<height:
aux=width
width=height
height=aux
dst = np.array([
[0, height - 1],
[0, 0],
[width - 1, 0],
[width - 1, height - 1],
], dtype = "float32")
if rect[2]<-30:
dst = np.array([
[width - 1, height - 1],
[0, height - 1],
[0, 0],
[width - 1, 0],
], dtype = "float32")
if 135>rect[2]>45 or -135<rect[2]<-45:
if rect[1][1] >lim_inf* rect[1][0] and rect[1][1] <lim_sup* rect[1][0]:
cv2.drawContours(frame_or,[box],0,(0,255,0),2)
M = cv2.getPerspectiveTransform(np.array(box,dtype="float32"), dst)
# warp = cv2.warpPerspective(frame, M, (width, height))
warp = cv2.warpPerspective(mask2, M, (width, height))
if len(approx)==4:
M2 = cv2.getPerspectiveTransform(np.array(approx,dtype="float32"), dst)
warp2 = cv2.warpPerspective(frame.copy(), M2, (width, height))
print('approx=4',approx,'box',box)
else:
print('approx',approx)
#print(len(approx),peri,area,area/peri)
else:
cv2.drawContours(frame_or,[box],0,(255,0,0),2)
else:
if rect[1][0] >lim_inf* rect[1][1] and rect[1][0] <lim_sup* rect[1][1]:
cv2.drawContours(frame_or,[box],0,(0,255,0),2)
M = cv2.getPerspectiveTransform( | np.array(box,dtype="float32") | numpy.array |
from . import transform_ipa as tipa
from .phone import Phone, attributes
import numpy as np
positions = ['itself', 'prev', 'prevNonDot', 'prevCons', 'prevVowel',
'prevOrSelfNonDot', 'prevOrSelfCons', 'prevOrSelfVowel']
def get_features(source_w, target_w):
"""
Creates a matrix containing the features for all sounds in the given words.
Keyword arguments:
source_w: The word in the source language.
A list(Phone) as returned by utils.get_cognates.
target_w: The word in the target language.
A list(Phone) as returned by utils.get_cognates.
Returns:
A numpy matrix with 2 * n_phonetic_features * n_context_positions columns
and len(source_w)-1 rows. The order of the columns matches that of the
header created by features.generate_features.
"""
n_features = len(attributes()) * len(positions)
source_matrix = process_word(source_w, n_features)
target_matrix = process_word(target_w, n_features)
return | np.concatenate((source_matrix, target_matrix), axis=1) | numpy.concatenate |
""" Trains an agent with (stochastic) Policy Gradients on Pong. Uses OpenAI Gym. """
import numpy as np
import pickle
import gym
from keras.layers import Input,Dense,Flatten,Convolution2D,Activation
from keras.models import Model,Sequential
from keras.optimizers import RMSprop,Adam
import uuid
from multiprocessing import Pool
from functools import partial
def buildmodel(opt):
print("Now we build the model")
model = Sequential()
model.add(Convolution2D(32, 8, 8, subsample=(4,4), border_mode='same',input_shape=(80,80,1)))
model.add(Activation('relu'))
model.add(Convolution2D(64, 4, 4, subsample=(2,2), border_mode='same'))
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3, subsample=(1,1), border_mode='same'))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dense(1))
model.compile(loss='binary_crossentropy',optimizer=opt)
print("We finish building the model")
return model
def create_perc_model(input_dim,hidden_dim):
inp=Input(shape=(80,80,1), dtype='float32', name='main_input')
dd=Flatten()(inp)
dd=Dense(hidden_dim,activation='relu')(dd)
out=Dense(1,activation='sigmoid')(dd)
return inp,out
def create_conv_model(input_dim):
inp=Input(shape=(80,80,1), dtype='float32', name='main_input')
dd=Convolution2D(32,4,4,border_mode='same',activation='relu')(inp)
dd=Convolution2D(32,4,4,border_mode='same',activation='relu')(dd)
dd=Flatten()(dd)
out=Dense(1,activation='sigmoid')(dd)
return inp,out
def prepro(I):
""" prepro 210x160x3 uint8 frame into 6400 (80x80) 1D float vector """
I = I[35:195] # crop
I = I[::2,::2,0] # downsample by factor of 2
I[I == 144] = 0 # erase background (background type 1)
I[I == 109] = 0 # erase background (background type 2)
I[I != 0] = 1 # everything else (paddles, ball) just set to 1
return I.astype(np.float32)
def discount_rewards(r):
""" take 1D float array of rewards and compute discounted reward """
gamma = 0.99 # discount factor for reward
discounted_r = np.zeros_like(r)
running_add = 0
for t in reversed(range(0, r.size)):
if r[t] != 0: running_add = 0 # reset the sum, since this was a game boundary (pong specific!)
running_add = running_add * gamma + r[t]
discounted_r[t] = running_add
return discounted_r
def get_dense_model():
"""Make keras model"""
learning_rate=1e-4
inp = Input(shape=(80*80,))
h = Dense(200, activation='relu')(inp)
out = Dense(1, activation='sigmoid')(h)
model = Model(inp, out)
optim = RMSprop(learning_rate)
model.compile(optim, 'binary_crossentropy')
try:
model.load_weights('mod_weights_binary.h5')
print('weights loaded')
except:
pass
return model
def run_episodes(thr):
"""
Main issue - make environments that are stateful and can run for some
iterations (say 4). Make fast gradient updates based on a few iterations
on many agents.
It's important to get the environments to keep the state.
"""
n_episodes=3
D=80*80
model=get_dense_model()
#env = gym.make("Pong-v0")
env=gym.make("Pong-v0")
observation = env.reset()
prev_x = None # used in computing the difference frame
xs,ys,drs = [],[],[]
running_reward = None
reward_sum = 0
episode_number = 0
loc_len=0
while True:
#if render: env.render()
# preprocess the observation, set input to network to be difference image
cur_x = prepro(observation)
x = cur_x - prev_x if prev_x is not None else np.zeros(D)
prev_x = cur_x
# forward the policy network and sample an action from the returned probability
aprob = model.predict(x.reshape((1, -1)))
action = 2 if np.random.uniform() < aprob else 3 # roll the dice!
# record various intermediates (needed later for backprop)
xs.append(x.reshape((1, -1))) # observation
# y = 1 if action == 2 else 0 # a "fake label" giving the action chosen
ys.append(1 if action == 2 else 0) # a "fake label" giving the action chosen
# step the environment and get new measurements
observation, reward, done, info = env.step(action)
reward_sum += reward
drs.append(reward) # record reward (has to be done after we call step() to get reward for previous action)
loc_len+=1
if done: # an episode finished (one player has reached a score of 21)
episode_number += 1
print(episode_number,reward_sum,loc_len)
reward_sum=0
loc_len=0
if episode_number>(n_episodes-1):
return xs,ys,drs
observation = env.reset()
def run_training(mod):
xs,ys,drs,inds = [],[],[],[]
bn=0
pp=Pool(3)
while True:
thr=[ iii for iii in range(3)]
outs=pp.map(run_episodes,thr)
for o in outs:
xs.extend(o[0])
ys.extend(o[1])
drs.extend(o[2])
# for iii in range(4):
# xs_n,ys_n,drs_n=run_episodes(mod)
# xs.extend(xs_n)
# ys.extend(ys_n)
# drs.extend(drs_n)
print('Updating weights...')
# stack together all inputs, actions, and rewards for this episode
epx = np.vstack(xs)
print(epx.shape)
epy = np.vstack(ys)
epr = | np.vstack(drs) | numpy.vstack |
import os
import numpy as np
import pandas as pd
"""
This function is used to import the data. Put the data in a folder named all_data in the directory of the code
"""
def import_data(dt_name):
"""
:param dt_name: Name of the Dataset
:return: Three pandas frames which correspond to training, testing and validation data
"""
# First we get the directory of our project and then take all the three files and import them to the respective
# names.
d = os.getcwd()
test_data = pd.read_csv(os.path.join(os.path.join(d, "all_data"), "test_{0}.csv".format(dt_name)), header=None)
train_data = pd.read_csv(os.path.join(os.path.join(d, "all_data"), "train_{0}.csv".format(dt_name)), header=None)
validation_data = pd.read_csv(os.path.join(os.path.join(d, "all_data"), "valid_{0}.csv".format(dt_name)),
header=None)
# Now we will return the data frames
return [test_data, train_data, validation_data]
"""
This function is defined to get the labels/classes and attribute values in different variables
"""
def get_attributes_and_labels(data):
"""
:param data: The dataset to be divided
:return: Two panda frames which are in order of classes and attributes
"""
# Here we divide our attributes and classes features for a given dataset
return [data.iloc[:, -1], data.iloc[:, :-1]]
"""
This function is used to find the entropy which is our impurity heuristic for this algorithm
"""
def get_entropy(data):
"""
:param data: THese are the values for which we want to find the entropy of. We pass a whole vector of values which
correspond to the attribute of importance and find entropy for that vector.
:return: Entropy for the given vector
"""
entropy_value = 0
temp, unique_count = np.unique(data, return_counts=True)
# We will use the formula mentioned in the slides to calculate the value of entropy for both the options (i.e,
# 1 and 0)
sum_of_counts = np.sum(unique_count)
for count in unique_count:
entropy_value = entropy_value - ((count / sum_of_counts) * np.log2(count / sum_of_counts))
return entropy_value
"""
This function is used to find the information gain for the given sub-tree/tree. The information gain is used to find the
attribute we will use to do further branching
"""
def Information_Gain_Heuristic(examples, attributes, target_attribute):
"""
:param examples: The data for whihc we want to find the information gain
:param attributes: the values of the attributes available (the column number)
:param target_attribute: the target attribute we are trying to find
:return: Information Gain of the given sub-tree.
"""
# Here we find the entropy for the root node
previous_entropy = get_entropy(target_attribute)
Information_Gain = []
for each_attribute in attributes:
unique_value_of_attribute, counts_of_attribute = | np.unique(examples[each_attribute], return_counts=True) | numpy.unique |
# -------------------------------------------------------------------
import cv2
import numpy as np
import time
from enum import Enum
# =============================================================================
# Ref. design
# https://github.com/Xilinx/Vitis-AI/blob/v1.1/mpsoc/vitis_ai_dnndk_samples/tf_yolov3_voc_py/tf_yolov3_voc.py
# From Vitis-AI Zoo
# 1. data channel order: BGR(0~255)
# 2. resize: 416 * 416(H * W)
# 3. mean_value: 0.0, 0.0, 0.0
# 4. scale: 1 / 255.0
# 5. reisze mode: biliner
# Data from yolov4_leaky_spp_m.prototxt
# and Xilinx yolov4-test.py
yolo_anchors = np.array([(12, 16), (19, 36), (40, 28), (36, 75), (76, 55), (72, 146), (142, 110), (192, 243),(459, 401)], np.float32) / 416
yolo_anchor_masks = np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]])
# -------------------------------------------------------------------
# YOLOv4 data collected from notebook (dpu_test.ipynb)
#
# inputTensor[0]: name=data_fixed, dims=[1, 416, 416, 3], dtype=xint8
#
# outputTensor[0]: name=layer138-conv_fixed, dims=[1, 52, 52, 255], dtype=xint8
# outputTensor[1]: name=layer149-conv_fixed, dims=[1, 26, 26, 255], dtype=xint8
# outputTensor[2]: name=layer160-conv_fixed, dims=[1, 13, 13, 255], dtype=xint8
# -------------------------------------------------------------------
# Load .xmodel downloaded from Vitis-AI repository
#yolov4_model_path = "models/yolov4_leaky_spp_m/yolov4_leaky_spp_m.xmodel"
yolov4_model_path = "models/yolov4_leaky_spp_m_pruned_0_36/yolov4_leaky_spp_m_pruned_0_36.xmodel"
# =============================================================================
# -------------------------------------------------------------------
def resize_with_padding(image, size):
# resize image with unchanged aspect ratio using padding
ih, iw, _ = image.shape
w, h = size
scale = min(w/iw, h/ih)
nw = int(iw*scale)
nh = int(ih*scale)
image = cv2.resize(image, (nw,nh), interpolation=cv2.INTER_LINEAR)
new_image = np.ones((h,w,3), np.uint8) * 128
h_start = (h-nh)//2
w_start = (w-nw)//2
new_image[h_start:h_start+nh, w_start:w_start+nw, :] = image
return new_image
# -------------------------------------------------------------------
def preprocess_img(image, size, fixpos):
image = image[...,::-1]
image = resize_with_padding(image, size)
image_data = np.array(image, dtype='float32', order='C')
fix_scale = 2**fixpos
image_data *= fix_scale/255
image_data = np.expand_dims(image_data, 0)
return image_data
# -------------------------------------------------------------------
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# -------------------------------------------------------------------
def draw_outputs(img, outputs, class_names):
boxes, objectness, classes, nums = outputs
ih, iw, _ = img.shape
wh = np.array([iw, ih])
for i in range(nums):
x1y1 = tuple((np.array(boxes[i][0:2]) * wh).astype(np.int32))
x2y2 = tuple((np.array(boxes[i][2:4]) * wh).astype(np.int32))
img = cv2.rectangle(img, x1y1, x2y2, (255, 0, 0), 2)
img = cv2.putText(
img, '{} {:.4f}'.format(class_names[int(classes[i])],
objectness[i]), x1y1,
cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)
return img
# -------------------------------------------------------------------
def draw_outputs_scale(img, scale, offset, outputs, class_names):
boxes, objectness, classes, nums = outputs
for i in range(nums):
x1y1 = tuple(
((np.array(boxes[i][0:2]) - offset) * scale).astype(np.int32))
x2y2 = tuple(
((np.array(boxes[i][2:4]) - offset) * scale).astype(np.int32))
img = cv2.rectangle(img, x1y1, x2y2, (255, 0, 0), 2)
img = cv2.putText(
img, '{} {:.4f}'.format(class_names[int(classes[i])],
objectness[i]), x1y1,
cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)
return img
# -------------------------------------------------------------------
def yolo_box(conv_output, grid_size, num_classes, anchors, layer_id):
box_xy = conv_output[:, :, :, :, 0:2]
box_wh = conv_output[:, :, :, :, 2:4]
objectness = conv_output[:, :, :, :, 4]
objectness = np.expand_dims(objectness, axis=-1)
class_probs = conv_output[:, :, :, :, 5:]
box_xy = sigmoid(box_xy)
objectness = sigmoid(objectness)
class_probs = sigmoid(class_probs)
grid = np.meshgrid(range(grid_size), range(grid_size))
grid = np.expand_dims(np.stack(grid, axis=-1), axis=2)
box_xy = (box_xy + grid) / grid_size
box_wh = np.exp(box_wh) * anchors
box_x1y1 = box_xy - box_wh / 2
box_x2y2 = box_xy + box_wh / 2
box_x1y1 = box_x1y1
box_x2y2 = box_x2y2
bbox = np.concatenate((box_x1y1, box_x2y2), axis=-1)
return bbox, objectness, class_probs
# -------------------------------------------------------------------
def yolo_non_max_suppression(outputs, score_thres, iou_thres):
# bbox, objectness, class_index
b, c, t = [], [], []
for o in outputs:
b.append(np.reshape(o[0], (-1, o[0].shape[-1])))
c.append(np.reshape(o[1], (-1, o[1].shape[-1])))
t.append(np.reshape(o[2], (-1, o[2].shape[-1])))
bbox = np.concatenate(b)
objectness = np.concatenate(c)
class_probs = np.concatenate(t)
scores = objectness * class_probs
# find the highes class score for each box
max_scores = | np.amax(scores, axis=-1) | numpy.amax |
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
def rgb_to_hex(rgb):
return '%02x%02x%02x' % rgb
def ball(center, r):
n = 200
#Pripravimo 100 točk:
theta = np.linspace(0,2*np.pi, n)
phi = np.linspace(0,np.pi, n)
#koordinate krogle
x = center[0] * np.ones((n,n)) + r * np.outer(np.cos(theta),np.sin(phi))
y = center[1] * np.ones((n,n)) + r * np.outer(np.sin(theta),np.sin(phi))
z = center[2] * np.ones((n,n)) + r * np.outer(np.ones(n),np.cos(phi))
#krogle ni treba rotirati
return x, y, z
def normalize(vector):
return vector / np.linalg.norm(vector)
def rot(axis, sin_theta, cos_theta):
"""
Rodriguezova formula predelana na vhodna podatka cos in sin kota.
"""
axis = np.asarray(axis)
axis = axis / (np.dot(axis, axis))**0.5
a = ((cos_theta+1.) / 2.)**0.5 #np.cos(theta / 2.0)
b, c, d = -axis * sin_theta / (2 * a) #-axis*np.sin(theta / 2.0)
aa, bb, cc, dd = a * a, b * b, c * c, d * d
bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d
return np.array([[aa + bb - cc - dd, 2 * (bc + ad), 2 * (bd - ac)],
[2 * (bc - ad), aa + cc - bb - dd, 2 * (cd + ab)],
[2 * (bd + ac), 2 * (cd - ab), aa + dd - bb - cc]])
def cylinder(center, axis, r, hmax):
"""
paramterizacija valja s središčem (vektor center), usmerjenostjo (vektor axis), radijem (r), maksimalno višino (hmax).
"""
#cos_fi=np.dot(normalize(axis), normalize(0,0,1))
if normalize(axis)[2]==1:
R = | np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) | numpy.array |
# Copyright (c) 2021 zfit
import mplhep
import numpy as np
import numpy.testing
import pytest
import zfit
import zfit.z.numpy as znp
from matplotlib import pyplot as plt
from zfit._data.binneddatav1 import BinnedData
from zfit._loss.binnedloss import ExtendedBinnedNLL
from zfit.models.binned_functor import BinnedSumPDF
from zfit.models.morphing import SplineMorphingPDF
from zfit.models.template import BinnedTemplatePDFV1
def test_binned_template_pdf():
bins1 = 5
bins2 = 7
counts = np.random.uniform(high=1, size=(bins1, bins2)) # generate counts
counts2 = np.random.normal(loc=5, size=(bins1, bins2))
counts3 = np.linspace(0, 10, num=bins1)[:, None] * np.linspace(0, 5, num=bins2)[None, :]
binnings = [zfit.binned.RegularBinning(bins1, 0, 10, name='obs1'),
zfit.binned.RegularBinning(7, -10, bins2, name='obs2')]
binning = binnings
axes = zfit.binned.Binnings(binning)
obs = zfit.Space(obs=['obs1', 'obs2'], binning=binning)
data = BinnedData.from_tensor(space=obs, values=counts, variances=znp.ones_like(counts) * 1.3)
data2 = BinnedData.from_tensor(obs, counts2)
data3 = BinnedData.from_tensor(obs, counts3)
pdf = BinnedTemplatePDFV1(data=data, extended=np.sum(counts))
pdf2 = BinnedTemplatePDFV1(data=data2, extended=np.sum(counts2))
pdf3 = BinnedTemplatePDFV1(data=data3, extended=np.sum(counts3))
assert len(pdf.ext_pdf(data)) > 0
pdf_sum = BinnedSumPDF(pdfs=[pdf, pdf2, pdf3], obs=obs)
probs = pdf_sum.counts(data)
true_sum_counts = counts + counts2 + counts3
np.testing.assert_allclose(true_sum_counts, probs)
nsamples = 100_000_000
sample = pdf_sum.sample(n=nsamples)
np.testing.assert_allclose(true_sum_counts, sample.values() / nsamples * pdf_sum.get_yield(), rtol=0.03)
# integrate
true_integral = znp.sum(true_sum_counts)
integral = pdf_sum.ext_integrate(limits=obs)
assert pytest.approx(float(true_integral)) == float(integral)
# import matplotlib.pyplot as plt
# plt.imshow(probs)
# plt.imshow(counts2)
# plt.show()
# assert len(pdf.pdf(None, obs)) > 0
@pytest.mark.plots
@pytest.mark.parametrize('alphas', [None, [-0.7, -0.1, 0.5, 1.4]])
def test_morphing_templates(alphas):
bins1 = 15
irregular_str = 'irregular templates' if alphas is not None else ''
counts1 = np.random.uniform(70, high=100, size=bins1) # generate counts
counts = [counts1 - np.random.uniform(high=20, size=bins1), counts1,
counts1 + np.random.uniform(high=20, size=bins1)]
if alphas is not None:
counts.append(counts1 + np.random.uniform(high=5, size=bins1))
binning = zfit.binned.RegularBinning(bins1, 0, 10, name='obs1')
obs = zfit.Space(obs='obs1', binning=binning)
histos = [BinnedData.from_tensor(obs, count) for count in counts]
pdfs = [zfit.pdf.HistogramPDF(h) for h in histos]
if alphas is not None:
pdfs = {a: p for a, p in zip(alphas, pdfs)}
alpha = zfit.Parameter('alpha', 0, -5, 5)
morph = SplineMorphingPDF(alpha=alpha, hists=pdfs)
if alphas is None:
alphas = [-1, 0, 1]
for i, a in enumerate(alphas):
alpha.set_value(a)
np.testing.assert_allclose(morph.counts(), counts[i])
if len(alphas) > i + 1:
alpha.set_value((a + alphas[i + 1]) / 2)
max_dist = (counts[i] - counts[i + 1]) ** 2 + 5 # tolerance
max_dist *= 1.1 # not strict, it can be a bit higher
numpy.testing.assert_array_less((morph.counts() - counts[i]) ** 2, max_dist)
numpy.testing.assert_array_less((morph.counts() - counts[i + 1]) ** 2, max_dist)
import matplotlib.cm as cm
amin, amax = -2, 2
n = 5
template_alphas = np.array(list(alphas))
for do_3d in [True, False]:
plt.figure()
if do_3d:
ax = plt.gcf().add_subplot(111, projection='3d')
else:
ax = plt.gca()
plotstyle = '3d plot' if do_3d else 'hist plot'
plt.title(f"Morphing with splines {irregular_str} {plotstyle}")
for a in list(znp.linspace(amin, amax, n * 2)) + list(template_alphas):
normed_a = (a - amin) / (amax - amin) / 1.3 # 3 is a scaling factor
color = cm.get_cmap('winter')(normed_a)
alpha.set_value(a)
histo = morph.ext_pdf(None)
histo = BinnedData.from_tensor(obs, histo)
histo = histo.to_hist()
values = histo.values()
x = histo.axes.edges[0][:-1]
y = np.broadcast_to(a, values.shape)
z = values
label = None
if do_3d:
ax.step(x, y, z, color=color, where='pre', label=label)
else:
if np.min((a - template_alphas) ** 2) < 0.0001:
label = f'alpha={a}'
mplhep.histplot(histo, label=label, color=color)
ax.set_xlabel('observable')
ax.set_ylabel('alpha')
if do_3d:
ax.set_zlabel('ext_pdf')
plt.legend()
pytest.zfit_savefig()
@pytest.mark.parametrize('alphas', [None, [-0.7, -0.1, 0.5, 1.4]])
def test_morphing_templates2D(alphas):
bins1 = 10
bins2 = 7
shape = (bins1, bins2)
counts1 = np.random.uniform(70, high=100, size=shape) # generate counts
# counts1 = np.random.uniform(70, high=100, size=bins1) # generate counts
counts = [counts1 - np.random.uniform(high=20, size=shape), counts1,
counts1 + np.random.uniform(high=20, size=shape)]
if alphas is not None:
counts.append(counts1 + np.random.uniform(high=5, size=shape))
binning1 = zfit.binned.VariableBinning(sorted(np.random.uniform(0, 10, size=bins1 + 1)), name='obs1')
binning2 = zfit.binned.RegularBinning(bins2, 0, 10, name='obs2')
obs1 = zfit.Space(obs='obs1', binning=binning1)
obs2 = zfit.Space(obs='obs2', binning=binning2)
obs = obs1 * obs2
datasets = [BinnedData.from_tensor(obs, count) for count in counts]
pdfs = [BinnedTemplatePDFV1(data=data, extended=np.sum(data.values())) for data in datasets]
if alphas is not None:
pdfs = {a: p for a, p in zip(alphas, pdfs)}
alpha = zfit.Parameter('alpha', 0, -5, 5)
morph = SplineMorphingPDF(alpha=alpha, hists=pdfs)
if alphas is None:
alphas = [-1, 0, 1]
for i, a in enumerate(alphas):
alpha.set_value(a)
np.testing.assert_allclose(morph.counts(), counts[i])
assert pytest.approx(np.sum(counts[i])) == zfit.run(morph.get_yield())
if len(alphas) > i + 1:
alpha.set_value((a + alphas[i + 1]) / 2)
max_dist = (counts[i] - counts[i + 1]) ** 2 + 5 # tolerance
max_dist *= 1.1 # not strict, it can be a bit higher
numpy.testing.assert_array_less((morph.counts() - counts[i]) ** 2, max_dist)
numpy.testing.assert_array_less((morph.counts() - counts[i + 1]) ** 2, max_dist)
def _binned_template_composed_factory(data, sysshape):
pdf = zfit.pdf.HistogramPDF(data=data, extended=True)
pdf = zfit.pdf.BinwiseScaleModifier(pdf=pdf, modifiers=sysshape)
return pdf
@pytest.mark.parametrize('TemplateLikePDF', [BinnedTemplatePDFV1, _binned_template_composed_factory])
def test_binned_template_pdf_bbfull(TemplateLikePDF):
bins1 = 15
bins2 = 10
counts1 = np.random.uniform(high=150, size=(bins1, bins2)) # generate counts
counts2 = np.random.normal(loc=50, size=(bins1, bins2))
counts3 = | np.linspace(10, 100, num=bins1) | numpy.linspace |
# These are the data exploration functions I often use
import matplotlib.pyplot as plt
# plot individual kernel density curve
n_rows = 1
n_cols = 1
i = 1
fig=plt.figure(figsize=(10,7))
ax=fig.add_subplot(n_rows,n_cols,i)
bins = np.linspace(0, 1, 100)
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
sns.kdeplot(volatility_df['prediction_prob_std'].values)
plt.legend(loc='best', fontsize=25)
plt.title('Prepdiction Probability Std Distribution (all)', fontsize=25)
plt.xlabel('pred_prob_std', fontsize=25)
plt.ylabel('density', fontsize=25)
fig.tight_layout()
plt.show()
# plot numerical features distribution (histogram)
def show_num_feature_distribution(feature_df, n_rows, n_cols):
plt.rcParams.update({'font.size': 20})
features = feature_df.columns
i = 0
fig=plt.figure(figsize=(40, 15))
for feature in features:
if feature == 'id' or feature == 'label':
continue
i += 1
ax=fig.add_subplot(n_rows,n_cols,i)
bins = np.linspace(np.nanmin(feature_df[feature]), np.nanmax(feature_df[feature]), 100)
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
plt.hist(feature_df[feature], bins, alpha=0.75, label='median = ' + str(round(np.nanmedian(feature_df[feature]), 3)),
color = 'g', edgecolor = 'k', range=(bins.min(),bins.max()),
weights=np.zeros_like(feature_df[feature]) + 1. / feature_df[feature].shape[0]) # weights here covert count into percentage for y-axis
plt.legend(loc='best')
plt.title('Feature: ' + feature)
plt.xlabel('Feature Values')
plt.ylabel('Percentage')
fig.tight_layout()
plt.show()
# plot numerical features distribution (KDE)
n_rows = 3
n_cols = 3
i = 0
fig=plt.figure(figsize=(20,10))
for feature in score_df.columns:
if feature in ['rid', 'prediction_prob', 'prediction', 'score']:
continue
i += 1
ax=fig.add_subplot(n_rows,n_cols,i)
bins = | np.linspace(0, 1, 100) | numpy.linspace |
import os
import sys
from sklearn.cluster import KMeans
import numpy as np
from tensorflow.keras.models import load_model
from transformation import transform_images
from utils.config import TRANSFORMATION
#from kmeans import k_means
from fcmeans import FCM
modelsDir="./trans_models"
AEDir ="./AEs"
predVecFP="./vectors.txt"
# load AEs and their original labels
numOfEPS = 4
listEPS = [10,15,20,25]
IMG_TRANSFORMATIONS = TRANSFORMATION.supported_types()
# remove the original model
IMG_TRANSFORMATIONS.remove('clean')
numOfModels = len(IMG_TRANSFORMATIONS)
numOfAEs = 10000
# list of tranformation based model
modelFPList=[]
models=[]
for imgTranID in range(numOfModels):
modelName = IMG_TRANSFORMATIONS[imgTranID]
modelNameFP = os.path.join(modelsDir, "mnist_cnn_"+modelName+".h5")
modelFPList.append(modelNameFP)
print("load model {} - {}".format(imgTranID, modelName))
models.append(load_model(modelNameFP))
predVec = np.zeros((numOfModels, numOfAEs))
with open(predVecFP) as fp:
row = 0
for line in fp:
line = line.rstrip()
if len(line) == 0:
continue
parts = line.split(',')
col = 0
for elem in parts:
predVec[row, col] = int(elem)
col+=1
row+=1
predVecList=predVec.tolist()
# Clustering
NC=list(range(1, 11))#numOfModels+1)) # list of numbers of clusters
accuracies = np.zeros((numOfEPS, len(NC)))
clusteringResult = {}
with open("FCM_clustering_result.txt", "w") as fp:
for numOfClusters in NC:
# clustering into c groups
print("Clustering: {} clusters".format(numOfClusters))
fcm = FCM(n_clusters=numOfClusters)
fcm.fit(predVec)
clusteringResult[numOfClusters] = fcm.u
fp.write("\n## number of clusters: "+str(numOfClusters)+"\n")
fp.write(str(fcm.u)+"\n")
fp.write("\n")
def vote2(pred, mem):
'''
pred: numOfModels X numOfAEs X 2
mem : numOfModels X numOfClusters
voteResult: numOfAEs X 2
'''
numOfModels = pred.shape[0]
numOfAEs = pred[0].shape[0]
voteResult = | np.zeros((numOfAEs, 2)) | numpy.zeros |
import pygame as pg
import numpy as np
from numba import njit
def main():
pg.init()
pg.display.set_caption("Dead and - A Python game by FinFET, thanks for playing!")
font = pg.font.SysFont("Courier New", 70)
sounds = load_sounds()
m_vol, sfx_vol, music = 0.4, 0.5, 0
set_volume(m_vol, sfx_vol, sounds)
sounds['music'+str(music)].play(-1)
stepdelay = pg.time.get_ticks()/200
stepdelay2 = stepdelay
click, clickdelay = 0, stepdelay
screen = pg.display.set_mode((800,600))
running, pause, options, newgame = 1, 1, 0, 2
clock = pg.time.Clock()
pg.mouse.set_visible(False)
timer = 0
hres, halfvres, mod, frame = adjust_resolution()
fullscreen = 0
level, player_health, swordsp, story = 0, 0, 0, 0
#sky1, floor, wall, door, window, enemies
level_textures = [[0, 1, 0, 0, 1, 4], #level 0
[0, 2, 1, 1, 0, 3], #level 1
[1, 0, 2, 1, 1, 4], #level 2
[1, 3, 1, 0, 0, 1], #level 3
[2, 1, 2, 1, 1, 0], #level 4
[2, 0, 0, 0, 0, 2]] #level 5
menu = [pg.image.load('Assets/Textures/menu0.png').convert_alpha()]
menu.append(pg.image.load('Assets/Textures/options.png').convert_alpha())
menu.append(pg.image.load('Assets/Textures/credits.png').convert_alpha())
menu.append(pg.image.load('Assets/Textures/menu1.png').convert_alpha())
hearts = pg.image.load('Assets/Textures/hearts.png').convert_alpha()
colonel = pg.image.load('Assets/Sprites/colonel1.png').convert_alpha()
hearts2 = pg.Surface.subsurface(hearts,(0,0,player_health*10,20))
exit1 = pg.image.load('Assets/Textures/exit.png').convert_alpha()
exit2 = 1
exits = [pg.Surface.subsurface(exit1,(0,0,50,50)), pg.Surface.subsurface(exit1,(50,0,50,50))]
splash = []
for i in range(4):
splash.append(pg.image.load('Assets/Textures/splash'+str(i)+'.jpg').convert())
blood = pg.image.load('Assets/Textures/blood0.png').convert_alpha()
blood_size = np.asarray(blood.get_size())
sky1 = hearts.copy() # initialize with something to adjust resol on start
msg = "Press any key..."
surf = splash[0].copy()
splash_screen(msg, splash[0], clock, font, screen)
msg = " "
while running:
pg.display.update()
ticks = pg.time.get_ticks()/200
er = min(clock.tick()/500, 0.3)
if not pause and (player_health <= 0 or (exit2 == 0 and int(posx) == exitx and int(posy) == exity)):
msg = ' '
if player_health <= 0:
sounds['died'].play()
newgame = 2
surf = splash[3].copy()
else:
level += 1
player_health = min(player_health+2, 20)
sounds['won'].play()
newgame = 1
if level > 5:
level, newgame = 0, 2
sounds['died'].play()
surf = splash[2].copy()
surf.blit(font.render('Total time: ' + str(round(timer,1)), 1, (255, 255, 255)), (20, 525))
else:
msg = "Cleared level " + str(level-1)+'!'
splash_screen(msg, surf, clock, font, screen)
pause, clickdelay = 1, ticks
pg.time.wait(500)
if pg.mouse.get_pressed()[0]:
if swordsp < 1 and not pause:
swordsp, damage_mod = 1, 1
if pause and ticks - clickdelay > 1:
click, clickdelay = 1, ticks
sounds['healthup'].play()
for event in pg.event.get():
if event.type == pg.QUIT:
running = False
if event.type == pg.KEYDOWN:
if event.key == ord('p') or event.key == pg.K_ESCAPE:
if not pause:
pause = 1
else:
if options > 0:
options = 0
elif newgame == 0:
pause = 0
pg.mouse.set_pos(400,300)
if event.key == ord('f'): # toggle fullscreen
pg.display.toggle_fullscreen()
fullscreen = not(fullscreen)
if pause:
clock.tick(60)
surf2, pause, options, running, newgame, adjust_res, m_vol, sfx_vol, story = pause_menu(
surf.copy(), menu, pause, options, click, running, m_vol, sfx_vol, sounds, newgame, font, msg, level, ticks, hres, story)
if adjust_res != 1:
hres, halfvres, mod, frame = adjust_resolution(int(hres*adjust_res))
sky = pg.surfarray.array3d(pg.transform.smoothscale(sky1, (720, halfvres*4)))
adjust_res = 1
screen.blit(surf2, (0,0))
click = 0
if newgame == 1:
newgame, pause = 0, not(pause)
if player_health <= 0 or msg[0] != 'C':
surf = splash[1].copy()
splash_screen(' ', surf, clock, font, screen)
level, player_health, timer = 0, 20, -0.1
if np.random.randint(0, 2) != music:
sounds['music'+str(music)].fadeout(1000)
music = int(not(music))
sounds['music'+str(music)].play(-1)
msg = 'Loading...'
surf2 = surf.copy()
surf2.blit(font.render(msg, 1, (255, 255, 255)), (30, 500))
surf2.blit(font.render(msg, 1, (30, 255, 155)), (32, 502))
screen.blit(surf2, (0,0))
pg.display.update()
msg = 'Kill the monsters!'
if story:
posx, posy, rot, rotv, maph, mapc, exitx, exity, stepscount, size = load_map(level)
nlevel = level_textures[level]
else:
size = np.random.randint(10+level*2, 16+level*2)
nenemies = size #number of enemies
posx, posy, rot, rotv, maph, mapc, exitx, exity, stepscount = gen_map(size)
nlevel = [np.random.randint(0,3), #sky1
np.random.randint(0,4), #floorwall
np.random.randint(0,3), #wall
np.random.randint(0,2), #door
np.random.randint(0,2), #window
np.random.randint(0,5), #enemies
]
nenemies = level**2 + 10 + level #number of enemies
sprites, spsize, sword, swordsp = get_sprites(nlevel[5])
sky1, floor, wall, bwall, door, window = load_textures(nlevel)
sky = pg.surfarray.array3d(pg.transform.smoothscale(sky1, (720, halfvres*4)))
enemies = spawn_enemies(nenemies, maph, size, posx, posy, level/2)
hearts2 = pg.Surface.subsurface(hearts,(0,0,player_health*10,20))
exit2, damage_mod, blood_scale = 1, 1, 1
mape, minimap = np.zeros((size, size)), np.zeros((size, size, 3))
sounds['healthup'].play()
else:
timer = timer + er/2
frame = new_frame(posx-0.2*np.cos(rot), posy-0.2*np.sin(rot), rot, frame, sky, floor, hres, halfvres,
mod, maph, size, wall, mapc, exitx, exity, nenemies, rotv, door, window, bwall, exit2)
surf = pg.surfarray.make_surface(frame)
mape = np.zeros((size, size))
health = player_health
enemies, player_health, mape = enemies_ai(posx, posy, enemies, maph, size, mape, swordsp, ticks, player_health, nenemies, level/3)
enemies = sort_sprites(posx-0.2*np.cos(rot), posy-0.2*np.sin(rot), rot, enemies, maph, size, er/3)
if exit2 == 0:
surf = draw_colonel(surf, colonel, posx-0.2*np.cos(rot), posy-0.2*np.sin(rot), exitx+0.5, exity+0.5,
hres, halfvres, rot, rotv, maph, size)
surf, en = draw_sprites(surf, sprites, enemies, spsize, hres, halfvres, ticks, sword, swordsp, rotv)
if int(swordsp) > 0 and damage_mod < 1:
blood_scale = blood_scale*(1 + 2*er)
scaled_blood = pg.transform.scale(blood, 4*blood_scale*blood_size*hres/800)
surf.blit(scaled_blood, np.asarray([hres/2, halfvres]) - 2*blood_scale*blood_size*hres/800)
surf = pg.transform.scale2x(surf)
surf = pg.transform.smoothscale(surf, (800, 600))
surf.blit(hearts2, (20,20))
if exit2 == 0:
minimap[int(posx)][int(posy)] = (50, 50, 255)
surfmap = pg.surfarray.make_surface(minimap.astype('uint8'))
surfmap = pg.transform.scale(surfmap, (size*5, size*5))
surf.blit(surfmap,(20, 50), special_flags=pg.BLEND_ADD)
minimap[int(posx)][int(posy)] = (100, 100, 0)
surf.blit(font.render(str(round(timer,1)), 1, (255, 255, 255)), (20, 525))
surf.blit(exits[exit2], (730,20))
screen.blit(surf, (0,0))
if health > player_health:
hearts2 = pg.Surface.subsurface(hearts,(0,0,player_health*10,20))
sounds['hurt'].play()
if ticks - stepdelay > 2 and stepscount != posx + posy:
sounds['step'].play()
stepdelay = ticks
stepscount = posx + posy
if mape[int(posx)][int(posy)] > 0:
delaycontrol = max(0.3, 2/np.random.uniform(0.99, mape[int(posx)][int(posy)]))
if ticks - stepdelay2 > delaycontrol:
sounds['step2'].play()
stepdelay2 = ticks
if int(swordsp) > 0:
if swordsp == 1:
damage_mod = 1
while enemies[en][3] < 10 and damage_mod > 0.4 and en >= 0:
x = posx -0.2*np.cos(rot) + np.cos(rot + np.random.uniform(0, 0.05))/enemies[en][3]
y = posy -0.2*np.sin(rot) + np.sin(rot + np.random.uniform(0, 0.05))/enemies[en][3]
z = 0.5 + np.sin(rotv*-0.392699)/enemies[en][3]
dist2en = np.sqrt((enemies[en][0]-x)**2 + (enemies[en][1]-y)**2)
if dist2en < 0.1 and z > 0 and z < 0.07*enemies[en][5]:
if z > 0.05*enemies[en][5]:
enemies[en][8] = enemies[en][8] - np.random.uniform(0,2)*2
else:
enemies[en][8] = enemies[en][8] - np.random.uniform(0,2)
enemies[en][10] = ticks
x = enemies[en][0] + 0.1*np.cos(rot)
y = enemies[en][1] + 0.1*np.sin(rot)
if maph[int(x)][int(y)] == 0:
enemies[en][0]= (x + enemies[en][0])/2 # push back
enemies[en][1]= (y + enemies[en][1])/2
if damage_mod == 1:
blood_scale = enemies[en][3]
sounds['swoosh'].play()
if enemies[en][4]:
sounds['hitmonster2'].set_volume(min(1, enemies[en][3])*sfx_vol)
sounds['hitmonster2'].play()
else:
sounds['hitmonster'].set_volume(min(1, enemies[en][3])*sfx_vol)
sounds['hitmonster'].play()
damage_mod = damage_mod*0.5
if enemies[en][8] < 0:
sounds['deadmonster'].set_volume(min(1, enemies[en][3])*sfx_vol)
sounds['deadmonster'].play()
nenemies = nenemies - 1
if nenemies == 0:
exit2, msg = 0, "Find the master!"
## if np.random.uniform(0,1) < 0.3:
## player_health = min(player_health+0.5, 20)
## hearts2 = pg.Surface.subsurface(hearts,(0,0,player_health*10,20))
## sounds['healthup'].play()
en = en - 1
if damage_mod == 1:
sounds['swoosh2'].play()
swordsp = (swordsp + er*10)%4
fps = int(clock.get_fps())
pg.display.set_caption("Health: "+str(round(player_health, 1))+" Enemies: " + str(nenemies) + " FPS: " + str(fps)+ ' ' + msg)
posx, posy, rot, rotv = movement(pg.key.get_pressed(), posx, posy, rot, maph, er, rotv)
pg.mouse.set_pos(400,300)
def movement(pressed_keys, posx, posy, rot, maph, et, rotv):
x, y, diag = posx, posy, 0
if pg.mouse.get_focused():
p_mouse = pg.mouse.get_pos()
rot = rot + np.clip((p_mouse[0]-400)/200, -0.2, .2)
rotv = rotv + np.clip((p_mouse[1]-300)/200, -0.2, .2)
rotv = np.clip(rotv, -0.999, .999)
if pressed_keys[pg.K_UP] or pressed_keys[ord('w')]:
x, y, diag = x + et*np.cos(rot), y + et*np.sin(rot), 1
elif pressed_keys[pg.K_DOWN] or pressed_keys[ord('s')]:
x, y, diag = x - et*np.cos(rot), y - et*np.sin(rot), 1
if pressed_keys[pg.K_LEFT] or pressed_keys[ord('a')]:
et = et/(diag+1)
x, y = x + et*np.sin(rot), y - et*np.cos(rot)
elif pressed_keys[pg.K_RIGHT] or pressed_keys[ord('d')]:
et = et/(diag+1)
x, y = x - et*np.sin(rot), y + et*np.cos(rot)
posx, posy = check_walls(posx, posy, maph, x, y)
return posx, posy, rot, rotv
def gen_map(size):
mapc = np.random.uniform(0,1, (size,size,3))
maph = np.random.choice([0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4], (size,size))
maph[0,:] = np.random.choice([1, 2, 3, 4], size)
maph[size-1,:] = np.random.choice([1, 2, 3, 4], size)
maph[:,0] = np.random.choice([1, 2, 3, 4], size)
maph[:,size-1] = np.random.choice([1, 2, 3, 4], size)
posx, posy = np.random.randint(1, size -2)+0.5, np.random.randint(1, size -2)+0.5
rot, rotv, stepscount = np.pi/4, 0, posx + posy
x, y = int(posx), int(posy)
maph[x][y] = 0
count = 0
while True:
testx, testy = (x, y)
if np.random.uniform() > 0.5:
testx = testx + np.random.choice([-1, 1])
else:
testy = testy + np.random.choice([-1, 1])
if testx > 0 and testx < size -1 and testy > 0 and testy < size -1:
if maph[testx][testy] == 0 or count > 5:
count = 0
x, y = (testx, testy)
maph[x][y] = 0
dtx = np.sqrt((x-posx)**2 + (y-posy)**2)
if (dtx > size*.6 and np.random.uniform() > .999) or np.random.uniform() > .99999:
exitx, exity = (x, y)
break
else:
count = count+1
return posx, posy, rot, rotv, maph, mapc, exitx, exity, stepscount
def load_map(level):
mapc = pg.surfarray.array3d(pg.image.load('Assets/Levels/map'+str(level)+'.png'))
size = len(mapc)
maph = np.random.choice([1, 2, 3, 4], (size,size))
colors = np.asarray([[0,0,0], [255,255,255], [127,127,127]])
posx, exitx = None, None
for i in range(size):
for j in range(size):
color = mapc[i][j]
if (color == colors[0]).all() or (color == colors[1]).all() or (color == colors[2]).all():
maph[i][j] = 0
if (color == colors[1]).all():
posx, posy = i+0.5, j+0.5
if (color == colors[2]).all():
exitx, exity = i, j
while posx == None: # if no start is found
x, y = np.random.randint(1, size), np.random.randint(1, size)
if (mapc[x][y] == colors[0]).all():
posx, posy = x+0.5, y+0.5
while exitx == None: # if no exit is found
x, y = np.random.randint(1, size), np.random.randint(1, size)
if (mapc[x][y] == colors[0]).all():
exitx, exity = x, y
rot, rotv, stepscount = np.pi/4, 0, posx + posy
return posx, posy, rot, rotv, maph, mapc/255, exitx, exity, stepscount, size
@njit(cache=True)
def new_frame(posx, posy, rot, frame, sky, floor, hres, halfvres, mod, maph, size, wall, mapc,
exitx, exity, nenemies, rotv, door, window, bwall, exit2):
offset = -int(halfvres*rotv)
for i in range(hres):
rot_i = rot + np.deg2rad(i/mod - 30)
sin, cos, cos2 = np.sin(rot_i), np.cos(rot_i), np.cos(np.deg2rad(i/mod - 30))
frame[i][:] = sky[int(np.rad2deg(rot_i)*2%720)][halfvres-offset:3*halfvres-offset]
n = 0
n2 = 0
x, y = posx +0.2*cos, posy +0.2*sin
for j in range(2000):
x, y = x +0.01*cos, y +0.01*sin
if n == 0 and maph[int(x)%(size-1)][int(y)%(size-1)] != 0: # found lower wall
n = np.sqrt((x-posx)**2+(y-posy)**2)
if maph[int(x)%(size-1)][int(y)%(size-1)] == 2:# found upper wall
n2 = np.sqrt((x-posx)**2+(y-posy)**2)
h = halfvres/(n2*cos2 + 0.001)
break
cwall = wall
if n2 > 0.5 and 3*h > int(halfvres/(n*cos2 + 0.000001)): #draw upper wall
xx = int(x*3%1*99)
xxx = x%1
if x%1 < 0.01 or x%1 > 0.99:
xx = int(y*3%1*99)
xxx = y%1
yy = np.linspace(0, 3, int(h*2))*99%99
shade = 0.3 + 0.7*(h/halfvres)
if shade > 1:
shade = 1
if maph[int(x-0.02)%(size-1)][int(y-0.02)%(size-1)] != 0:
shade = shade*0.8
c = shade*mapc[int(x)%(size-1)][int(y)%(size-1)]
if n2 > 3.5:
cwall = bwall
for k in range(int(h)*2):
c2 = c*cwall[xx][int(yy[k])]
h1 = int(halfvres - int(h) +k +offset -2*h +3)
h2 = int(halfvres+3*h-k+offset-1 +2*h - 6)
if xxx > 1/3 and xxx < 2/3 and k > h*2/3 and k < h*4/3:
c2 = shade*window[xx][int(yy[k])]
if h1 >= 0 and h1 < 2*halfvres:
frame[i][h1] = c2
if h2 < halfvres*2:
frame[i][h2] = c2
if n == 0:
n = 1000
x, y = posx +n*cos, posy +n*sin
walltype = maph[int(x)%(size-1)][int(y)%(size-1)]
cwall = wall
if n > 3.5:
cwall = bwall
h = int(halfvres/(n*cos2 + 0.000001))
xx = int(x*3%1*99)
xxx = x%1
if x%1 < 0.01 or x%1 > 0.99:
xx = int(y*3%1*99)
xxx = y%1
yy = np.linspace(0, 3, int(h*2))*99%99
shade = 0.4 + 0.6*(h/halfvres)
if shade > 1:
shade = 1
ash = 0
if maph[int(x-0.33)%(size-1)][int(y-0.33)%(size-1)] != 0:
ash = 1
if maph[int(x-0.01)%(size-1)][int(y-0.01)%(size-1)] != 0:
shade, ash = shade*0.7, 0
c = mapc[int(x)%(size-1)][int(y)%(size-1)]
cdoor = np.sqrt(np.ones(3) - c)
c = shade*c
start_range, stop_range = 0, int(2*h)
if h > halfvres+abs(offset):
start_range = int(h - halfvres - offset)
stop_range = int(h + halfvres - offset)
for k in range(start_range, stop_range):
c2 = c*cwall[xx][int(yy[k])]
h1 = int(halfvres - h +k +offset)
h2 = int(halfvres+3*h-k+offset-3)
if xxx > 1/3 and xxx < 2/3 and k > h*2/3:
if walltype < 3:
c2 = shade*cdoor*door[xx][int(yy[k])]
elif k < h*4/3 and walltype == 3:
c2 = shade*window[xx][int(yy[k])]
if h1 >= 0 and h1 < 2*halfvres:
if ash and 1-k/(2*h) < 1-xx/99:
c2, c, ash = 0.7*c2, 0.7*c, 0
frame[i][h1] = c2
if h2 < halfvres*2:
frame[i][h2] = c2
for j in range(int(halfvres -h -offset)): #floor
n = (halfvres/(halfvres-j - offset ))/cos2
x, y = posx + cos*n, posy + sin*n
xx, yy = int(x*3%1*99), int(y*3%1*99)
shade = min(0.2 + 0.8/n, 1)
if maph[int(x-0.33)%(size-1)][int(y-0.33)%(size-1)] != 0:
shade = shade*0.7
elif ((maph[int(x-0.33)%(size-1)][int(y)%(size-1)] and y%1>x%1) or
(maph[int(x)%(size-1)][int(y-0.33)%(size-1)] and x%1>y%1)):
shade = shade*0.7
frame[i][halfvres*2-j-1] = shade*(floor[xx][yy]*2+frame[i][halfvres*2-j-1])/3
if exit2 == 0 and int(x) == exitx and int(y) == exity and (x%1-0.5)**2 + (y%1-0.5)**2 < 0.2:
ee = j/(20*halfvres)
frame[i][j:2*halfvres-j] = (ee*np.ones(3)*255+frame[i][j:2*halfvres-j])/(1+ee)
return frame
@njit(cache=True)
def vision(posx, posy, enx, eny, dist2p, maph, size):
cos, sin = (posx-enx)/dist2p, (posy-eny)/dist2p
x, y = enx, eny
seen = 1
x, y = x +0.25*cos, y +0.25*sin
for i in range(abs(int((dist2p-0.5)/0.05))):
x, y = x +0.05*cos, y +0.05*sin
if (maph[int(x-0.02)%(size-1)][int(y-0.02)%(size-1)] or
maph[int(x-0.02)%(size-1)][int(y+0.02)%(size-1)] or
maph[int(x+0.02)%(size-1)][int(y-0.02)%(size-1)] or
maph[int(x+0.02)%(size-1)][int(y+0.02)%(size-1)]):
seen = 0
break
return seen
@njit(cache=True)
def enemies_ai(posx, posy, enemies, maph, size, mape, swordsp, ticks, player_health, nenemies, level=0):
if nenemies < 5: # teleport far enemies closer
for en in range(len(enemies)): # mape = enemies heatmap
if enemies[en][8] > 0:
enx, eny = enemies[en][0], enemies[en][1]
dist2p = np.sqrt((enx-posx)**2 + (eny-posy)**2 + 1e-16)
if dist2p > 10:
for i in range(10):
x, y = | np.random.randint(1, size) | numpy.random.randint |
"""Evaluation script to analyse the gathered data.
This script:
- reads the interaction data (from the logs) and re-run the study to compute performance measures
- simulates the baseline user behaviour (starting with the same prior and query)
"""
import os
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import statsmodels
import yaml
from statsmodels.formula.api import ols
from interactive_bayesian_optimisation import config
def main(path_to_analyse=None):
if path_to_analyse is None:
path_to_analyse = "data_analysis_config.yaml"
with open(path_to_analyse) as config_file:
analysis_config = yaml.load(config_file, Loader=yaml.FullLoader)
print(analysis_config)
load_and_analyse(analysis_config)
def load_and_analyse(analysis_config):
plotting_folder = os.path.join(config.INSTANCE_PATH, analysis_config["plotting_folder"])
os.makedirs(plotting_folder, exist_ok=True)
dataframe = pd.read_csv(
filepath_or_buffer=os.path.join(config.INSTANCE_PATH, "dataset", analysis_config["dataset_name"], "dataset.csv")
)
print("Dataset loaded:", analysis_config["dataset_name"])
# Reconvert each string to a list of floats
try:
dataframe["la_all_expected_future_scores"] = dataframe.apply(
lambda row: [float(el) for el in row["la_all_expected_future_scores"][1:-1].split()],
axis=1
)
except Exception as e:
warnings.warn(
"Could not convert list for 'la_all_expected_future_scores' for the following error:\n"
+ str(e)
)
# Set generic settings for all plots
sns.set_palette(sns.color_palette("muted"))
# Comment or uncomment to select which analysis to perform
analyse_user_vs_naive_questionnaire(dataframe, plotting_folder, analysis_config)
def create_means(data, fields):
iterations = sorted(list(data["iteration"].unique()))
user_id_series = data["user_id"].unique()
if len(user_id_series) > 1:
# Means by user: for each user, have a list of their average score. The whole is an ndarray
fields_mean_by_user_list_list = [np.array([
# Each element of the list is the average score for a given user at a specific iteration
[np.mean(data[(data["iteration"] == i) & (data["user_id"] == user)][field]) for i in iterations]
for user in user_id_series])
for field in fields]
else:
session_series = data["session"].unique()
# Means by session: for each user, have a list of the session score. The whole is an ndarray
fields_mean_by_user_list_list = [np.array([
# Each element of the list is the average score for a given user at a specific iteration
[np.mean(data[(data["iteration"] == i) & (data["session"] == session)][field]) for i in iterations]
for session in session_series])
for field in fields]
assert len(fields_mean_by_user_list_list) == len(fields)
return fields_mean_by_user_list_list
def plot_averages(data, plotting_folder, plot_filename, title, fields):
"""
Parameters
----------
data
plotting_folder
plot_filename
title
fields
Returns
-------
"""
# List of iteration number in the specific user-study instance
iterations = sorted(list(data["iteration"].unique()))
user_id_series = data["user_id"].unique()
fields_by_user_list_list = create_means(data, fields)
sample_size = fields_by_user_list_list[0].shape[0] # len(data[(data["iteration"] == 0)])
# Get the mean of the score for each iteration
fields_mean_score_list_list = [np.mean(fields_by_user_list, 0) for fields_by_user_list in fields_by_user_list_list]
# Get the standard deviation of the score for each iteration
fields_se_score_list_list = [(np.std(fields_by_user_list, 0) / np.sqrt(sample_size)) for fields_by_user_list in
fields_by_user_list_list]
for field_mean, field_se, field_name in zip(fields_mean_score_list_list, fields_se_score_list_list, fields):
plt.fill_between(iterations, np.array(field_mean) + np.array(field_se),
np.array(field_mean) - np.array(field_se), alpha=0.2)
plt.plot(iterations, field_mean, label=field_name)
plt.legend()
plt.ylabel(f"AVG {fields}")
plt.xlabel("Iterations")
plt.xticks(iterations, [i + 1 for i in iterations])
plt.title(title)
plt.tight_layout()
figure_path = os.path.join(
plotting_folder,
plot_filename
)
plt.savefig(figure_path)
print("Plot completed:", figure_path)
plt.close()
if len(user_id_series) > 1:
plt.plot(iterations, [0] * len(iterations), "--")
assert len(user_id_series) == fields_by_user_list_list[0].shape[
0], f"{len(user_id_series)}, {fields_mean_score_list_list[0].shape[0]}"
for i, user in zip(range(fields_by_user_list_list[0].shape[0]), user_id_series):
for field_mean, field_name in zip(fields_by_user_list_list, fields):
plt.plot(iterations, field_mean[i, :], label=f"{user}_{field_name}")
plt.legend()
plt.ylabel(f"AVG {fields} by user")
plt.xlabel("Iterations")
plt.xticks(iterations, [i + 1 for i in iterations])
plt.title("All " + title)
plt.tight_layout()
figure_path = os.path.join(
plotting_folder,
"ALL__" + plot_filename
)
plt.savefig(figure_path)
print("Plot completed:", figure_path)
plt.close()
def plot_averages_naive_vs_user_special(data, plotting_folder, plot_filename, title, fields=None, also_utility=False):
"""
Parameters
----------
data
plotting_folder
plot_filename
title
fields
Returns
-------
"""
# Fields to be plotted
if fields is None:
fields = [
"naive_bo_score", # Score averaged
"user_score",
"abs_scaled_steering",
"scaled_steering",
]
# List of iteration number in the specific user-study instance
user_id_series = data["user_id"].unique()
study_id_series = data["study_name"].unique()
# Part for study 5
data_5 = data[data["study_name"] == "study_5"]
iterations_5 = sorted(list(data_5["iteration"].unique()))
fields_mean_by_user_list_list = create_means(data_5, fields) # Shaped (users, iterations)
sample_size = fields_mean_by_user_list_list[0].shape[0]
naive_mean_by_user_list_list_5 = fields_mean_by_user_list_list[0]
user_mean_by_user_list_list_5 = fields_mean_by_user_list_list[1]
abs_steering_mean_by_user_list_list = fields_mean_by_user_list_list[2]
steering_mean_by_user_list_list = fields_mean_by_user_list_list[3]
difference_mean_by_user_list_list_5 = np.array(user_mean_by_user_list_list_5) - np.array(
naive_mean_by_user_list_list_5)
# Get the mean of the score for each iteration
naive_mean_score_list_5 = np.mean(naive_mean_by_user_list_list_5, 0)
user_mean_score_list_5 = np.mean(user_mean_by_user_list_list_5, 0)
# Get the standard deviation of the score for each iteration
naive_se_score_list_5 = np.std(naive_mean_by_user_list_list_5, 0) / np.sqrt(sample_size)
user_se_score_list_5 = np.std(user_mean_by_user_list_list_5, 0) / np.sqrt(sample_size)
# Part for study 10
data_10 = data[data["study_name"] == "study_10"]
iterations_10 = sorted(list(data_10["iteration"].unique()))
fields_mean_by_user_list_list = create_means(data_10, fields) # Shaped (users, iterations)
sample_size = fields_mean_by_user_list_list[0].shape[0]
naive_mean_by_user_list_list_10 = fields_mean_by_user_list_list[0]
user_mean_by_user_list_list_10 = fields_mean_by_user_list_list[1]
abs_steering_mean_by_user_list_list = fields_mean_by_user_list_list[2]
steering_mean_by_user_list_list = fields_mean_by_user_list_list[3]
difference_mean_by_user_list_list_10 = np.array(user_mean_by_user_list_list_10) - np.array(
naive_mean_by_user_list_list_10)
# Get the mean of the score for each iteration
naive_mean_score_list_10 = np.mean(naive_mean_by_user_list_list_10, 0)
user_mean_score_list_10 = np.mean(user_mean_by_user_list_list_10, 0)
# Get the standard deviation of the score for each iteration
naive_se_score_list_10 = np.std(naive_mean_by_user_list_list_10, 0) / np.sqrt(sample_size)
user_se_score_list_10 = np.std(user_mean_by_user_list_list_10, 0) / np.sqrt(sample_size)
# ANCHOR PLOTS_SP
# Two subplots, 1 figure
fig, (sub_10, sub_5) = plt.subplots(nrows=1, ncols=2, sharey=True, constrained_layout=True)
# In order of execution
# Sublplot 10
sub_10.fill_between(iterations_10, np.array(naive_mean_score_list_10) + np.array(naive_se_score_list_10),
np.array(naive_mean_score_list_10) - np.array(naive_se_score_list_10), alpha=0.2)
sub_10.fill_between(iterations_10, np.array(user_mean_score_list_10) + | np.array(user_se_score_list_10) | numpy.array |
import os
import sys
import time
import argparse
import pandas as pd
import numpy as np
from scipy import interp
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.ticker import FormatStrFormatter
plt.style.use('ggplot')
sns.set(color_codes=True)
sns.set(font_scale=4)
sns.set_style("whitegrid")
sns.set_context("paper")
sns.set(style='white', palette='muted', color_codes=True)
sns.despine(left=True)
fig_format = 'pdf'
if not os.path.exists('fig'):
os.system('mkdir fig')
##########
# figure 1
##########
title_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
filename_dataset = 'snap_data_w_annot_1000_seq_reg.txt'
dataset = pd.read_csv(filename_dataset, sep='\t')
d1 = dataset[dataset['label']==1]
d0 = dataset[dataset['label']==0]
# AFR, AMR, ASN, EUR
for i, ft in enumerate(['AFR', 'AMR', 'ASN', 'EUR']):
f = plt.figure()
x_range = np.linspace(0.0, 1.0, 11)
ft_ll1 = np.histogram(d1[ft], x_range, density=True)[0]
ft_ll0 = np.histogram(d0[ft], x_range, density=True)[0]
ft_llr = np.log(ft_ll1 / ft_ll0)
sns.barplot(x=[0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9], y=ft_llr, palette='vlag')
plt.xlabel('allele frequency', fontsize=18)
plt.ylabel('LLR(+/-)', fontsize=18)
plt.tick_params(axis='both', labelsize=18)
plt.title('({}) Binned log-likelihood-ratio: {}'.format(title_list[i], ft), fontsize=18)
plt.tight_layout()
plt.savefig('./fig/fig1_{}.{}'.format(ft, fig_format))
print('[INFO]fig1_{}.{} saved to ./fig'.format(ft, fig_format))
# reg_score_int
f = plt.figure()
ft = 'reg_score_int'
ft_ll1 = np.array([d1[d1[ft] == x].shape[0] for x in np.arange(1.0, 17.0, 1.0)])
ft_ll0 = np.array([d0[d0[ft] == x].shape[0] for x in np.arange(1.0, 17.0, 1.0)])
ft_llr = np.log(ft_ll1 / ft_ll0)
sns.barplot(x=np.arange(1, 17, 1), y=ft_llr, palette='vlag')
plt.xlabel('RegulomeDB score (encoded)', fontsize=18)
plt.ylabel('LLR(+/-)', fontsize=18)
plt.tick_params(axis='both', labelsize=18)
plt.title('(e) Log-likelihood-ratio: {}'.format(ft), fontsize=18)
plt.tight_layout()
plt.savefig('./fig/fig1_{}.{}'.format(ft, fig_format))
print('[INFO]fig1_{}.{} saved to ./fig'.format(ft, fig_format))
# GENCODE_direction, RefSeq_direction
for i, ft in enumerate(['GENCODE_direction', 'RefSeq_direction']):
f = plt.figure()
x_range = [-1, 1, 4, 6]
ft_ll1 = np.histogram(d1[ft], x_range, density=True)[0]
ft_ll0 = np.histogram(d0[ft], x_range, density=True)[0]
ft_llr = np.log(ft_ll1 / ft_ll0)
sns.barplot(x=[0, 3, 5], y=ft_llr, palette='vlag', label=ft)
plt.xlabel(ft, fontsize=18)
plt.ylabel('LLR(+/-)', fontsize=18)
plt.tick_params(axis='both', labelsize=18)
plt.title('({}) Log-likelihood-ratio: {}'.format(title_list[i+5], ft), fontsize=18)
plt.tight_layout()
plt.savefig('./fig/fig1_{}.{}'.format(ft, fig_format))
print('[INFO]fig1_{}.{} saved to ./fig'.format(ft, fig_format))
# GERP_cons, SiPhy_cons
for i, ft in enumerate(['GERP_cons', 'SiPhy_cons']):
f = plt.figure()
ft_ll1 = np.array([d1[d1[ft]==0.0].shape[0], d1[d1[ft]==1.0].shape[0]])
ft_ll0 = np.array([d0[d0[ft]==0.0].shape[0], d0[d0[ft]==1.0].shape[0]])
ft_llr = np.log(ft_ll1 / ft_ll0)
sns.barplot(x=[0.0, 1.0], y=ft_llr, palette='vlag')
plt.xlabel(ft, fontsize=18)
plt.ylabel('LLR(+/-)', fontsize=18)
plt.tick_params(axis='both', labelsize=18)
plt.title('({}) Log-likelihood-ratio: {}'.format(title_list[i+7], ft), fontsize=18)
plt.tight_layout()
plt.savefig('./fig/fig1_{}.{}'.format(ft, fig_format))
print('[INFO]fig1_{}.{} saved to ./fig'.format(ft, fig_format))
# plot annotation distribution
f = plt.figure()
table0 = d0.pivot_table(index='chr', columns='annotation', values='label', aggfunc='count')
sns.heatmap(table0, annot=True, cmap='YlGnBu', fmt='g', cbar_kws={'label': 'count'})
f.savefig('./fig/fig1_annot0.{}'.format(fig_format))
print('[INFO] fig1_annot0.{} saved to ./fig'.format(fig_format))
f = plt.figure()
table1 = d1.pivot_table(index='chr', columns='annotation', values='label', aggfunc=np.sum)
sns.heatmap(table1, annot=True, cmap='YlGnBu', fmt='g', cbar_kws={'label': 'count'})
f.savefig('./fig/fig1_annot1.{}'.format(fig_format))
print('[INFO] fig1_annot1.{} saved to ./fig'.format(fig_format))
##########
# figure 2
##########
method_list = ['regulomedb', 'DeFine0', 'DeFine', 'cnn_1s', 'cnn_2s', 'resnet_2s2a', 'resnet_2s2a_metadata']
method_list_xticks = ['RDB', 'DF0', 'DF', 'CNN1s', 'CNN2s', 'Res', 'ResM']
random_seed_list = [1337, 1338, 1339, 1340, 1341]
perf_list = []
for method in method_list:
for random_seed in random_seed_list:
filename = 'out_test_{}_1000_fold_{}.txt'.format(method, random_seed)
perf = pd.read_csv(filename, sep='\t', nrows=1)
perf['random_seed'] = random_seed
perf['method'] = method
perf_list.append(perf)
perf_list = pd.concat(perf_list)
f = plt.figure()
g = sns.boxplot(x='method', y='AUROC', data=perf_list, palette='RdBu')
g.set_xlabel('method', fontsize=15)
g.set_ylabel('AUROC', fontsize=15)
plt.title('(c) 5-fold AUROC', fontsize=15)
g.set_xticklabels(labels=method_list_xticks, rotation=20)
g.tick_params(axis='both', labelsize=15)
g.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
plt.tight_layout()
f.savefig('./fig/fig2_auroc.{}'.format(fig_format))
print('[INFO] ./fig/fig2_auroc.{} saved'.format(fig_format))
f = plt.figure()
g = sns.boxplot(x='method', y='AUPRC', data=perf_list, palette='RdBu')
g.set_xlabel('method', fontsize=15)
g.set_ylabel('AUPRC', fontsize=15)
plt.title('(d) 5-fold AUPRC', fontsize=15)
g.set_xticklabels(labels=method_list_xticks, rotation=20)
g.tick_params(axis='both', labelsize=15)
g.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))
plt.tight_layout()
f.savefig('./fig/fig2_auprc.{}'.format(fig_format))
print('[INFO] ./fig/fig2_auprc.{} saved'.format(fig_format))
roc_list = {}
prc_list = {}
tprs = []
precisions = []
recalls = []
for method in method_list:
roc_list[method] = []
prc_list[method] = []
for random_seed in random_seed_list:
filename_roc = 'roc_test_{}_1000_fold_{}.txt'.format(method, random_seed)
filename_prc = 'prc_test_{}_1000_fold_{}.txt'.format(method, random_seed)
roc = pd.read_csv(filename_roc, sep='\t')
prc = pd.read_csv(filename_prc, sep='\t')
roc_list[method].append(roc)
prc_list[method].append(prc)
f = plt.figure()
for i, method in enumerate(method_list):
for roc in roc_list[method]:
mean_fp = np.linspace(0, 1, 100)
tprs.append(interp(mean_fp, roc['FP'], roc['TP']))
tprs[-1][0] = 0.0
mean_tp = np.mean(tprs, axis=0)
mean_tp[-1] = 1.0
#mean_auc = auc(mean_tp, mean_fp)
mean_auc = perf_list[perf_list['method']==method]['AUROC'].mean()
plt.plot(mean_tp, mean_fp, label='{} (Mean AUC={:.4f})'.format(method_list_xticks[i], mean_auc), lw=1, alpha=.8)
#plt.plot(roc_list[method][0]['TP'], roc_list[method][0]['FP'], label='{} (Mean AUC={:.4f})'.format(method, mean_auc), lw=1, alpha=.8)
plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate', fontsize=15)
plt.ylabel('True Positive Rate', fontsize=15)
g.set_xticklabels(labels=method_list_xticks)
g.tick_params(axis='both', labelsize=18)
plt.title('(a) ROC curve', fontsize=15)
plt.legend()
f.savefig('./fig/fig2_roc.{}'.format(fig_format))
print('[INFO] fig2_roc.{} saved!'.format(fig_format))
f = plt.figure()
for i, method in enumerate(method_list):
for prc in prc_list[method]:
# mean_recall = np.linspace(0, 1, 100)
mean_threshold = np.linspace(0.0, 0.99, 100)
precisions.append(interp(mean_threshold, prc['threshold'], prc['Precision']))
recalls.append(interp(mean_threshold, prc['threshold'], prc['Recall']))
precisions[-1][0] = 0.0
recalls[-1][0] = 1.0
recalls[-1][-1] = 0.0
mean_precision = np.mean(precisions, axis=0)
mean_recall = | np.mean(recalls, axis=0) | numpy.mean |
"""
Description: Utility functions to transform option data
"""
import datetime
import numpy as np
import pandas as pd
from wallstreet import Stock, Call, Put
import matplotlib.pyplot as plt
import matplotlib.colors as colors
# Constants
FIG_WIDTH = 20
FIG_HEIGHT = 6
def collect_option_data(ticker, year, month, day, strict=True):
""" Collect the option data for the given date """
dates = []
strikes = []
prices = []
call_setup = False
attempts = 0
print(strict)
while not call_setup and attempts < 10:
try:
wc = Call(ticker, d=day, m=month, y=year, strict=strict)
new_date = wc.expiration.split('-')
day = int(new_date[0])
month = int(new_date[1])
year = int(new_date[2])
date = datetime.datetime(year=year, month=month, day=day)
call_setup = True
except:
attempts += 1
attempts = 0
if call_setup:
for cdata in wc.data:
strikes.append(cdata['strike'])
prices.append(cdata['lastPrice'])
dates.append(date)
data = pd.DataFrame({'date':dates, 'price':prices, 'strike':strikes})
return data
def calculate_gains(strike_price, share_price, call_price, initial=None):
""" Calculate the net gains given option data and a share price """
# Calculate current value
gains = (share_price - strike_price) * 100
# OTM is worth nothing, not negative
gains[gains < 0] = 0.0
# Cost of a single contract
cost = call_price * 100
if initial:
n_contracts = np.floor(initial / cost)
net = (gains * n_contracts) + (initial - cost * n_contracts)
else:
net = ((gains - cost) / cost) * 100
return net
def plot_option_percent_gain(ticker, year, month, day, strict_date=True, data=None):
"""
Plot mesh grid of scenarios for a given call option and the
resulting percent gain
"""
fig, ax = plt.subplots(figsize=(FIG_WIDTH, FIG_HEIGHT))
if data is None:
data = collect_option_data(ticker, year, month, day, strict=strict_date)
stock = Stock(ticker)
current_price = stock.price
# Make data.
strike_price = data['strike']
share_price = np.arange(0, data['strike'].max() * 1.5, current_price / 100)
call_price_mesh = np.tile(data['price'].T, (len(share_price), 1))
strike_mesh, stock_mesh = np.meshgrid(strike_price, share_price)
percent_gains = calculate_gains(strike_mesh, stock_mesh, call_price_mesh)
# Plot the mesh grid and percent gain surfaces
pg_min = percent_gains.min()
pg_max = percent_gains.max()
positive = np.concatenate((np.arange(0, 100, 5), np.arange(100, 1100, 100)))
negative = np.linspace(-100, 0, len(positive))
bounds = | np.concatenate((negative, positive)) | numpy.concatenate |
import tensorflow as tf
from tensorflow import keras
import tensorflow_io as tfio
import numpy as np
import os
# System filepath setup
import sys
# add data folders to path
sys.path.insert(1, '../data')
sys.path.insert(1, '../src')
sys.path.insert(1, '../img')
def mel_1s_snapshot(input):
sr = 48000
a_tensor = tf.convert_to_tensor(input, dtype=tf.float32)
tensor = tf.cast(a_tensor, tf.float32)
spectrogram = tfio.experimental.audio.spectrogram(
tensor,
nfft=512,
window=512,
stride=256
)
mel_spectrogram = tfio.experimental.audio.melscale(
spectrogram,
rate=sr,
mels=128,
fmin=93.75, # 20,
fmax=13687.5) # 15000)
reshape = tf.expand_dims(mel_spectrogram.numpy(), -1)
return | np.array(reshape) | numpy.array |
"""Use k-nearest neighbors on pitch2dv0 joint data"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import os
import pandas as pd
import scipy.io as spio
import matplotlib.pyplot as plt
import time
from datetime import datetime
from sklearn import neighbors
from sklearn.metrics import confusion_matrix
import utils
train_path = "/media/linzhank/850EVO_1T/Works/Action_Recognition/Data/train/joint/"
test_path = "/media/linzhank/850EVO_1T/Works/Action_Recognition/Data/test/joint/"
TODAY = datetime.today().strftime("%Y%m%d")
result_path= "/media/linzhank/850EVO_1T/Works/Action_Recognition/Data/result{}".format(TODAY)
# Load train data
train_data = spio.loadmat(train_path + "joint_train.mat")["joint_train"]
num_examples_train = train_data.shape[0]
initid_train = utils.detectInit(train_data)
train_data = train_data.reshape(num_examples_train,150,75)
train_classes = spio.loadmat(train_path + "labels_train.mat")["labels_train"]
train_labels = np.argmax(train_classes, axis=1)
# Load test data
test_data = spio.loadmat(test_path + "joint_test.mat")["joint_test"]
num_examples_test = test_data.shape[0]
initid_test = utils.detectInit(test_data)
test_data = test_data.reshape(num_examples_test,150,75)
test_classes = spio.loadmat(test_path + "labels_test.mat")["labels_test"]
test_labels = np.argmax(test_classes, axis=1)
# Use 5, 10, 15,...,40 frames of data to train 8 knn classifier
num_frames = 5* | np.arange(1,9) | numpy.arange |
# -*- coding: utf-8 -*-
import nnabla as nn
import numpy as np
import rawdata as rdat
from tex_util import Texture
""" from nnc_proj.($$project_name_of_nnc) import network """
from nnc_proj.model import network
nn.clear_parameters()
nn.parameter.load_parameters('./nnc_proj/model.nnp')
ratios = rdat.ratios
mvec = rdat.max_vector
def estimate_sscurve(stress_roots, tex_info, num=1):
'''
return:(array_like, [rootNum, 50]) strain, stress
'''
x = nn.Variable((num, 1, 128, 128))
x2 = nn.Variable((num, 1))
y1, y2 = network(x, x2, test=True)
# RD, TD なので2つ [num, xx, '2']
rootsNum = len(stress_roots)
strain = | np.empty((num, rootsNum, 50, 2)) | numpy.empty |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Nov 16 23:34:59 2020
@author: mlampert
"""
import os
import pandas
import copy
import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages
from matplotlib.gridspec import GridSpec
import pickle
import numpy as np
import matplotlib.cm as cm
#Flap imports
import flap
import flap_nstx
flap_nstx.register()
import flap_mdsplus
#Setting up FLAP
flap_mdsplus.register('NSTX_MDSPlus')
thisdir = os.path.dirname(os.path.realpath(__file__))
fn = os.path.join(thisdir,"../flap_nstx.cfg")
flap.config.read(file_name=fn)
#Plot settings for publications
publication=True
if publication:
#figsize=(8.5/2.54,
# 8.5/2.54/1.618*1.1)
figsize=(17/2.54,10/2.54)
plt.rc('font', family='serif', serif='Helvetica')
labelsize=6
linewidth=0.5
major_ticksize=2
plt.rc('text', usetex=False)
plt.rcParams['pdf.fonttype'] = 42
plt.rcParams['ps.fonttype'] = 42
plt.rcParams['lines.linewidth'] = linewidth
plt.rcParams['axes.linewidth'] = linewidth
plt.rcParams['axes.labelsize'] = labelsize
plt.rcParams['axes.titlesize'] = labelsize
plt.rcParams['xtick.labelsize'] = labelsize
plt.rcParams['xtick.major.size'] = major_ticksize
plt.rcParams['xtick.major.width'] = linewidth
plt.rcParams['xtick.minor.width'] = linewidth/2
plt.rcParams['xtick.minor.size'] = major_ticksize/2
plt.rcParams['ytick.labelsize'] = labelsize
plt.rcParams['ytick.major.width'] = linewidth
plt.rcParams['ytick.major.size'] = major_ticksize
plt.rcParams['ytick.minor.width'] = linewidth/2
plt.rcParams['ytick.minor.size'] = major_ticksize/2
plt.rcParams['legend.fontsize'] = labelsize
else:
figsize=None
#TODO
#These are for a different analysis and a different method
#define pre ELM time
#define ELM burst time
#define the post ELM time based on the ELM burst time
#Calculate the average, maximum and the variance of the results in those time ranges
#Calculate the averaged velocity trace around the ELM time
#Calculate the correlation coefficients between the +-tau us time range around the ELM time
#Classify the ELMs based on the correlation coefficents
def plot_nstx_gpi_velocity_distribution(window_average=500e-6,
tau_range=[-500e-6,500e-6],
sampling_time=2.5e-6,
pdf=False,
plot=True,
return_results=False,
return_error=False,
plot_variance=True,
plot_error=False,
normalized_velocity=True,
normalized_structure=True,
subtraction_order=4,
opacity=0.2,
correlation_threshold=0.6,
plot_max_only=False,
plot_for_publication=False,
gpi_plane_calculation=True,
plot_scatter=True,
elm_time_base='frame similarity',
n_hist=50,
min_max_range=False,
nocalc=False,
general_plot=True,
plot_for_velocity=False,
plot_for_structure=False,
plot_for_dependence=False,
structure_finding_method='contour',
interpolation=False,
):
if elm_time_base not in ['frame similarity', 'radial velocity']:
raise ValueError('elm_time_base should be either "frame similarity" or "radial velocity"')
wd=flap.config.get_all_section('Module NSTX_GPI')['Working directory']
all_results_file=wd+'/processed_data/all_results_file.pickle'
database_file=wd+'/db/ELM_findings_mlampert_velocity_good.csv'
db=pandas.read_csv(database_file, index_col=0)
elm_index=list(db.index)
n_elm=len(elm_index)
nwin=int(window_average/sampling_time)
time_vec=(np.arange(2*nwin)*sampling_time-window_average)*1e3
all_results={'Velocity ccf':np.zeros([2*nwin,n_elm,2]),
'Velocity str max':np.zeros([2*nwin,n_elm,2]),
'Acceleration ccf':np.zeros([2*nwin,n_elm,2]),
'Frame similarity':np.zeros([2*nwin,n_elm]),
'Correlation max':np.zeros([2*nwin,n_elm]),
'Size max':np.zeros([2*nwin,n_elm,2]),
'Position max':np.zeros([2*nwin,n_elm,2]),
'Separatrix dist max':np.zeros([2*nwin,n_elm]),
'Centroid max':np.zeros([2*nwin,n_elm,2]),
'COG max':np.zeros([2*nwin,n_elm,2]),
'Area max':np.zeros([2*nwin,n_elm]),
'Elongation max':np.zeros([2*nwin,n_elm]),
'Angle max':np.zeros([2*nwin,n_elm]),
'Str number':np.zeros([2*nwin,n_elm]),
'GPI Dalpha':np.zeros([2*nwin,n_elm]),
}
hist_range_dict={'Velocity ccf':{'Radial':[-5e3,15e3],
'Poloidal':[-25e3,5e3]},
'Velocity str max':{'Radial':[-10e3,20e3],
'Poloidal':[-20e3,10e3]},
'Size max':{'Radial':[0,0.1],
'Poloidal':[0,0.1]},
'Separatrix dist max':[-0.05,0.150],
'Elongation max':[-0.5,0.5],
'Str number':[-0.5,10.5],
}
n_hist_str=int(hist_range_dict['Str number'][1]-hist_range_dict['Str number'][0])*4
result_histograms={'Velocity ccf':np.zeros([2*nwin,n_hist,2]),
'Velocity str max':np.zeros([2*nwin,n_hist,2]),
'Size max':np.zeros([2*nwin,n_hist,2]),
'Separatrix dist max':np.zeros([2*nwin,n_hist]),
'Elongation max':np.zeros([2*nwin,n_hist]),
'Str number':np.zeros([2*nwin,n_hist_str]),
}
average_results={'Velocity ccf':np.zeros([2*nwin,2]),
'Velocity str max':np.zeros([2*nwin,2]),
'Size max':np.zeros([2*nwin,2]),
'Separatrix dist max':np.zeros([2*nwin]),
'Elongation max':np.zeros([2*nwin]),
'Str number':np.zeros([2*nwin]),
}
moment_results={'average':copy.deepcopy(average_results),
'median':copy.deepcopy(average_results),
'10percentile':copy.deepcopy(average_results),
'90percentile':copy.deepcopy(average_results),
}
result_bins={'Velocity ccf':np.zeros([n_hist+1,2]),
'Velocity str max':np.zeros([n_hist+1,2]),
'Size max':np.zeros([n_hist+1,2]),
'Separatrix dist max':np.zeros([n_hist+1]),
'Elongation max':np.zeros([n_hist+1]),
'Str number':np.zeros([n_hist_str+1]),
}
coeff_r=np.asarray([3.7183594,-0.77821046,1402.8097])/1000. #The coordinates are in meters, the coefficients are in mm
coeff_z=np.asarray([0.18090118,3.0657776,70.544312])/1000. #The coordinates are in meters, the coefficients are in mm
coeff_r_new=3./800.
coeff_z_new=3./800.
if not nocalc:
for index_elm in range(n_elm):
#preprocess velocity results, tackle with np.nan and outliers
shot=int(db.loc[elm_index[index_elm]]['Shot'])
#define ELM time for all the cases
elm_time=db.loc[elm_index[index_elm]]['ELM time']/1000.
if structure_finding_method == 'contour':
str_add_find_method=''
elif structure_finding_method == 'watershed' and interpolation == False:
str_add_find_method='_nointer_watershed'
else:
str_add_find_method=''
if normalized_velocity:
if normalized_structure:
str_add='_ns'
else:
str_add=''
filename=flap_nstx.tools.filename(exp_id=shot,
working_directory=wd+'/processed_data',
time_range=[elm_time-2e-3,elm_time+2e-3],
comment='ccf_velocity_pfit_o'+str(subtraction_order)+'_fst_0.0'+str_add+'_nv'+str_add_find_method,
extension='pickle')
else:
filename=wd+'/processed_data/'+db.loc[elm_index[index_elm]]['Filename']+'.pickle'
status=db.loc[elm_index[index_elm]]['OK/NOT OK']
if status != 'NO':
velocity_results=pickle.load(open(filename, 'rb'))
velocity_results['GPI Dalpha']=velocity_results['GPI Dalpha'][0]
velocity_results['Separatrix dist avg']=np.zeros(velocity_results['Position avg'].shape[0])
velocity_results['Separatrix dist max']=np.zeros(velocity_results['Position max'].shape[0])
R_sep=flap.get_data('NSTX_MDSPlus',
name='\EFIT02::\RBDRY',
exp_id=shot,
object_name='SEP R OBJ').slice_data(slicing={'Time':elm_time}).data
z_sep=flap.get_data('NSTX_MDSPlus',
name='\EFIT02::\ZBDRY',
exp_id=shot,
object_name='SEP Z OBJ').slice_data(slicing={'Time':elm_time}).data
sep_GPI_ind=np.where(np.logical_and(R_sep > coeff_r[2],
np.logical_and(z_sep > coeff_z[2],
z_sep < coeff_z[2]+79*coeff_z[0]+64*coeff_z[1])))
try:
sep_GPI_ind=np.asarray(sep_GPI_ind[0])
sep_GPI_ind=np.insert(sep_GPI_ind,0,sep_GPI_ind[0]-1)
sep_GPI_ind=np.insert(sep_GPI_ind,len(sep_GPI_ind),sep_GPI_ind[-1]+1)
z_sep_GPI=z_sep[(sep_GPI_ind)]
R_sep_GPI=R_sep[sep_GPI_ind]
GPI_z_vert=coeff_z[0]*np.arange(80)/80*64+coeff_z[1]* | np.arange(80) | numpy.arange |
import math
import re
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
from fibber import log
from fibber.metrics.bert_lm_utils import get_lm
from fibber.paraphrase_strategies.asrs_utils_text_parser import TextParser
from fibber.paraphrase_strategies.asrs_utils_wpe import get_wordpiece_emb
from fibber.paraphrase_strategies.strategy_base import StrategyBase
logger = log.setup_custom_logger(__name__)
POST_PROCESSING_PATTERN = [
(r"\s+n\s", "n "),
(r"\s*'\s*t\s", "'t "),
(r"\s*'\s*s\s", "'s "),
(r"\s*'\s*ve\s", "'ve "),
(r"\s*'\s*ll\s", "'ll "),
(r"\s*n't\s", "n't "),
(r"- -", "--"),
(r"\s*([\.,?!])", r"\1"),
(r"\s+-\s+", "-"),
]
PRE_PROCESSING_PATTERN = [
(r"can't\s", r" cannot "),
(r"won't\s", r" will not "),
(r"n't\s", r" not "),
(r"'ll\s", r" will "),
(r"'ve\s", r" have "),
]
AUTO_SENTENCE_LEN_THRESHOLD = 50 # 50 words
def process_text(text, patterns):
"""Processing the text using regex patterns.
Args:
text (str): the str to be post processed.
patterns (list): a list of substitution patterns.
"""
for pattern in patterns:
text = re.sub(pattern[0], pattern[1], text)
return text
def tostring(tokenizer, seq):
"""Convert a sequence of word ids to a sentence. The post prossing is applied.
Args:
tokenizer (transformers.BertTokenizer): a BERT tokenizer.
seq (list): a list-like sequence of word ids.
"""
return process_text(tokenizer.decode(seq), POST_PROCESSING_PATTERN)
def sample_word_from_logits(logits, temperature=1., top_k=0):
"""Sample a word from a distribution.
Args:
logits (torch.Tensor): tensor of logits with size ``(batch_size, vocab_size)``.
temperature (float): the temperature of softmax. The PMF is
``softmax(logits/temperature)``.
top_k (int): if ``k>0``, only sample from the top k most probable words.
"""
logits = logits / temperature
if top_k > 0:
kth_vals, kth_idx = logits.topk(top_k, dim=-1)
dist = torch.distributions.categorical.Categorical(logits=kth_vals)
idx = kth_idx.gather(dim=1, index=dist.sample().unsqueeze(-1)).squeeze(-1)
else:
dist = torch.distributions.categorical.Categorical(logits=logits)
idx = dist.sample().squeeze(-1)
return idx
def all_accept_criteria(candidate_ids, stats, **kargs):
"""Always accept proposed words.
Args:
candidate_ids (torch.Tensor): proposed word ids in this sampling step with
size ``(batch_size, pos_ed-pos_st)``.
stats (dict): a dict to keep track the accept rate.
Returns:
(np.array, None)
np.array is the same as candidate_ids.
None means this criteria does not have any state.
"""
stats["accept"] += len(candidate_ids)
stats["all"] += len(candidate_ids)
return candidate_ids, None
def sim_criteria_score(origin, paraphrases, sim_metric, sim_threshold, sim_weight):
"""Estimate the score of a sentence using USE.
Args:
origin (str): original sentence.
paraphrases ([str]): a list of paraphrase_list.
sim_metric (MetricBase): a similarity metric object.
sim_threshold (float): the universal sentence encoder similarity threshold.
sim_weight (float): the weight parameter for the criteria.
Returns:
(np.array): a numpy array of size ``(batch_size,)``. All entries ``<=0``.
"""
if sim_weight == 0:
return np.zeros(len(paraphrases), dtype="float32")
use_semantic_similarity = sim_metric.measure_batch(origin, paraphrases)
return -sim_weight * (
np.maximum(sim_threshold - np.asarray(use_semantic_similarity), 0) ** 2)
def ppl_criteria_score(origin, paraphrases, ppl_metric, ppl_weight):
"""Estimate the score of a sentence using USE.
Args:
origin (str): original sentence.
paraphrases ([str]): a list of paraphrase_list.
ppl_metric (GPT2PerplexityMetric): a GPT2PerplexityMetric metric object.
ppl_weight (float): the weight parameter for the criteria.
Returns:
(np.array): a numpy array of size ``(batch_size,)``. All entries ``<=0``.
"""
if ppl_weight == 0:
return np.zeros(len(paraphrases), dtype="float32")
ppl_ratio = ppl_metric.measure_batch(origin, paraphrases)
return -ppl_weight * (np.maximum( | np.asarray(ppl_ratio) | numpy.asarray |
import pytest
import torch
import sklearn.metrics
import numpy as np
from flambe.metric import Accuracy, AUC, MultiClassAUC, Perplexity, BPC, F1
from flambe.metric import BinaryRecall, BinaryPrecision, BinaryAccuracy
from flambe.metric import Recall
from pytest import approx
NUMERIC_PRECISION = 1e-2
def metric_test_case(predicted, true, metric, expected):
assert metric(predicted, true).item() == approx(expected, NUMERIC_PRECISION)
def test_auc_full():
"""Test random score list."""
y_pred = np.random.randint(0, 10000, 100)
y_true = np.random.randint(0, 2, 100)
metric_test_case(y_pred, y_true, AUC(), sklearn.metrics.roc_auc_score(y_true, y_pred))
def test_auc_threshold():
"""To compute rates:
-> fpr: number of false positives / total number of negatives
-> tpr: number of true positives / total number of positives
In this example, consider the first threshold of 0.1, and consider everything
higher than 0.1 as positives, and everything lower as negatives:
fpr = 1 / 2 = 0.5
tpr = 1
Thus, if the max_fpr rate is 0.1, the tpr is 0, and if the max_fpr is 0.5,
then the tpr is 1. So we get an auc of 0 for the 0.1 threshold, and 0.5
for the 0.5 threshold.
For more details: https://en.wikipedia.org/wiki/Receiver_operating_characteristic
"""
y_pred = torch.tensor([0.1, 0.2, 0.3, 0.4])
y_true = torch.tensor([0, 1, 0, 1])
metric_test_case(y_pred, y_true, AUC(max_fpr=1.), sklearn.metrics.roc_auc_score(y_true, y_pred))
metric_test_case(y_pred, y_true, AUC(max_fpr=0.500001), 0.5)
metric_test_case(y_pred, y_true, AUC(max_fpr=0.1), 0.5)
def test_auc_empty():
"""Should be completely random on an empty list"""
y_pred = torch.tensor([])
y_true = torch.tensor([])
auc = AUC()
assert auc(y_pred, y_true).item() == approx(0.5, NUMERIC_PRECISION)
def test_multiclass_auc_full_one_hot():
"""simple base case with one-hot labels"""
n_classes = 100
y_pred = np.random.uniform(0, 1, (100, n_classes))
y_true = np.zeros((100, n_classes))
y_true[np.arange(100), np.random.randint(n_classes)] = 1
sklearn_score = sklearn.metrics.roc_auc_score(y_true.flatten(), y_pred.flatten())
metric_test_case(torch.tensor(y_pred), torch.tensor(y_true), MultiClassAUC(), sklearn_score)
def test_multiclass_auc_full_indexed():
"""simple base case with index labels"""
n_classes = 100
y_pred = np.random.uniform(0, 1, (100, n_classes))
y_true = | np.random.randint(0, n_classes, 100) | numpy.random.randint |
"""
Copyright (c) 2019, <NAME> and the respective contributors
All rights reserved.
Use of this source code is governed by a MIT license that can be found
in the LICENSE.txt file.
"""
import numpy as np
import copy
################################################################################################### optimizers
class Optimizer:
def optimize(self,w,dw):
pass
#gradient descent algorithm using only gradient sign
class OptimizerStep(Optimizer):
lr = 0.01
def optimize(self,w,dw):
return w - np.sign(dw) * self.lr
#classical gradient descent algorithm
class OptimizerSGD(Optimizer):
lr = 0.01
def optimize(self,w,dw):
return w - dw * self.lr
# Momentum from https://cs231n.github.io/neural-networks-3/#sgd
# simplification of below Ng momentum, (avoid one mult)
class OptimizerMomentum(Optimizer):
lr = 0.01 # is 0.1*(1-momentum)
momentum = 0.9
init = False
def optimize(self,w,dw):
if not self.init:
self.v = dw
self.init = True
self.v = self.v * self.momentum + dw * self.lr
return w - self.v
# Andrew Ng definition of momentum
class OptimizerMomentumNg(Optimizer):
lr = 0.1 # can be high since gradient is smoothed
momentum = 0.9
init = False
def optimize(self,w,dw):
if not self.init:
self.v = dw
self.init = True
self.v = self.v * self.momentum + dw * (1.-self.momentum) #recursive averaging
return w - self.v*self.lr # sgd update step with smoothed gradient
# Nesterov from https://cs231n.github.io/neural-networks-3/#sgd
class OptimizerNesterov(Optimizer):
lr = 0.01
momentum = 0.9
init = False
def optimize(self,w,dw):
if not self.init:
self.v = 0. * w
self.init = True
v_prev = self.v # back this up
self.v = self.momentum * self.v - self.lr * dw # velocity update stays the same
w += -self.momentum * v_prev + (1. + self.momentum) * self.v # position update changes form
return w
# RPROP- as in : https://pdfs.semanticscholar.org/df9c/6a3843d54a28138a596acc85a96367a064c2.pdf
# or in paper : Improving the Rprop Learning Algorithm (<NAME> and <NAME>)
class OptimizerRPROPm(Optimizer):
init = False
def optimize(self,w,dw):
if not self.init:
self.mu = 0.0125 * | np.ones(w.shape) | numpy.ones |
"""
Compare preformance of methods within certain running time.
Author(s): <NAME> (<EMAIL>)
"""
import argparse
import os
import itertools
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams.update({'font.size': 18})
if __name__ == "__main__":
# Arguments
parser = argparse.ArgumentParser(description='Optimize')
parser.add_argument('--n_runs', type=int, default=10, help='number of runs')
parser.add_argument('--n_eval', type=int, default=500, help='number of evaluations per run')
args = parser.parse_args()
n_runs = args.n_runs
n_eval = args.n_eval
''' Call optimization '''
for latent_dim in [2, 4, 6, 8, 10]:
if not os.path.exists('./results_opt/gan_bo_refine_{}_10/opt_history.npy'.format(latent_dim)) or not os.path.exists('./results_opt/gan_bo_refine_{}_10/opt_airfoil.npy'.format(latent_dim)):
os.system('python optimize_gan_bo_refine.py {} 10 --n_runs={} --n_eval={}'.format(latent_dim, args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/gan_bo_8_0/opt_history.npy') or not os.path.exists('./results_opt/gan_bo_8_0/opt_airfoil.npy'):
os.system('python optimize_gan_bo.py 8 0 --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/gan_bo_refine_8_20/opt_history.npy') or not os.path.exists('./results_opt/gan_bo_refine_8_20/opt_airfoil.npy'):
os.system('python optimize_gan_bo_refine.py 8 20 --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
for latent_dim in [2, 4, 6, 8, 10]:
if not os.path.exists('./results_opt/gan_bo_{}_10/opt_history.npy'.format(latent_dim)) or not os.path.exists('./results_opt/gan_bo_{}_10/opt_airfoil.npy'.format(latent_dim)):
os.system('python optimize_gan_bo.py {} 10 --n_runs={} --n_eval={}'.format(latent_dim, args.n_runs, args.n_eval))
for dim in [6, 8, 10, 12]:
if not os.path.exists('./results_opt/generic_bo_{}/opt_history.npy'.format(dim)) or not os.path.exists('./results_opt/generic_bo_{}/opt_airfoil.npy'.format(dim)):
os.system('python optimize_generic_bo.py {} --n_runs={} --n_eval={}'.format(dim, args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/generic_ga_8/opt_history.npy') or not os.path.exists('./results_opt/generic_ga_8/opt_airfoil.npy'):
os.system('python optimize_generic_ga.py 8 --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
for dim in [8, 9, 10]:
if not os.path.exists('./results_opt/svd_bo_{}/opt_history.npy'.format(dim)) or not os.path.exists('./results_opt/svd_bo_{}/opt_airfoil.npy'.format(dim)):
os.system('python optimize_svd_bo.py {} --n_runs={} --n_eval={}'.format(dim, args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/svd_ga_9/opt_history.npy') or not os.path.exists('./results_opt/svd_ga_9/opt_airfoil.npy'):
os.system('python optimize_svd_ga.py 9 --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/nurbs_bo/opt_history.npy') or not os.path.exists('./results_opt/nurbs_bo/opt_airfoil.npy'):
os.system('python optimize_nurbs_bo.py --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/nurbs_ga/opt_history.npy') or not os.path.exists('./results_opt/nurbs_ga/opt_airfoil.npy'):
os.system('python optimize_nurbs_ga.py --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/ffd_bo/opt_history.npy') or not os.path.exists('./results_opt/ffd_bo/opt_airfoil.npy'):
os.system('python optimize_ffd_bo.py --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
if not os.path.exists('./results_opt/ffd_ga/opt_history.npy') or not os.path.exists('./results_opt/ffd_ga/opt_airfoil.npy'):
os.system('python optimize_ffd_ga.py --n_runs={} --n_eval={}'.format(args.n_runs, args.n_eval))
''' Plot history '''
gan_bo_2_10_hist = np.load('results_opt/gan_bo_2_10/opt_history.npy')
gan_bo_4_10_hist = np.load('results_opt/gan_bo_4_10/opt_history.npy')
gan_bo_6_10_hist = np.load('results_opt/gan_bo_6_10/opt_history.npy')
gan_bo_8_10_hist = np.load('results_opt/gan_bo_8_10/opt_history.npy')
gan_bo_10_10_hist = np.load('results_opt/gan_bo_10_10/opt_history.npy')
gan_bo_refine_2_10_hist = np.load('results_opt/gan_bo_refine_2_10/opt_history.npy')
gan_bo_refine_4_10_hist = np.load('results_opt/gan_bo_refine_4_10/opt_history.npy')
gan_bo_refine_6_10_hist = np.load('results_opt/gan_bo_refine_6_10/opt_history.npy')
gan_bo_refine_8_10_hist = np.load('results_opt/gan_bo_refine_8_10/opt_history.npy')
gan_bo_refine_10_10_hist = np.load('results_opt/gan_bo_refine_10_10/opt_history.npy')
gan_bo_8_0_hist = np.load('results_opt/gan_bo_8_0/opt_history.npy')
gan_bo_refine_8_20_hist = np.load('results_opt/gan_bo_refine_8_20/opt_history.npy')
generic_bo_6_hist = np.load('results_opt/generic_bo_6/opt_history.npy')
generic_bo_8_hist = np.load('results_opt/generic_bo_8/opt_history.npy')
generic_bo_10_hist = np.load('results_opt/generic_bo_10/opt_history.npy')
generic_bo_12_hist = np.load('results_opt/generic_bo_12/opt_history.npy')
generic_ga_8_hist = np.load('results_opt/generic_ga_8/opt_history.npy')
svd_bo_8_hist = np.load('results_opt/svd_bo_8/opt_history.npy')
svd_bo_9_hist = np.load('results_opt/svd_bo_9/opt_history.npy')
svd_bo_10_hist = np.load('results_opt/svd_bo_10/opt_history.npy')
svd_ga_9_hist = np.load('results_opt/svd_ga_9/opt_history.npy')
nurbs_bo_hist = np.load('results_opt/nurbs_bo/opt_history.npy')
nurbs_ga_hist = np.load('results_opt/nurbs_ga/opt_history.npy')
ffd_bo_hist = np.load('results_opt/ffd_bo/opt_history.npy')
ffd_ga_hist = np.load('results_opt/ffd_ga/opt_history.npy')
mean_gan_bo_2_10_hist = np.mean(gan_bo_2_10_hist, axis=0)
std_gan_bo_2_10_hist = np.std(gan_bo_2_10_hist, axis=0)
mean_gan_bo_4_10_hist = np.mean(gan_bo_4_10_hist, axis=0)
std_gan_bo_4_10_hist = np.std(gan_bo_4_10_hist, axis=0)
mean_gan_bo_6_10_hist = np.mean(gan_bo_6_10_hist, axis=0)
std_gan_bo_6_10_hist = np.std(gan_bo_6_10_hist, axis=0)
mean_gan_bo_8_10_hist = np.mean(gan_bo_8_10_hist, axis=0)
std_gan_bo_8_10_hist = np.std(gan_bo_8_10_hist, axis=0)
mean_gan_bo_10_10_hist = np.mean(gan_bo_10_10_hist, axis=0)
std_gan_bo_10_10_hist = np.std(gan_bo_10_10_hist, axis=0)
mean_gan_bo_refine_2_10_hist = np.mean(gan_bo_refine_2_10_hist, axis=0)
std_gan_bo_refine_2_10_hist = np.std(gan_bo_refine_2_10_hist, axis=0)
mean_gan_bo_refine_4_10_hist = np.mean(gan_bo_refine_4_10_hist, axis=0)
std_gan_bo_refine_4_10_hist = np.std(gan_bo_refine_4_10_hist, axis=0)
mean_gan_bo_refine_6_10_hist = np.mean(gan_bo_refine_6_10_hist, axis=0)
std_gan_bo_refine_6_10_hist = np.std(gan_bo_refine_6_10_hist, axis=0)
mean_gan_bo_refine_8_10_hist = np.mean(gan_bo_refine_8_10_hist, axis=0)
std_gan_bo_refine_8_10_hist = np.std(gan_bo_refine_8_10_hist, axis=0)
mean_gan_bo_refine_10_10_hist = np.mean(gan_bo_refine_10_10_hist, axis=0)
std_gan_bo_refine_10_10_hist = np.std(gan_bo_refine_10_10_hist, axis=0)
mean_gan_bo_8_0_hist = np.mean(gan_bo_8_0_hist, axis=0)
std_gan_bo_8_0_hist = np.std(gan_bo_8_0_hist, axis=0)
mean_gan_bo_refine_8_20_hist = np.mean(gan_bo_refine_8_20_hist, axis=0)
std_gan_bo_refine_8_20_hist = np.std(gan_bo_refine_8_20_hist, axis=0)
mean_generic_bo_6_hist = np.mean(generic_bo_6_hist, axis=0)
std_generic_bo_6_hist = np.std(generic_bo_6_hist, axis=0)
mean_generic_bo_8_hist = np.mean(generic_bo_8_hist, axis=0)
std_generic_bo_8_hist = np.std(generic_bo_8_hist, axis=0)
mean_generic_bo_10_hist = np.mean(generic_bo_10_hist, axis=0)
std_generic_bo_10_hist = np.std(generic_bo_10_hist, axis=0)
mean_generic_bo_12_hist = np.mean(generic_bo_12_hist, axis=0)
std_generic_bo_12_hist = np.std(generic_bo_12_hist, axis=0)
mean_generic_ga_8_hist = np.mean(generic_ga_8_hist, axis=0)
std_generic_ga_8_hist = np.std(generic_ga_8_hist, axis=0)
mean_svd_bo_8_hist = np.mean(svd_bo_8_hist, axis=0)
std_svd_bo_8_hist = np.std(svd_bo_8_hist, axis=0)
mean_svd_bo_9_hist = np.mean(svd_bo_9_hist, axis=0)
std_svd_bo_9_hist = np.std(svd_bo_9_hist, axis=0)
mean_svd_bo_10_hist = np.mean(svd_bo_10_hist, axis=0)
std_svd_bo_10_hist = np.std(svd_bo_10_hist, axis=0)
mean_svd_ga_9_hist = np.mean(svd_ga_9_hist, axis=0)
std_svd_ga_9_hist = np.std(svd_ga_9_hist, axis=0)
mean_nurbs_bo_hist = np.mean(nurbs_bo_hist, axis=0)
std_nurbs_bo_hist = np.std(nurbs_bo_hist, axis=0)
mean_nurbs_ga_hist = np.mean(nurbs_ga_hist, axis=0)
std_nurbs_ga_hist = np.std(nurbs_ga_hist, axis=0)
mean_ffd_bo_hist = np.mean(ffd_bo_hist, axis=0)
std_ffd_bo_hist = np.std(ffd_bo_hist, axis=0)
mean_ffd_ga_hist = np.mean(ffd_ga_hist, axis=0)
std_ffd_ga_hist = np.std(ffd_ga_hist, axis=0)
linestyles = ['-', '--', ':', '-.', (0, (5,1,1,1,1,1)), (0, (1,4))]
lss = itertools.cycle(linestyles)
iters = np.arange(n_eval+1, dtype=int)
diff_2 = gan_bo_refine_2_10_hist - gan_bo_2_10_hist
mean_diff_2 = np.mean(diff_2, axis=0)
std_diff_2 = np.std(diff_2, axis=0)
diff_4 = gan_bo_refine_4_10_hist - gan_bo_4_10_hist
mean_diff_4 = np.mean(diff_4, axis=0)
std_diff_4 = np.std(diff_4, axis=0)
diff_6 = gan_bo_refine_6_10_hist - gan_bo_6_10_hist
mean_diff_6 = np.mean(diff_6, axis=0)
std_diff_6 = np.std(diff_6, axis=0)
diff_8 = gan_bo_refine_8_10_hist - gan_bo_8_10_hist
mean_diff_8 = np.mean(diff_8, axis=0)
std_diff_8 = np.std(diff_8, axis=0)
diff_10 = gan_bo_refine_10_10_hist - gan_bo_10_10_hist
mean_diff_10 = np.mean(diff_10, axis=0)
std_diff_10 = np.std(diff_10, axis=0)
plt.figure(figsize=(10,5))
plt.plot(iters, mean_gan_bo_6_10_hist, ls=next(lss), label='OSO', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_6_10_hist-std_gan_bo_6_10_hist, mean_gan_bo_6_10_hist+std_gan_bo_6_10_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_gan_bo_refine_6_10_hist, ls=next(lss), label='TSO', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_6_10_hist-std_gan_bo_refine_6_10_hist, mean_gan_bo_refine_6_10_hist+std_gan_bo_refine_6_10_hist, alpha=.2, color='0.6')
plt.legend(frameon=False, title='Latent dim.')
plt.title('Performance History')
plt.xlabel('Number of Evaluations')
plt.ylabel(r'$C_L/C_D$')
# plt.xticks(np.linspace(0, max_n_eval+1, 5, dtype=int))
plt.tight_layout()
plt.savefig('results_opt/opt_history_refine_6.svg')
plt.savefig('results_opt/opt_history_refine_6.pdf', dpi=600)
plt.close()
list_latent_dim = [2, 4, 6, 8, 10]
list_mean = [mean_gan_bo_2_10_hist[-1],
mean_gan_bo_4_10_hist[-1],
mean_gan_bo_6_10_hist[-1],
mean_gan_bo_8_10_hist[-1],
mean_gan_bo_10_10_hist[-1]]
list_std = [std_gan_bo_2_10_hist[-1],
std_gan_bo_4_10_hist[-1],
std_gan_bo_6_10_hist[-1],
std_gan_bo_8_10_hist[-1],
std_gan_bo_10_10_hist[-1]]
list_mean_refine = [mean_gan_bo_refine_2_10_hist[-1],
mean_gan_bo_refine_4_10_hist[-1],
mean_gan_bo_refine_6_10_hist[-1],
mean_gan_bo_refine_8_10_hist[-1],
mean_gan_bo_refine_10_10_hist[-1]]
list_std_refine = [std_gan_bo_refine_2_10_hist[-1],
std_gan_bo_refine_4_10_hist[-1],
std_gan_bo_refine_6_10_hist[-1],
std_gan_bo_refine_8_10_hist[-1],
std_gan_bo_refine_10_10_hist[-1]]
plt.figure(figsize=(5,5))
plt.bar(np.array(list_latent_dim)-.3, list_mean, width=.6, yerr=list_std, label='One-stage opt.', color='0.7')
plt.bar(np.array(list_latent_dim)+.3, list_mean_refine, width=.6, yerr=list_std_refine, label='Two-stage opt.', color='0.3')
plt.legend(frameon=False)
plt.ylim([50, 350])
plt.xticks(list_latent_dim)
plt.xlabel('Latent dimension')
plt.ylabel(r'Max. $C_L/C_D$')
plt.tight_layout()
plt.savefig('results_opt/opt_refine.svg')
plt.savefig('results_opt/opt_refine.pdf', dpi=600)
plt.close()
lss = itertools.cycle(linestyles)
plt.figure(figsize=(7,5))
plt.plot(iters, mean_diff_2, ls=next(lss), label='2', c='k', alpha=.7)
plt.fill_between(iters, mean_diff_2-std_diff_2, mean_diff_2+std_diff_2, alpha=.2, color='0.6')
# plt.plot(iters, mean_diff_4, ls=next(lss), label='4', c='k', alpha=.7)
# plt.fill_between(iters, mean_diff_4-std_diff_4, mean_diff_4+std_diff_4, alpha=.2, color='0.6')
# plt.plot(iters, mean_diff_6, ls=next(lss), label='6', c='k', alpha=.7)
# plt.fill_between(iters, mean_diff_6-std_diff_6, mean_diff_6+std_diff_6, alpha=.2, color='0.6')
plt.plot(iters, mean_diff_8, ls=next(lss), label='8', c='k', alpha=.7)
plt.fill_between(iters, mean_diff_8-std_diff_8, mean_diff_8+std_diff_8, alpha=.2, color='0.6')
# plt.plot(iters, mean_diff_10, ls=next(lss), label='10', c='k', alpha=.7)
# plt.fill_between(iters, mean_diff_10-std_diff_10, mean_diff_10+std_diff_10, alpha=.2, color='0.6')
plt.axhline(y=0., color='r', ls=next(lss), alpha=.7)
plt.legend(frameon=False, title='Latent dim.')
plt.title('Performance Improvement History')
plt.xlabel('Number of Evaluations')
plt.ylabel(r'$\Delta$ ($C_L/C_D$)')
# plt.xticks(np.linspace(0, max_n_eval+1, 5, dtype=int))
plt.tight_layout()
plt.savefig('results_opt/opt_history_refine.svg')
plt.savefig('results_opt/opt_history_refine.pdf', dpi=600)
plt.close()
lss = itertools.cycle(linestyles)
plt.figure(figsize=(10,5))
plt.plot(iters, mean_gan_bo_refine_8_10_hist, ls=next(lss), label=r'B$\acute{e}$zier-GAN+TSO', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_8_10_hist-std_gan_bo_refine_8_10_hist, mean_gan_bo_refine_8_10_hist+std_gan_bo_refine_8_10_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_generic_bo_8_hist, ls=next(lss), label='GMDV+EGO', c='k', alpha=.7)
plt.fill_between(iters, mean_generic_bo_8_hist-std_generic_bo_8_hist, mean_generic_bo_8_hist+std_generic_bo_8_hist, alpha=.2, color='0.6')
# plt.plot(iters, mean_generic_ga_8_hist, ls=next(lss), label='GMDV+GA')
# plt.fill_between(iters, mean_generic_ga_8_hist-std_generic_ga_8_hist, mean_generic_ga_8_hist+std_generic_ga_8_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_svd_bo_9_hist, ls=next(lss), label='SVD+EGO', c='k', alpha=.7)
plt.fill_between(iters, mean_svd_bo_9_hist-std_svd_bo_9_hist, mean_svd_bo_9_hist+std_svd_bo_9_hist, alpha=.2, color='0.6')
# plt.plot(iters, mean_svd_ga_9_hist, ls=next(lss), label='SVD+GA', c='k', alpha=.7)
# plt.fill_between(iters, mean_svd_ga_9_hist-std_svd_ga_9_hist, mean_svd_ga_9_hist+std_svd_ga_9_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_ffd_bo_hist, ls=next(lss), label='FFD+EGO', c='k', alpha=.7)
plt.fill_between(iters, mean_ffd_bo_hist-std_ffd_bo_hist, mean_ffd_bo_hist+std_ffd_bo_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_ffd_ga_hist, ls=next(lss), label='FFD+GA', c='k', alpha=.7)
plt.fill_between(iters, mean_ffd_ga_hist-std_ffd_ga_hist, mean_ffd_ga_hist+std_ffd_ga_hist, alpha=.2, color='0.6')
plt.legend(frameon=False)
plt.title('Optimization History')
plt.xlabel('Number of Evaluations')
plt.ylabel(r'$C_L/C_D$')
plt.ylim(ymax=300)
# plt.xticks(np.linspace(0, max_n_eval+1, 5, dtype=int))
plt.tight_layout()
plt.savefig('results_opt/opt_history_conventional.svg')
plt.savefig('results_opt/opt_history_conventional.pdf', dpi=600)
plt.close()
lss = itertools.cycle(linestyles)
plt.figure(figsize=(10,5))
plt.plot(iters, mean_gan_bo_refine_2_10_hist, ls=next(lss), label='2', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_2_10_hist-std_gan_bo_refine_2_10_hist, mean_gan_bo_refine_2_10_hist+std_gan_bo_refine_2_10_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_gan_bo_refine_4_10_hist, ls=next(lss), label='4', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_4_10_hist-std_gan_bo_refine_4_10_hist, mean_gan_bo_refine_4_10_hist+std_gan_bo_refine_4_10_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_gan_bo_refine_6_10_hist, ls=next(lss), label='6', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_6_10_hist-std_gan_bo_refine_6_10_hist, mean_gan_bo_refine_6_10_hist+std_gan_bo_refine_6_10_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_gan_bo_refine_8_10_hist, ls=next(lss), label='8', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_8_10_hist-std_gan_bo_refine_8_10_hist, mean_gan_bo_refine_8_10_hist+std_gan_bo_refine_8_10_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_gan_bo_refine_10_10_hist, ls=next(lss), label='10', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_10_10_hist-std_gan_bo_refine_10_10_hist, mean_gan_bo_refine_10_10_hist+std_gan_bo_refine_10_10_hist, alpha=.2, color='0.6')
plt.legend(frameon=False, title='Latent dim.')
plt.title('Optimization History')
plt.xlabel('Number of Evaluations')
plt.ylabel(r'$C_L/C_D$')
plt.ylim(ymax=300)
# plt.xticks(np.linspace(0, max_n_eval+1, 5, dtype=int))
plt.tight_layout()
plt.savefig('results_opt/opt_history_latent.svg')
plt.savefig('results_opt/opt_history_latent.pdf', dpi=600)
plt.close()
lss = itertools.cycle(linestyles)
plt.figure(figsize=(10,5))
plt.plot(iters, mean_gan_bo_8_0_hist, ls=next(lss), label='0', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_8_0_hist-std_gan_bo_8_0_hist, mean_gan_bo_8_0_hist+std_gan_bo_8_0_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_gan_bo_refine_8_10_hist, ls=next(lss), label='10', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_8_10_hist-std_gan_bo_refine_8_10_hist, mean_gan_bo_refine_8_10_hist+std_gan_bo_refine_8_10_hist, alpha=.2, color='0.6')
plt.plot(iters, mean_gan_bo_refine_8_20_hist, ls=next(lss), label='20', c='k', alpha=.7)
plt.fill_between(iters, mean_gan_bo_refine_8_20_hist-std_gan_bo_refine_8_20_hist, mean_gan_bo_refine_8_20_hist+std_gan_bo_refine_8_20_hist, alpha=.2, color='0.6')
plt.legend(frameon=False, title='Noise dim.')
plt.title('Optimization History')
plt.xlabel('Number of Evaluations')
plt.ylabel(r'$C_L/C_D$')
plt.ylim(ymax=300)
# plt.xticks(np.linspace(0, max_n_eval+1, 5, dtype=int))
plt.tight_layout()
plt.savefig('results_opt/opt_history_noise.svg')
plt.savefig('results_opt/opt_history_noise.pdf', dpi=600)
plt.close()
''' Plot optimal solutions '''
gan_bo_4_10_opt = np.load('results_opt/gan_bo_4_10/opt_airfoil.npy')
gan_bo_refine_2_10_opt = np.load('results_opt/gan_bo_refine_2_10/opt_airfoil.npy')
gan_bo_refine_4_10_opt = np.load('results_opt/gan_bo_refine_4_10/opt_airfoil.npy')
gan_bo_refine_6_10_opt = np.load('results_opt/gan_bo_refine_6_10/opt_airfoil.npy')
gan_bo_refine_8_10_opt = np.load('results_opt/gan_bo_refine_8_10/opt_airfoil.npy')
gan_bo_refine_10_10_opt = np.load('results_opt/gan_bo_refine_10_10/opt_airfoil.npy')
gan_bo_8_0_opt = np.load('results_opt/gan_bo_8_0/opt_airfoil.npy')
gan_bo_refine_8_10_opt = np.load('results_opt/gan_bo_refine_8_10/opt_airfoil.npy')
gan_bo_refine_8_20_opt = np.load('results_opt/gan_bo_refine_8_20/opt_airfoil.npy')
generic_bo_8_opt = np.load('results_opt/generic_bo_8/opt_airfoil.npy')
generic_ga_8_opt = | np.load('results_opt/generic_ga_8/opt_airfoil.npy') | numpy.load |
import numpy as np
import os
import matplotlib.pyplot as plt
import sklearn.datasets as skld
import sklearn.model_selection as sklms
import sklearn.ensemble as skle
from bayeso import bo
from bayeso.utils import utils_bo
from bayeso.utils import utils_common
from bayeso.utils import utils_plotting
from bayeso import constants
STR_FUN_TARGET = 'real1'
INT_BO = 20
INT_ITER = 50
INT_INIT = 3
data = skld.fetch_olivetti_faces()
images = data.images
targets = data.target
print(images.shape)
print(targets.shape)
X_train, X_test, y_train, y_test = sklms.train_test_split(images, targets, test_size=0.2, random_state=42, stratify=targets)
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1] * X_train.shape[2]))
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1] * X_test.shape[2]))
def fun_target(X):
print(X)
model_ = skle.RandomForestClassifier(n_estimators=int(X[0]), max_depth=int(X[1]), min_samples_split=int(X[2]), max_features=float(X[3]), random_state=42)
model_.fit(X_train, y_train)
y_pred = model_.predict(X_test)
score_ = 1.0 - np.mean(y_pred == y_test)
print(score_)
return score_
def main(str_optimizer_method_gp, str_mlm_method, str_ms_method, int_bo, int_iter, int_init):
bounds = np.array([
[10, 100],
[2.01, 5],
[2.01, 6],
[0.001, 1],
])
list_Y = []
list_time = []
for ind_bo in range(0, int_bo):
print('BO Iteration', ind_bo)
model_bo = bo.BO(bounds, str_optimizer_method_gp=str_optimizer_method_gp, debug=False)
X_final, Y_final, time_final = utils_bo.optimize_many_with_random_init(model_bo, fun_target, int_init, int_iter, str_initial_method_bo='uniform', str_initial_method_ao='uniform', int_samples_ao=100, str_mlm_method=str_mlm_method, str_modelselection_method=str_ms_method, int_seed=77*(ind_bo+1))
list_Y.append(Y_final)
list_time.append(time_final)
arr_Y = np.array(list_Y)
if int_bo == 1:
arr_Y = np.expand_dims( | np.squeeze(arr_Y) | numpy.squeeze |
from __future__ import print_function
import numpy as NP
"""
A module which implements the continuous wavelet transform
---------------------------------------------------------
Code released under the BSD 3-clause licence.
Copyright (c) 2012, <NAME>, University of Cape Town
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the University of Cape Town nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------
Wavelet classes:
Morlet
MorletReal
MexicanHat
Paul2 : Paul order 2
Paul4 : Paul order 4
DOG1 : 1st Derivative Of Gaussian
DOG4 : 4th Derivative Of Gaussian
Haar : Unnormalised version of continuous Haar transform
HaarW : Normalised Haar
Usage e.g.
wavelet=Morlet(data, largestscale=2, notes=0, order=2, scaling="log")
data: Numeric array of data (float), with length ndata.
Optimum length is a power of 2 (for FFT)
Worst-case length is a prime
largestscale:
largest scale as inverse fraction of length
scale = len(data)/largestscale
smallest scale should be >= 2 for meaningful data
notes: number of scale intervals per octave
if notes == 0, scales are on a linear increment
order: order of wavelet for wavelets with variable order
[Paul, DOG, ..]
scaling: "linear" or "log" scaling of the wavelet scale.
Note that feature width in the scale direction
is constant on a log scale.
Attributes of instance:
wavelet.cwt: 2-d array of Wavelet coefficients, (nscales,ndata)
wavelet.nscale: Number of scale intervals
wavelet.scales: Array of scale values
Note that meaning of the scale will depend on the family
wavelet.fourierwl: Factor to multiply scale by to get scale
of equivalent FFT
Using this factor, different wavelet families will
have comparable scales
References:
A practical guide to wavelet analysis
C Torrance and GP Compo
Bull Amer Meteor Soc Vol 79 No 1 61-78 (1998)
naming below vaguely follows this.
updates:
(24/2/07): Fix Morlet so can get MorletReal by cutting out H
(10/04/08): Numeric -> numpy
(25/07/08): log and lin scale increment in same direction!
swap indices in 2-d coeffiecient matrix
explicit scaling of scale axis
"""
class Cwt:
"""
Base class for continuous wavelet transforms
Implements cwt via the Fourier transform
Used by subclass which provides the method wf(self,s_omega)
wf is the Fourier transform of the wavelet function.
Returns an instance.
"""
fourierwl=1.00
def _log2(self, x):
# utility function to return (integer) log2
return int( NP.log(float(x))/ NP.log(2.0)+0.0001 )
def __init__(self, data, largestscale=1, notes=0, order=2, scaling='linear'):
"""
Continuous wavelet transform of data
data: data in array to transform, length must be power of 2
notes: number of scale intervals per octave
largestscale: largest scale as inverse fraction of length
of data array
scale = len(data)/largestscale
smallest scale should be >= 2 for meaningful data
order: Order of wavelet basis function for some families
scaling: Linear or log
"""
ndata = len(data)
self.order=order
self.scale=largestscale
self._setscales(ndata,largestscale,notes,scaling)
self.cwt= NP.zeros((self.nscale,ndata), NP.complex64)
omega= NP.array(range(0,ndata/2)+range(-ndata/2,0))*(2.0*NP.pi/ndata)
datahat=NP.fft.fft(data)
self.fftdata=datahat
#self.psihat0=self.wf(omega*self.scales[3*self.nscale/4])
# loop over scales and compute wvelet coeffiecients at each scale
# using the fft to do the convolution
for scaleindex in range(self.nscale):
currentscale=self.scales[scaleindex]
self.currentscale=currentscale # for internal use
s_omega = omega*currentscale
psihat=self.wf(s_omega)
psihat = psihat * NP.sqrt(2.0*NP.pi*currentscale)
convhat = psihat * datahat
W = NP.fft.ifft(convhat)
self.cwt[scaleindex,0:ndata] = W
return
def _setscales(self,ndata,largestscale,notes,scaling):
"""
if notes non-zero, returns a log scale based on notes per ocave
else a linear scale
(25/07/08): fix notes!=0 case so smallest scale at [0]
"""
if scaling=="log":
if notes<=0: notes=1
# adjust nscale so smallest scale is 2
noctave=self._log2( ndata/largestscale/2 )
self.nscale=notes*noctave
#print self.nscale
self.scales=NP.zeros(self.nscale,float)
for j in range(self.nscale):
self.scales[j] = ndata/(self.scale*(2.0**(float(self.nscale-j)/notes)))
#self.scales[j] = ndata/(self.scale*(2.0**(float(self.nscale-1-j)/notes)))
elif scaling=="linear":
nmax=ndata/largestscale/2
self.scales=NP.arange(float(2),float(nmax))
self.nscale=len(self.scales)
else: raise ValueError("scaling must be linear or log")
return
def getdata(self):
"""
returns wavelet coefficient array
"""
return self.cwt
def getcoefficients(self):
return self.cwt
def getpower(self):
"""
returns square of wavelet coefficient array
"""
return (self.cwt* NP.conjugate(self.cwt)).real
def getscales(self):
"""
returns array containing scales used in transform
"""
return self.scales
def getnscale(self):
"""
return number of scales
"""
return self.nscale
# wavelet classes
class Morlet(Cwt):
"""
Morlet wavelet
"""
_omega0=5.0
fourierwl=4* NP.pi/(_omega0+ NP.sqrt(2.0+_omega0**2))
def wf(self, s_omega):
H= NP.ones(len(s_omega))
n=len(s_omega)
for i in range(len(s_omega)):
if s_omega[i] < 0.0: H[i]=0.0
# !!!! note : was s_omega/8 before 17/6/03
#xhat=0.75112554*( NP.exp(-(s_omega-self._omega0)**2/2.0))*H
xhat=0.75112554*( NP.exp(-(s_omega-self.order)**2/2.0))*H
return xhat
class MorletReal(Cwt):
"""
Real Morlet wavelet
"""
_omega0=5.0
fourierwl=4* NP.pi/(_omega0+ NP.sqrt(2.0+_omega0**2))
def wf(self, s_omega):
H= NP.ones(len(s_omega))
n=len(s_omega)
for i in range(len(s_omega)):
if s_omega[i] < 0.0: H[i]=0.0
# !!!! note : was s_omega/8 before 17/6/03
xhat=0.75112554*( NP.exp(-(s_omega-self._omega0)**2/2.0)+ NP.exp(-(s_omega+self._omega0)**2/2.0)- NP.exp(-(self._omega0)**2/2.0)+ NP.exp(-(self._omega0)**2/2.0))
return xhat
class Paul4(Cwt):
"""
Paul m=4 wavelet
"""
fourierwl=4* NP.pi/(2.*4+1.)
def wf(self, s_omega):
n=len(s_omega)
xhat= NP.zeros(n)
xhat[0:n/2]=0.11268723*s_omega[0:n/2]**4* NP.exp(-s_omega[0:n/2])
#return 0.11268723*s_omega**2*exp(-s_omega)*H
return xhat
class Paul2(Cwt):
"""
Paul m=2 wavelet
"""
fourierwl=4* NP.pi/(2.*2+1.)
def wf(self, s_omega):
n=len(s_omega)
xhat= NP.zeros(n)
xhat[0:n/2]=1.1547005*s_omega[0:n/2]**2* | NP.exp(-s_omega[0:n/2]) | numpy.exp |
"""Unittests for imes4d"""
import unittest
from imes4d.utils import translation_transformation, rigid_transformation, affine_transformation, ransac
from imes4d.utils import create_dummy_data, blend_volumes, _calc_new_bounds
from imes4d.PyrLK3D import PyrLK3D
import numpy as np
class ImesTest(unittest.TestCase):
"""Unittests for imes4d"""
def test_pyr_lk_3d(self):
shift = np.random.rand(3)-0.5 * 20
trans = np.eye(4)
trans[:3, 3] = shift
a, b = create_dummy_data((128, 128, 128), trans=trans)
prev_pts = PyrLK3D.harris_corner_3d(a)
lk = PyrLK3D(a, b, prev_pts)
flow, _, _ = lk.calc_flow()
self.assertLess(np.linalg.norm(shift - np.mean(flow, axis=0)), 5e-2)
def test_translation_transformation(self):
# generate random transformation
trans = np.eye(4)
trans[:3, 3] = np.random.rand(3)
# generate point set and apply transformation
a = np.concatenate((np.random.rand(100, 3), np.ones((100, 1))), axis=1)
b = np.matmul(trans, a.T).T
# calculate transformation
t = translation_transformation(a, b)
# check for equality with tolerance
self.assertTrue(np.allclose(t, trans), "t not trans")
def test_rigid_transformation(self):
# generate random transformation
trans = np.eye(4)
a = np.random.rand() * np.pi
trans[0, 0] = np.cos(a)
trans[0, 1] = -np.sin(a)
trans[1, 0] = np.sin(a)
trans[1, 1] = np.cos(a)
trans[2, 2] = 1
trans[:3, 3] = np.random.rand(3)
# generate point set and apply transformation
a = np.concatenate((np.random.rand(100, 3), np.ones((100, 1))), axis=1)
b = np.matmul(trans, a.T).T
# calculate transformation
t = rigid_transformation(a, b)
# check for equality with tolerance
self.assertTrue(np.allclose(t, trans), "t not trans")
def test_affine_transformation(self):
# generate random data in homogeneous
a = np.concatenate((np.random.rand(4, 3), np.ones((4, 1))), axis=1)
# generate random transformation matrix
trans = np.vstack((np.random.rand(3, 4), np.array([0, 0, 0, 1])))
b = np.matmul(trans, a.T).T
# calculate transformation
t = affine_transformation(a, b)
# check for equality with tolerance
self.assertTrue(np.allclose(t, trans), "t not trans")
def test_ransac_rigid(self):
# generate random transformation
trans = np.eye(4)
a = np.random.rand() * np.pi
trans[0, 0] = np.cos(a)
trans[0, 1] = -np.sin(a)
trans[1, 0] = np.sin(a)
trans[1, 1] = np.cos(a)
trans[2, 2] = 1
trans[:3, 3] = np.random.rand(3)
# generate point set and apply transformation
a = np.concatenate((np.random.rand(100, 3), np.ones((100, 1))), axis=1)
b = np.matmul(trans, a.T).T
# add some outlier
for _ in range(50):
i = np.random.randint(0, b.shape[0])
b[i] = b[i] + 10 * np.random.rand() + 10
t, inlier_idx = ransac(a, b, 'rigid', inlier_threshold=0.25)
self.assertTrue(np.allclose(t, trans), "t not trans")
def test_blend_calc_bounds(self):
shape = (128, 128, 128)
shift = (np.random.rand(3)-0.5) * 20
trans = np.eye(4)
trans[:3, 3] = shift
bounds = np.zeros((8, 3))
bounds[0] = | np.array([0, 0, 0]) | numpy.array |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 17 15:32:46 2020
@author: jgb
"""
import numpy as np
import matplotlib.pyplot as plt
#https://www.ti.com/download/trng/docs/seminar/Topic_3_Lynch.pdf
Vin = 12
Vout = 180
Iout = 0.01
Rout = Vout/Iout
Fsw = 200e3
Tsw = 1/Fsw
L = 47e-6
# Assume CCM to find critical inductance
D = 1-(Vin/Vout)
print("Dccm: {}".format(D))
Lmax = 1/2*(Vout-Vin)*(1-D)**2*Tsw/Iout
print("Lmax: {} uH".format(Lmax*1e6))
# Now assuming DCM
K = (2*L)/(Rout*Tsw)
D = | np.linspace(0,1) | numpy.linspace |
import numpy as np
import mesh
import mesh.plot.trimesh_viewer as mplot # visualize
# Generate some data
length = 10 # length of flagellum, um
radius = 0.125 # flagellum radius
long_grid = 30 # longitudal grid
azimuth_grid = 8
xs = | np.linspace(-1, 1, long_grid) | numpy.linspace |
"""
A series of tools with which tidal data can be extracted from FVCOM NetCDF
model results. Also provides a number of tools to interrogate the SQLite
database of tidal data collated from a range of sources across the north-west
European continental shelf.
"""
from __future__ import print_function
import os
import sys
import numpy as np
import scipy
from lxml import etree
from netCDF4 import Dataset, date2num
from PyFVCOM.grid import find_nearest_point, unstructured_grid_depths
from PyFVCOM.utilities.general import fix_range, warn
from PyFVCOM.utilities.time import julian_day
try:
import sqlite3
use_sqlite = True
except ImportError:
warn('No sqlite standard library found in this python'
' installation. Some functions will be disabled.')
use_sqlite = False
class HarmonicOutput(object):
"""
Class to create a harmonic output file which creates variables for surface elevation and currents (both
depth-averaged and depth-resolved). Will optionally save raw data and predicted time series too.
"""
def __init__(self, ncfile, fvcom, consts, files=None, predict=False, dump_raw=False):
"""
Create a new netCDF file for harmonic analysis output.
Parameters
----------
ncfile : str
Path to the netCDF to create.
fvcom : PyFVCOM.read.FileReader
Model data object.
consts : list
List of constituents used in the harmonic analysis.
files : list, optional
File names used to create the harmonic analysis for the metadata.
predict : bool, optional
Set to True to enable predicted variable creation (defaults to False).
dump_raw : bool, optional
Set to True to enable output of the raw data used to perform the harmonic analysis (defaults to False).
"""
# Things to do.
self._predict = predict
self._dump_raw = dump_raw
# The output file
self._ncfile = ncfile
self._files = files
self._ncopts = {'zlib': True, 'complevel': 7}
self._consts = consts
# The data arrays
self._time = fvcom.time.datetime
self._lon = fvcom.grid.lon
self._lat = fvcom.grid.lat
self._lonc = fvcom.grid.lonc
self._latc = fvcom.grid.latc
self._Times = fvcom.time.Times
self._nv = fvcom.grid.nv
self._h = fvcom.grid.h
self._h_center = fvcom.grid.h_center
self._siglay = fvcom.grid.siglay
self._siglev = fvcom.grid.siglev
# The dimensions
self._nx = len(self._lon)
self._ne = len(self._lonc)
self._nz = self._siglay.shape[0]
self._nzlev = self._siglev.shape[0]
self._nt = self._Times.shape[0]
self._nconsts = len(self._consts)
# Make the netCDF and populate the initial values (grid and time).
self._init_structure()
self._populate_grid()
# Sync what we've got to disk now.
self.sync()
def _init_structure(self):
if self._nz == 0:
# Space last
self._node_siglay_dims = ['siglay', 'node']
self._node_siglev_dims = ['siglev', 'node']
self._three_nele_dims = ['three', 'nele']
self._nele_time_dims = ['time', 'nele']
self._nele_siglay_time_dims = ['time', 'siglay', 'nele']
self._node_time_dims = ['time', 'node']
self._nele_nconsts_dims = ['nconsts', 'nele']
self._nele_siglay_nconsts_dims = self._nele_consts_dims # single-layer only
self._node_nconsts_dims = ['nconsts', 'node']
self._nele_coordinates = 'time latc lonc'
self._nconsts_coordinates = 'nconsts lonc latc'
else:
# Space last
self._node_siglay_dims = ['siglay', 'node']
self._node_siglev_dims = ['siglev', 'node']
self._three_nele_dims = ['three', 'nele']
self._nele_time_dims = ['time', 'nele']
self._nele_siglay_time_dims = ['time', 'siglay', 'nele']
self._node_time_dims = ['time', 'node']
self._nele_nconsts_dims = ['nconsts', 'nele']
self._nele_siglay_nconsts_dims = ['nconsts', 'siglay', 'nele'] # multi-layer
self._node_nconsts_dims = ['nconsts', 'node']
self._nele_coordinates = 'time latc lonc'
self._nconsts_coordinates = 'nconsts lonc latc'
self._nc = Dataset(self._ncfile, 'w', format='NETCDF4', clobber=True)
self._nc.createDimension('node', self._nx)
self._nc.createDimension('nele', self._ne)
if self._nz != 0:
self._nc.createDimension('siglay', self._nz)
self._nc.createDimension('siglev', self._nzlev)
# Only create a Times variable if we're actually outputting any time dependent data.
if self._dump_raw or self._predict:
self._nc.createDimension('time', 0)
self._nc.createDimension('nconsts', self._nconsts)
self._nc.createDimension('three', 3)
self._nc.createDimension('NameStrLen', 4)
self._nc.createDimension('DateStrLen', 26)
self._nc.setncattr('type', 'Harmonic analysis of elevation, u and v data')
self._nc.setncattr('title', 'FVCOM model results harmonic analysis')
self._nc.setncattr('author', '<NAME> (Plymouth Marine Laboratory)')
self._nc.setncattr('history', 'File created using {}'.format(os.path.basename(sys.argv[0])))
if self._files:
self._nc.setncattr('sources', 'Created from file(s): {}'.format(self._files))
self.lon = self._nc.createVariable('lon', 'f4', ['node'], **self._ncopts)
self.lon.setncattr('units', 'degrees_east')
self.lon.setncattr('long_name', 'nodal longitude')
self.lon.setncattr('standard_name', 'longitude')
self.lat = self._nc.createVariable('lat', 'f4', ['node'], **self._ncopts)
self.lat.setncattr('units', 'degrees_north')
self.lat.setncattr('long_name', 'nodal longitude')
self.lat.setncattr('standard_name', 'longitude')
self.lonc = self._nc.createVariable('lonc', 'f4', ['nele'], **self._ncopts)
self.lonc.setncattr('units', 'degrees_east')
self.lonc.setncattr('long_name', 'zonal longitude')
self.lonc.setncattr('standard_name', 'longitude')
self.latc = self._nc.createVariable('latc', 'f4', ['nele'], **self._ncopts)
self.latc.setncattr('units', 'degrees_north')
self.latc.setncattr('long_name', 'zonal longitude')
self.latc.setncattr('standard_name', 'longitude')
self.h = self._nc.createVariable('h', 'f4', ['node'], **self._ncopts)
self.h.setncattr('long_name', 'Bathymetry')
self.h.setncattr('standard_name', 'sea_floor_depth_below_geoid')
self.h.setncattr('units', 'm')
self.h.setncattr('positive', 'down')
self.h.setncattr('grid', 'Bathymetry_Mesh')
self.h.setncattr('coordinates', 'x y')
self.h.setncattr('type', 'data')
self.h_center = self._nc.createVariable('h_center', 'f4', ['nele'], **self._ncopts)
self.h_center.setncattr('long_name', 'Bathymetry')
self.h_center.setncattr('standard_name', 'sea_floor_depth_below_geoid')
self.h_center.setncattr('units', 'm')
self.h_center.setncattr('positive', 'down')
self.h_center.setncattr('grid', 'grid1 grid3')
self.h_center.setncattr('coordinates', 'latc lonc')
self.h_center.setncattr('grid_location', 'center')
self.siglay = self._nc.createVariable('siglay', 'f4', self._node_siglay_dims, **self._ncopts)
self.siglay.setncattr('long_name', 'Sigma Layers')
self.siglay.setncattr('standard_name', 'ocean_sigma/general_coordinate')
self.siglay.setncattr('positive', 'up')
self.siglay.setncattr('valid_min', -1.0)
self.siglay.setncattr('valid_max', 0.0)
self.siglay.setncattr('formula_terms', 'sigma: siglay eta: zeta depth: h')
self.siglev = self._nc.createVariable('siglev', 'f4', self._node_siglev_dims, **self._ncopts)
self.siglev.setncattr('long_name', 'Sigma Levels')
self.siglev.setncattr('standard_name', 'ocean_sigma/general_coordinate')
self.siglev.setncattr('positive', 'up')
self.siglev.setncattr('valid_min', -1.0)
self.siglev.setncattr('valid_max', 0.0)
self.siglev.setncattr('formula_terms', 'sigma: siglay eta: zeta depth: h')
self.nv = self._nc.createVariable('nv', 'f4', self._three_nele_dims, **self._ncopts)
self.nv.setncattr('long_name', 'nodes surrounding element')
if self._dump_raw or self._predict:
self.Times = self._nc.createVariable('Times', 'c', ['time', 'DateStrLen'], **self._ncopts)
self.Times.setncattr('time_zone', 'UTC')
if self._dump_raw:
self.ua_raw = self._nc.createVariable('ua_raw', 'f4', self._nele_time_dims, **self._ncopts)
self.ua_raw.setncattr('long_name', 'Modelled Eastward Water Depth-averaged Velocity')
self.ua_raw.setncattr('standard_name', 'fvcom_eastward_sea_water_velocity')
self.ua_raw.setncattr('units', 'meters s-1')
self.ua_raw.setncattr('grid', 'fvcom_grid')
self.ua_raw.setncattr('type', 'data')
self.ua_raw.setncattr('coordinates', self._nele_coordinates)
self.ua_raw.setncattr('location', 'face')
self.va_raw = self._nc.createVariable('va_raw', 'f4', self._nele_time_dims, **self._ncopts)
self.va_raw.setncattr('long_name', 'Modelled Northward Water Depth-averaged Velocity')
self.va_raw.setncattr('standard_name', 'fvcom_northward_sea_water_velocity')
self.va_raw.setncattr('units', 'meters s-1')
self.va_raw.setncattr('grid', 'fvcom_grid')
self.va_raw.setncattr('type', 'data')
self.va_raw.setncattr('coordinates', self._nele_coordinates)
self.va_raw.setncattr('location', 'face')
self.u_raw = self._nc.createVariable('u_raw', 'f4', self._nele_siglay_time_dims, **self._ncopts)
self.u_raw.setncattr('long_name', 'Modelled Eastward Water Velocity')
self.u_raw.setncattr('standard_name', 'fvcom_eastward_sea_water_velocity')
self.u_raw.setncattr('units', 'meters s-1')
self.u_raw.setncattr('grid', 'fvcom_grid')
self.u_raw.setncattr('type', 'data')
self.u_raw.setncattr('coordinates', self._nele_coordinates)
self.u_raw.setncattr('location', 'face')
self.v_raw = self._nc.createVariable('v_raw', 'f4', self._nele_siglay_time_dims, **self._ncopts)
self.v_raw.setncattr('long_name', 'Modelled Northward Water Velocity')
self.v_raw.setncattr('standard_name', 'fvcom_northward_sea_water_velocity')
self.v_raw.setncattr('units', 'meters s-1')
self.v_raw.setncattr('grid', 'fvcom_grid')
self.v_raw.setncattr('type', 'data')
self.v_raw.setncattr('coordinates', self._nele_coordinates)
self.v_raw.setncattr('location', 'face')
self.z_raw = self._nc.createVariable('z_raw', 'f4', self._node_time_dims, **self._ncopts)
self.z_raw.setncattr('long_name', 'Modelled Surface Elevation')
self.z_raw.setncattr('standard_name', 'fvcom_surface_elevation')
self.z_raw.setncattr('units', 'meters')
self.z_raw.setncattr('grid', 'fvcom_grid')
self.z_raw.setncattr('type', 'data')
self.z_raw.setncattr('coordinates', 'time lat lon')
self.z_raw.setncattr('location', 'node')
if self._predict:
self.ua_pred = self._nc.createVariable('ua_pred', 'f4', self._nele_time_dims, **self._ncopts)
self.ua_pred.setncattr('long_name', 'Predicted Eastward Water Depth-averaged Velocity')
self.ua_pred.setncattr('standard_name', 'eastward_sea_water_velocity')
self.ua_pred.setncattr('units', 'meters s-1')
self.ua_pred.setncattr('grid', 'fvcom_grid')
self.ua_pred.setncattr('type', 'data')
self.ua_pred.setncattr('coordinates', self._nele_coordinates)
self.ua_pred.setncattr('location', 'face')
self.va_pred = self._nc.createVariable('va_pred', 'f4', self._nele_time_dims, **self._ncopts)
self.va_pred.setncattr('long_name', 'Predicted Northward Water Depth-averaged Velocity')
self.va_pred.setncattr('standard_name', 'northward_sea_water_velocity')
self.va_pred.setncattr('units', 'meters s-1')
self.va_pred.setncattr('grid', 'fvcom_grid')
self.va_pred.setncattr('type', 'data')
self.va_pred.setncattr('coordinates', self._nele_coordinates)
self.va_pred.setncattr('location', 'face')
self.u_pred = self._nc.createVariable('u_pred', 'f4', self._nele_siglay_time_dims, **self._ncopts)
self.u_pred.setncattr('long_name', 'Predicted Eastward Water Velocity')
self.u_pred.setncattr('standard_name', 'eastward_sea_water_velocity')
self.u_pred.setncattr('units', 'meters s-1')
self.u_pred.setncattr('grid', 'fvcom_grid')
self.u_pred.setncattr('type', 'data')
self.u_pred.setncattr('coordinates', self._nele_coordinates)
self.u_pred.setncattr('location', 'face')
self.v_pred = self._nc.createVariable('v_pred', 'f4', self._nele_siglay_time_dims, **self._ncopts)
self.v_pred.setncattr('long_name', 'Predicted Northward Water Velocity')
self.v_pred.setncattr('standard_name', 'northward_sea_water_velocity')
self.v_pred.setncattr('units', 'meters s-1')
self.v_pred.setncattr('grid', 'fvcom_grid')
self.v_pred.setncattr('type', 'data')
self.v_pred.setncattr('coordinates', self._nele_coordinates)
self.v_pred.setncattr('location', 'face')
self.z_pred = self._nc.createVariable('z_pred', 'f4', self._node_time_dims, **self._ncopts)
self.z_pred.setncattr('long_name', 'Predicted Surface Elevation')
self.z_pred.setncattr('standard_name', 'surface_elevation')
self.z_pred.setncattr('units', 'meters')
self.z_pred.setncattr('grid', 'fvcom_grid')
self.z_pred.setncattr('type', 'data')
self.z_pred.setncattr('coordinates', 'time lat lon')
self.z_pred.setncattr('location', 'node')
self.u_const_names = self._nc.createVariable('u_const_names', 'c', ['nconsts', 'NameStrLen'], **self._ncopts)
self.u_const_names.setncattr('long_name', 'Tidal constituent names for u-velocity')
self.u_const_names.setncattr('standard_name', 'u_constituent_names')
self.v_const_names = self._nc.createVariable('v_const_names', 'c', ['nconsts', 'NameStrLen'], **self._ncopts)
self.v_const_names.setncattr('long_name', 'Tidal constituent names for v-velocity')
self.v_const_names.setncattr('standard_name', 'v_constituent_names')
self.z_const_names = self._nc.createVariable('z_const_names', 'c', ['nconsts', 'NameStrLen'], **self._ncopts)
self.z_const_names.setncattr('long_name', 'Tidal constituent names for surface elevation')
self.z_const_names.setncattr('standard_name', 'z_constituent_names')
self.u_amp = self._nc.createVariable('u_amp', 'f4', self._nele_siglay_nconsts_dims, **self._ncopts)
self.u_amp.setncattr('long_name', 'Tidal harmonic amplitudes of the u velocity')
self.u_amp.setncattr('standard_name', 'u_amplitude')
self.u_amp.setncattr('units', 'meters')
self.u_amp.setncattr('grid', 'fvcom_grid')
self.u_amp.setncattr('type', 'data')
self.u_amp.setncattr('coordinates', self._nconsts_coordinates)
self.v_amp = self._nc.createVariable('v_amp', 'f4', self._nele_siglay_nconsts_dims, **self._ncopts)
self.v_amp.setncattr('long_name', 'Tidal harmonic amplitudes of the v velocity')
self.v_amp.setncattr('standard_name', 'v_amplitude')
self.v_amp.setncattr('units', 'meters')
self.v_amp.setncattr('grid', 'fvcom_grid')
self.v_amp.setncattr('type', 'data')
self.v_amp.setncattr('coordinates', self._nconsts_coordinates)
self.ua_amp = self._nc.createVariable('ua_amp', 'f4', self._nele_nconsts_dims, **self._ncopts)
self.ua_amp.setncattr('long_name', 'Tidal harmonic amplitudes of the ua velocity')
self.ua_amp.setncattr('standard_name', 'ua_amplitude')
self.ua_amp.setncattr('units', 'meters')
self.ua_amp.setncattr('grid', 'fvcom_grid')
self.ua_amp.setncattr('type', 'data')
self.ua_amp.setncattr('coordinates', self._nconsts_coordinates)
self.va_amp = self._nc.createVariable('va_amp', 'f4', self._nele_nconsts_dims, **self._ncopts)
self.va_amp.setncattr('long_name', 'Tidal harmonic amplitudes of the va velocity')
self.va_amp.setncattr('standard_name', 'va_amplitude')
self.va_amp.setncattr('units', 'meters')
self.va_amp.setncattr('grid', 'fvcom_grid')
self.va_amp.setncattr('type', 'data')
self.va_amp.setncattr('coordinates', self._nconsts_coordinates)
self.z_amp = self._nc.createVariable('z_amp', 'f4', self._node_nconsts_dims, **self._ncopts)
self.z_amp.setncattr('long_name', 'Tidal harmonic amplitudes of the surface elevation')
self.z_amp.setncattr('standard_name', 'z_amplitude')
self.z_amp.setncattr('units', 'meters')
self.z_amp.setncattr('grid', 'fvcom_grid')
self.z_amp.setncattr('type', 'data')
self.z_amp.setncattr('coordinates', 'lon lat nconsts')
self.u_phase = self._nc.createVariable('u_phase', 'f4', self._nele_siglay_nconsts_dims, **self._ncopts)
self.u_phase.setncattr('long_name', 'Tidal harmonic phases of the u velocity')
self.u_phase.setncattr('standard_name', 'u_amplitude')
self.u_phase.setncattr('units', 'meters')
self.u_phase.setncattr('grid', 'fvcom_grid')
self.u_phase.setncattr('type', 'data')
self.u_phase.setncattr('coordinates', self._nconsts_coordinates)
self.v_phase = self._nc.createVariable('v_phase', 'f4', self._nele_siglay_nconsts_dims, **self._ncopts)
self.v_phase.setncattr('long_name', 'Tidal harmonic phases of the v velocity')
self.v_phase.setncattr('standard_name', 'v_amplitude')
self.v_phase.setncattr('units', 'meters')
self.v_phase.setncattr('grid', 'fvcom_grid')
self.v_phase.setncattr('type', 'data')
self.v_phase.setncattr('coordinates', self._nconsts_coordinates)
self.ua_phase = self._nc.createVariable('ua_phase', 'f4', self._nele_nconsts_dims, **self._ncopts)
self.ua_phase.setncattr('long_name', 'Tidal harmonic phases of the ua velocity')
self.ua_phase.setncattr('standard_name', 'ua_amplitude')
self.ua_phase.setncattr('units', 'meters')
self.ua_phase.setncattr('grid', 'fvcom_grid')
self.ua_phase.setncattr('type', 'data')
self.ua_phase.setncattr('coordinates', self._nconsts_coordinates)
self.va_phase = self._nc.createVariable('va_phase', 'f4', self._nele_nconsts_dims, **self._ncopts)
self.va_phase.setncattr('long_name', 'Tidal harmonic phases of the va velocity')
self.va_phase.setncattr('standard_name', 'va_amplitude')
self.va_phase.setncattr('units', 'meters')
self.va_phase.setncattr('grid', 'fvcom_grid')
self.va_phase.setncattr('type', 'data')
self.va_phase.setncattr('coordinates', self._nconsts_coordinates)
self.z_phase = self._nc.createVariable('z_phase', 'f4', self._node_nconsts_dims, **self._ncopts)
self.z_phase.setncattr('long_name', 'Tidal harmonic phases of the surface elevation'),
self.z_phase.setncattr('standard_name', 'z_amplitude')
self.z_phase.setncattr('units', 'meters')
self.z_phase.setncattr('grid', 'fvcom_grid')
self.z_phase.setncattr('type', 'data')
self.z_phase.setncattr('coordinates', 'lon lat nconsts')
def _populate_grid(self):
# Add the data we already have.
self.lon[:] = self._lon
self.lat[:] = self._lat
self.lonc[:] = self._lonc
self.latc[:] = self._latc
self.h[:] = self._h
self.h_center[:] = self._h_center
self.nv[:] = self._nv
self.z_const_names[:] = self._consts
self.u_const_names[:] = self._consts
self.v_const_names[:] = self._consts
self.siglay[:] = self._siglay
self.siglev[:] = self._siglev
if self._predict or self._dump_raw:
self._write_fvcom_time(self._time)
def _write_fvcom_time(self, time, **kwargs):
"""
Write the four standard FVCOM time variables (time, Times, Itime, Itime2) for the given time series.
Parameters
----------
time : np.ndarray, list, tuple
Times as datetime objects.
"""
mjd = date2num(time, units='days since 1858-11-17 00:00:00')
Itime = np.floor(mjd) # integer Modified Julian Days
Itime2 = (mjd - Itime) * 24 * 60 * 60 * 1000 # milliseconds since midnight
Times = [t.strftime('%Y-%m-%dT%H:%M:%S.%f') for t in time]
# time
self.time = self._nc.createVariable('time', 'f4', ['time'], **self._ncopts)
self.time.setncattr('units', 'days since 1858-11-17 00:00:00')
self.time.setncattr('format', 'modified julian day (MJD)')
self.time.setncattr('long_name', 'time')
self.time.setncattr('time_zone', 'UTC')
# Itime
self.Itime = self._nc.createVariable('Itime', 'i', ['time'], **self._ncopts)
self.Itime.setncattr('units', 'days since 1858-11-17 00:00:00')
self.Itime.setncattr('format', 'modified julian day (MJD)')
self.Itime.setncattr('time_zone', 'UTC')
self.Itime[:] = Itime
# Itime2
self.Itime2 = self._nc.createVariable('Itime2', 'i', ['time'], **self._ncopts)
self.Itime2.setncattr('units', 'msec since 00:00:00')
self.Itime2.setncattr('time_zone', 'UTC')
self.Itime2[:] = Itime2
# Times
self.Times = self._nc.createVariable('Times', 'c', ['time', 'DateStrLen'], **self._ncopts)
self.Times.setncattr('long_name', 'Calendar Date')
self.Times.setncattr('format', 'String: Calendar Time')
self.Times.setncattr('time_zone', 'UTC')
self.Times[:] = Times
def close(self):
""" Close the netCDF file handle. """
self._nc.close()
def sync(self):
""" Sync data to disk now. """
self._nc.sync()
def add_harmonic_results(db, stationName, constituentName, phase, amplitude, speed, inferred, ident=None, noisy=False):
"""
Add data to an SQLite database.
Parameters
----------
db : str
Full path to an SQLite database. If absent, it will be created.
stationName : str
Short name for the current station. This is the table name.
constituentName : str
Name of the current tidal constituent being added.
phase : float
Tidal constituent phase (in degrees).
amplitude : float
Tidal constituent amplitude (in metres).
speed : float
Tidal constituent speed (in degrees per hour).
inferred : str
'true' or 'false' indicating whether the values are inferred
(i.e. the time series is too short to perform a robust harmonic
analysis).
ident : str
Optional prefix for the table names in the SQLite database. Usage of
this option means you can store both u and v data in the same database.
noisy : bool
Set to True to enable verbose output.
"""
if not use_sqlite:
raise RuntimeError('No sqlite standard library found in this python'
' installation. This function (add_harmonic_results)'
' is unavailable.')
if not ident:
ident = ''
else:
ident = '_' + ident
conn = sqlite3.connect(db)
c = conn.cursor()
# Create the necessary tables if they don't exist already
c.execute('CREATE TABLE IF NOT EXISTS TidalConstituents ( \
shortName TEXT COLLATE nocase, \
amplitude FLOAT(10), \
phase FLOAT(10), \
speed FLOAT(10), \
constituentName TEXT COLLATE nocase, \
amplitudeUnits TEXT COLLATE nocase, \
phaseUnits TEXT COLLATE nocase, \
speedUnits TEXT COLLATE nocase, \
inferredConstituent TEXT COLLATE nocase)')
if noisy:
print('amplitude, phase and speed.', end=' ')
for item in range(len(inferred)):
c.execute('INSERT INTO TidalConstituents VALUES (?,?,?,?,?,?,?,?,?)',
(stationName + ident, amplitude[item], phase[item], speed[item], constituentName[item], 'metres', 'degrees', 'degrees per mean solar hour', inferred[item]))
conn.commit()
conn.close()
def get_observed_data(db, table, startYear=False, endYear=False, noisy=False):
"""
Extract the tidal data from the SQLite database for a given station.
Specify the database (db), the table name (table) which needs to be the
short name version of the station of interest.
Optionally supply a start and end year (which if equal give all data from
that year) to limit the returned data. If no data exists for that station,
the output is returned as False.
Parameters
----------
db : str
Full path to the tide data SQLite database.
table : str
Name of the table to be extracted (e.g. 'AVO').
startYear : bool, optional
Year from which to start extracting data (inclusive).
endYear : bool, optional
Year at which to end data extraction (inclusive).
noisy : bool, optional
Set to True to enable verbose output.
See Also
--------
tide.get_observed_metadata : extract metadata for a tide station.
Notes
-----
Search is not fuzzy, so "NorthShields" is not the same as "North Shields".
Search is case insensitive, however.
"""
if not use_sqlite:
raise RuntimeError('No sqlite standard library found in this python'
' installation. This function (get_observed_data)'
' is unavailable.')
if noisy:
print('Getting data for {} from the database...'.format(table), end=' ')
try:
con = sqlite3.connect(db)
with con:
c = con.cursor()
if startYear and endYear:
# We've been given a range of data
if startYear == endYear:
# We have the same start and end dates, so just do a
# simpler version
c.execute('SELECT * FROM {t} WHERE {t}.year == {sy} ORDER BY year, month, day, hour, minute, second'.format(t=table, sy=startYear))
else:
# We have a date range
c.execute('SELECT * FROM {t} WHERE {t}.year >= {sy} AND {t}.year <= {ey} ORDER BY year, month, day, hour, minute, second'.format(t=table, sy=startYear, ey=endYear))
else:
# Return all data
c.execute('SELECT * FROM {} ORDER BY year, month, day, hour, minute, second'.format(table))
# Now get the data in a format we might actually want to use
data = c.fetchall()
con.close()
if noisy:
print('done.')
except sqlite3.Error as e:
if con:
con.close()
print('Error {}:'.format(e.args[0]))
data = [False]
return data
def get_observed_metadata(db, originator=False, obsdepth=None):
"""
Extracts the meta data from the supplied database. If the supplied
originator is False (default), then information from all stations is
returned.
Parameters
----------
db : str
Full path to the tide data SQLite database.
originator : str, optional
Specify an originator (e.g. 'NTSLF', 'NSTD', 'REFMAR') to
extract only that data. Defaults to all data.
obsdepth : bool, optional
Set to True to return the observation depth (useful for current meter
data). Defaults to False.
Returns
-------
lat, lon : list
Latitude and longitude of the requested station(s).
site : list
Short names (e.g. 'AVO' for 'Avonmouth') of the tide stations.
longName : list
Long names of the tide stations (e.g. 'Avonmouth').
depth : list
If obsdepth=True on input, then depths are returned, otherwise omitted.
"""
if not use_sqlite:
raise RuntimeError('No sqlite standard library found in this python'
' installation. This function (get_observed_metadata)'
' is unavailable.')
con = None
try:
con = sqlite3.connect(db)
c = con.cursor()
if not originator:
out = c.execute('SELECT * from Stations where originatorName '
'is ? or originatorLongName is ?',
[originator, originator])
else:
out = c.execute('SELECT * from Stations')
# Convert it to a set of better formatted values.
metadata = out.fetchall()
lat = [float(m[0]) for m in metadata]
lon = [float(m[1]) for m in metadata]
site = [str(m[2]) for m in metadata]
longName = [str(m[3]) for m in metadata]
if len(metadata) > 4:
depth = [str(m[4]) for m in metadata]
else:
depth = None
except sqlite3.Error as e:
if con:
con.close()
lat, lon, site, longName, depth = False, False, False, False, False
raise Exception('SQLite error: {}'.format(e.args[0]))
if not obsdepth:
return lat, lon, site, longName
else:
return lat, lon, site, longName, depth
def clean_observed_data(data, removeResidual=False):
"""
Process the observed raw data to a more sensible format. Also
convert from Gregorian dates to Modified Julian Day (to match FVCOM
model output times).
Parameters
----------
data : ndarray
Array of [YYYY, MM, DD, hh, mm, ss, zeta, flag] data output by
getObservedData().
removeResidual : bool, optional
If True, remove any residual values. Where such data are absent
(marked by values of -9999 or -99.0), no removal is performed. Defaults
to False.
Returns
-------
dateMJD : ndarray
Modified Julian Days of the input data.
tideDataMSL : ndarray
Time series of surface elevations from which the mean surface
elevation has been subtracted. If removeResidual is True, these
values will omit the atmospheric effects, leaving a harmonic
signal only.
npFlagsData : ndarray
Flag values from the SQLite database (usually -9999, or P, N
etc. if BODC data).
allDateTimes : ndarray
Original date data in [YYYY, MM, DD, hh, mm, ss] format.
"""
npObsData = []
npFlagData = []
for row in data:
npObsData.append(row[:-1]) # eliminate the flag from the numeric data
npFlagData.append(row[-1]) # save the flag separately
# For the tidal data, convert the numbers to floats to avoid issues
# with truncation.
npObsData = np.asarray(npObsData, dtype=float)
npFlagData = np.asarray(npFlagData)
# Extract the time and tide data
allObsTideData = np.asarray(npObsData[:, 6])
allObsTideResidual = np.asarray(npObsData[:, 7])
allDateTimes = np.asarray(npObsData[:, :6], dtype=float)
dateMJD = julian_day(allDateTimes, mjd=True)
# Apply a correction (of sorts) from LAT to MSL by calculating the
# mean (excluding nodata values (-99 for NTSLF, -9999 for SHOM))
# and removing that from the elevation.
tideDataMSL = allObsTideData - np.mean(allObsTideData[allObsTideData > -99])
if removeResidual:
# Replace the residuals to remove with zeros where they're -99
# or -9999 since the net effect at those times is "we don't have
# a residual, so just leave the original value alone".
allObsTideResidual[allObsTideResidual <= -99] = 0
tideDataMSL = tideDataMSL - allObsTideResidual
return dateMJD, tideDataMSL, npFlagData, allDateTimes
def parse_TAPPY_XML(file):
"""
Extract values from an XML file created by TAPPY.
TODO: Allow a list of constituents to be specified when calling
parse_TAPPY_XML.
Parameters
----------
file : str
Full path to a TAPPY output XML file.
Returns
-------
constituentName : list
Tidal constituent names.
constituentSpeed : list
Tidal constituent speeds (in degrees per hour).
constituentPhase : list
Tidal constituent phases (in degrees).
constituentAmplitude : list
Tidal constituent amplitudes (in metres).
constituentInference : list
Flag of whether the tidal constituent was inferred due to a
short time series for the given constituent.
"""
tree = etree.parse(open(file, 'r'))
constituentName = []
constituentSpeed = []
constituentInference = []
constituentPhase = []
constituentAmplitude = []
for harmonic in tree.iter('Harmonic'):
# Still not pretty
for item in harmonic.iter('name'):
constituentName.append(item.text)
for item in harmonic.iter('speed'):
constituentSpeed.append(item.text)
for item in harmonic.iter('inferred'):
constituentInference.append(item.text)
for item in harmonic.iter('phaseAngle'):
constituentPhase.append(item.text)
for item in harmonic.iter('amplitude'):
constituentAmplitude.append(item.text)
return constituentName, constituentSpeed, constituentPhase, constituentAmplitude, constituentInference
def get_harmonics(db, stationName, noisy=False):
"""
Use the harmonics database to extract the results of the harmonic analysis
for a given station (stationName).
Parameters
----------
db : str
Full path to the tidal harmonics SQLite database.
stationName : str
Station short name (i.e. table name).
noisy : bool, optional
Set to True to enable verbose output.
Returns
-------
siteHarmonics : dict
Contains all the harmonics data for the given tide station. Keys and units are:
- 'stationName' (e.g. 'AVO')
- 'amplitude' (m)
- 'phase' (degrees)
- 'speed' (degrees per mean solar hour)
- 'constituentName' (e.g. 'M2')
- 'inferredConstituent' ('true'|'false')
"""
if not use_sqlite:
raise RuntimeError('No sqlite standard library found in this python'
' installation. This function (get_harmonics) is'
' unavailable.')
if noisy:
print('Getting harmonics data for site {}...'.format(stationName), end=' ')
try:
con = sqlite3.connect(db)
with con:
c = con.cursor()
c.execute('SELECT * FROM TidalConstituents WHERE shortName = \'' + stationName + '\'')
data = c.fetchall()
con.close()
except sqlite3.Error as e:
if con:
con.close()
print('Error %s:' % e.args[0])
data = [False]
if noisy:
print('extraction failed.')
# Convert data to a dict of value pairs
siteHarmonics = {}
tAmp = np.empty(np.shape(data)[0])
tPhase = np.empty(np.shape(data)[0])
tSpeed = np.empty(np.shape(data)[0])
tConst = np.empty(np.shape(data)[0], dtype="|S7")
tInfer = np.empty(np.shape(data)[0], dtype=bool)
for i, constituent in enumerate(data):
tAmp[i] = constituent[1]
tPhase[i] = constituent[2]
tSpeed[i] = constituent[3]
tConst[i] = str(constituent[4])
if str(constituent[-1]) == 'false':
tInfer[i] = False
else:
tInfer[i] = True
siteHarmonics['amplitude'] = tAmp
siteHarmonics['phase'] = tPhase
siteHarmonics['speed'] = tSpeed
siteHarmonics['constituentName'] = tConst
siteHarmonics['inferredConstituent'] = tInfer
if noisy:
print('done.')
return siteHarmonics
def read_POLPRED(harmonics, noisy=False):
"""
Load a POLPRED data file into a NumPy array. This can then be used by
get_harmonics_POLPRED to extract the harmonics at a given loaction, or
otherwise can be used to simply extract the positions of the POLCOMS grid.
Parameters
----------
harmonics : str
Full path to the POLPRED ASCII data file.
noisy : bool, optional
Set to True to enable verbose output.
Returns
-------
header : dict
Contains the header data from the POLPRED ASCII file.
values : ndarray
Harmonic constituent data formatted as [x, y, nConst * [zZ, zG,
uZ, uG, vZ, vG]], where nConst is the number of constituents in
the POLPRED data (15) and z, u and v refer to surface elevation,
u-vector and v-vector components, respectively. The suffixes Z
and G refer to amplitude and phase of the z, u and v data.
See Also
--------
tide.grid_POLPRED : Converts the POLPRED data into a rectangular
gridded data set with values of -999.9 outside the POLPRED domain.
"""
# Open the harmonics file
f = open(harmonics, 'r')
polpred = f.readlines()
f.close()
# Read the header into a dict.
readingHeader = True
header = {}
values = []
if noisy:
print('Parsing POLPRED raw data...', end=' ')
for line in polpred:
if readingHeader:
if not line.strip():
# Blank line, which means the end of the header
readingHeader = False
else:
key, parameters = line.split(':')
header[key.strip()] = parameters.strip()
else:
# Remove duplicate whitespaces and split on the resulting
# single spaces.
line = line.strip()
line = ' '.join(line.split())
values.append(line.split(' '))
# Make the values into a numpy array
values = | np.asarray(values, dtype=float) | numpy.asarray |
from unittest import TestCase
from plotoptix.utils import *
from plotoptix.utils import _make_contiguous_vector, _make_contiguous_3d
import numpy as np
class TestScene(TestCase):
@classmethod
def setUpClass(cls):
print("################ Test 060: Utility and convenience functions. ################")
def test010_make_contiguous(self):
x = 1
a = _make_contiguous_vector(x, 3)
self.assertTrue(a.shape == (3,), msg="Output shape is wrong.")
self.assertTrue(a.dtype == np.float32, msg="Data type is not np.float32.")
self.assertTrue(np.array_equal(a, [x, x, x]), msg="Output content is wrong.")
self.assertTrue(a.flags['C_CONTIGUOUS'], msg="Output array is not c-contiguous.")
y = [1, 2, 3]
a = _make_contiguous_vector(y, len(y))
self.assertTrue(a.shape == (len(y),), msg="Output shape is wrong.")
self.assertTrue(a.dtype == np.float32, msg="Data type is not np.float32.")
self.assertTrue(np.array_equal(a, y), msg="Output content is wrong.")
self.assertTrue(a.flags['C_CONTIGUOUS'], msg="Output array is not c-contiguous.")
z = [[1, 2], [3, 4]]
a = _make_contiguous_vector(z, 4)
self.assertTrue(a.shape == (4,), msg="Output shape is wrong.")
self.assertTrue(a.dtype == np.float32, msg="Data type is not np.float32.")
self.assertTrue(np.array_equal(a, [1, 2, 3, 4]), msg="Output content is wrong.")
self.assertTrue(a.flags['C_CONTIGUOUS'], msg="Output array is not c-contiguous.")
x = 1
a = _make_contiguous_3d(x, extend_scalars=True)
self.assertTrue(a.shape == (1, 3), msg="Output shape is wrong.")
self.assertTrue(a.dtype == np.float32, msg="Data type is not np.float32.")
self.assertTrue(np.array_equal(a, [[x, x, x]]), msg="Output content is wrong.")
self.assertTrue(a.flags['C_CONTIGUOUS'], msg="Output array is not c-contiguous.")
a = _make_contiguous_3d(x, extend_scalars=False)
self.assertTrue(a.shape == (1, 3), msg="Output shape is wrong.")
self.assertTrue(a.dtype == np.float32, msg="Data type is not np.float32.")
self.assertTrue( | np.array_equal(a, [[x, x, x]]) | numpy.array_equal |
# Copyright 2018 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 training utility functions."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.python.eager import context
from tensorflow.python.framework import tensor_util
from tensorflow.python.keras.engine import training_utils
from tensorflow.python.keras.utils import tf_utils
from tensorflow.python.platform import test
class ModelInputsTest(test.TestCase):
def test_single_thing(self):
a = | np.ones(10) | numpy.ones |
import tensorflow as tf
from copy import deepcopy
import numpy as np
import time
import json
import tqdm
from base import *
from lm import loss
from lm import stop
class Config(wb.Config):
def __init__(self, data_or_vocab_size=1000, hidden_size=200, hidden_layers=2):
if isinstance(data_or_vocab_size, int):
self.vocab_size = data_or_vocab_size
else:
self.vocab_size = data_or_vocab_size.get_vocab_size()
self.embedding_size = hidden_size
self.hidden_layers = hidden_layers
self.hidden_size = hidden_size
self.softmax_type = 'Softmax' # only support 'Softmax'
self.softmax_pred_token_per_cluster = int(np.sqrt(self.vocab_size)) # used to accelerate the sampling, suggested as int(np.sqrt(vocab_size))
self.init_weight = 0.1
self.optimize_method = 'SGD' # can be one of 'SGD', 'adam'
self.max_grad_norm = 5.0 # grad_norm, can be None
self.dropout = 0.0
self.learning_rate = 1. # [learning rate] initial values
self.max_update_batch = 100
def __str__(self):
s = 'lstm_e{}_h{}x{}'.format(self.embedding_size, self.hidden_size, self.hidden_layers)
return s
class Net(object):
def __init__(self, config, is_training, name='lstm_net', reuse=None):
self.is_training = is_training
self.config = config
self.state = None # save the current state of LSMT
# a initializer for variables
initializer = tf.random_uniform_initializer(-config.init_weight, config.init_weight)
with tf.variable_scope(name, reuse=reuse, initializer=initializer):
# Create LSTM cell
def one_lstm_cell():
c = tf.contrib.rnn.BasicLSTMCell(self.config.hidden_size, forget_bias=0., reuse=reuse)
if self.is_training and self.config.dropout > 0:
c = tf.contrib.rnn.DropoutWrapper(c, output_keep_prob=1. - self.config.dropout_prob)
return c
cell = tf.contrib.rnn.MultiRNNCell([one_lstm_cell() for _ in range(self.config.hidden_layers)])
# inputs: [batch_size, max_length]
# targets: [batch_size, max_length]
# lengths: [batch_size]
# _scales: [batch_size] the scales for each sequences
self._inputs = tf.placeholder(tf.int32, [None, None], name='net_inputs')
self._targets = tf.placeholder(tf.int32, [None, None], name='net_targets')
self._lengths = tf.ones([tf.shape(self._inputs)[0]], dtype=tf.int32) * tf.shape(self._inputs)[1]
self._scales = tf.placeholder(tf.float32, [None], name='net_scales')
self._initial_state = cell.zero_state(tf.shape(self._inputs)[0], tf.float32)
# bulid network...
self.softmax, self.final_state = self.output(cell, self._initial_state,
self._inputs, self._targets, self._lengths)
# loss for each position
length_mask = tf.sequence_mask(self._lengths, tf.shape(self._inputs)[1], dtype=tf.float32)
self.logps = self.softmax.logps
self.logps_for_position = self.logps * length_mask
self.logps_for_sequence = tf.reduce_sum(self.logps_for_position, axis=-1)
self.loss = -self.softmax.logps
self.loss_for_position = self.loss * length_mask
self.loss_for_sequence = tf.reduce_sum(self.loss_for_position, axis=-1)
# all the trainalbe vairalbes
self.vars = tf.get_collection(key=tf.GraphKeys.GLOBAL_VARIABLES, scope=tf.get_variable_scope().name)
self.var_size = tf.add_n([tf.size(v) for v in self.vars])
# print the variables
if reuse is None:
print('[%s.%s] variables in %s' % (__name__, self.__class__.__name__, name))
for v in self.vars:
print('\t' + v.name, v.shape, v.device)
print('[%s.%s] max_update_batch=%d' % (__name__, self.__class__.__name__, self.config.max_update_batch))
if is_training:
# as _lr and _global_step is not defined in variables_scope(),
# as the default collection is tf.GraphKeys.TRAINABLE_VARIABLES
# It should be initialized by session.run(tf.global_variables_initializer()) or
# use tf.Train.Supervisor()
self.grads = tf.gradients(self.loss_for_sequence, self.vars, self._scales)
self.train_op = layers.TrainOp(self.grads, self.vars,
optimize_method=self.config.optimize_method,
max_grad_norm=self.config.max_grad_norm)
def output(self, cell, init_states, _inputs, _targets=None, _lengths=None):
# word embedding
word_embedding = tf.get_variable('word_embedding',
[self.config.vocab_size, self.config.embedding_size],
dtype=tf.float32)
inputs = tf.nn.embedding_lookup(word_embedding, _inputs)
# dropout
if self.is_training and self.config.dropout > 0:
inputs = tf.nn.dropout(inputs, keep_prob=1. - self.config.dropout)
# lstm
# using tf.nn.dynamic_rnn to remove the constrains of step size.
outputs, state = tf.nn.dynamic_rnn(cell,
inputs=inputs,
initial_state=init_states,
sequence_length=_lengths)
# softmax
softmax = layers.Softmax(outputs, _targets, self.config.vocab_size,
self.config.softmax_pred_token_per_cluster,
name='Softmax')
return softmax, state
def run_update(self, session, inputs, targets, lengths, scales, learning_rate=None):
if learning_rate is None:
learning_rate = self.config.learning_rate
self.train_op.set_lr(session, learning_rate)
self.train_op.update(session, {self._inputs: inputs,
self._targets: targets,
self._lengths: lengths,
self._scales: scales})
def run_loss(self, session, inputs, targets, lengths):
return session.run(self.loss_for_sequence, {self._inputs: inputs,
self._targets: targets,
self._lengths: lengths})
def run_draws(self, session, inputs, max_sample_num, end_id=None):
states = session.run(self.final_state, {self._inputs: inputs[:, 0:-1]})
final_outputs = np.array(inputs)
final_lengths = np.ones(inputs.shape[0], dtype='int32') * inputs.shape[1]
final_logps = np.zeros_like(inputs)
is_tail = np.array([False] * len(inputs))
for i in range(max_sample_num):
draw_w, draw_logp, states = session.run(self.softmax.draw + [self.final_state],
{self._inputs: final_outputs[:, -1:],
self._initial_state: states})
final_outputs = np.concatenate([final_outputs, draw_w], axis=-1)
final_lengths += np.where(is_tail, 0, 1)
final_logps = np.concatenate([final_logps, draw_logp], axis=-1)
if end_id is not None:
is_tail = np.logical_or(is_tail, np.reshape(draw_w, [-1]) == end_id)
if np.all(is_tail):
break
return final_outputs, final_lengths, final_logps
def run_logps(self, session, inputs):
final_logps = session.run(self.logps_for_position, {self._inputs: inputs[:, 0:-1],
self._targets: inputs[:, 1:]})
final_logps = np.concatenate([np.zeros([len(inputs), 1]), final_logps], axis=-1)
return final_logps
# parallize the sampling
class NetEval(object):
def __init__(self, config, name='lstm_net', devices=['/gpu:0', '/gpu:1']):
self.device_num = len(devices)
self.nets = []
for device in devices:
with tf.device(device):
self.nets.append(Net(config, is_training=False, name=name, reuse=True))
with tf.device(devices[0]):
draw_w_list = [net.softmax.draw[0] for net in self.nets]
draw_logp_list = [net.softmax.draw[1] for net in self.nets]
self.draw_w = tf.concat(draw_w_list, axis=0)
self.draw_logp = tf.concat(draw_logp_list, axis=0)
loss_list = [net.loss_for_sequence for net in self.nets]
self.loss_for_sequence = tf.concat(loss_list, axis=0)
def split_data(self, a):
n = len(a)
k = n // self.device_num
res = []
for i in range(self.device_num):
if i == self.device_num - 1:
res.append(a[k * i: ])
else:
res.append(a[k * i: k * (i+1)])
return res
def run_loss(self, session, inputs, targets, lengths):
feed_dict = {}
for net, i, t, l in zip(self.nets, self.split_data(inputs), self.split_data(targets), self.split_data(lengths)):
feed_dict[net._inputs] = i
feed_dict[net._targets] = t
feed_dict[net._lengths] = l
return session.run(self.loss_for_sequence, feed_dict)
def run_draws(self, session, inputs, max_sample_num, end_id=None):
feed_dict = {}
for net, i in zip(self.nets, self.split_data(inputs)):
feed_dict[net._inputs] = i[:, 0:-1]
# get states ( a list of state )
states = session.run([net.final_state for net in self.nets], feed_dict)
final_outputs = np.array(inputs)
final_lengths = np.ones(inputs.shape[0], dtype='int32') * inputs.shape[1]
final_logps = np.zeros_like(inputs)
is_tail = np.array([False] * len(inputs))
for i in range(max_sample_num):
feed_dict = {}
for net, st, i in zip(self.nets, states, self.split_data(final_outputs[:, -1:])):
feed_dict[net._inputs] = i
feed_dict[net._initial_state] = st
draw_w, draw_logp, states = session.run([self.draw_w,
self.draw_logp,
[net.final_state for net in self.nets]
], feed_dict)
final_outputs = np.concatenate([final_outputs, draw_w], axis=-1)
final_lengths += np.where(is_tail, 0, 1)
final_logps = np.concatenate([final_logps, draw_logp], axis=-1)
if end_id is not None:
is_tail = np.logical_or(is_tail, np.reshape(draw_w, [-1]) == end_id)
if np.all(is_tail):
break
return final_outputs, final_lengths, final_logps
class Model(object):
def __init__(self, config, name='seq_lstmlm', devices='/gpu:0'):
if isinstance(devices, str):
with tf.device(devices):
self.train_net = Net(config, is_training=True, name=name, reuse=None)
self.eval_net = Net(config, is_training=False, name=name, reuse=True)
else:
with tf.device(devices[0]):
self.train_net = Net(config, is_training=True, name=name, reuse=None)
self.eval_net = NetEval(config, name=name, devices=devices)
self.saver = tf.train.Saver(self.train_net.vars)
def update(self, session, seq_list, seq_scales, learning_rate=None):
inputs, lengths = reader.produce_data_to_array(seq_list)
self.train_net.run_update(session,
inputs[:, 0:-1], inputs[:, 1:], lengths-1, seq_scales,
learning_rate)
def get_log_probs(self, session, seq_list, max_batch_size=None):
if max_batch_size is None:
max_batch_size = len(seq_list)
logps = np.zeros(len(seq_list))
for i in range(0, len(seq_list), max_batch_size):
j = i + max_batch_size
inputs, lengths = reader.produce_data_to_array(seq_list[i:j])
logps[i: j] = -self.eval_net.run_loss(session, inputs[:, 0:-1], inputs[:, 1:], lengths-1)
return logps
def eval(self, session, seq_list):
logps = self.get_log_probs(session, seq_list)
nll = -np.mean(logps)
words = np.sum([len(x) - 1 for x in seq_list])
ppl = np.exp(-np.sum(logps) / words)
return nll, ppl
def draw_seqs(self, session, batch_size, beg_token, end_token=None, max_length=1000):
inputs = | np.ones([batch_size, 1], dtype='int32') | numpy.ones |
from __future__ import division, absolute_import, print_function
import numpy as np
try:
from scipy.spatial import cKDTree, KDTree, SphericalVoronoi, distance
except ImportError:
pass
from .common import Benchmark
class Build(Benchmark):
params = [
[(3,10000,1000), (8,10000,1000), (16,10000,1000)],
['KDTree', 'cKDTree'],
]
param_names = ['(m, n, r)', 'class']
def setup(self, mnr, cls_name):
self.cls = KDTree if cls_name == 'KDTree' else cKDTree
m, n, r = mnr
np.random.seed(1234)
self.data = np.concatenate((np.random.randn(n//2,m),
np.random.randn(n-n//2,m)+np.ones(m)))
self.queries = np.concatenate((np.random.randn(r//2,m),
np.random.randn(r-r//2,m)+np.ones(m)))
def time_build(self, mnr, cls_name):
"""
Constructing kd-tree
=======================
dim | # points | time
"""
m, n, r = mnr
if cls_name == 'cKDTree_flat':
self.T = self.cls(self.data, leafsize=n)
else:
self.cls(self.data)
LEAF_SIZES = [8, 128]
BOX_SIZES = [None, 1.0]
class Query(Benchmark):
params = [
[(3,10000,1000), (8,10000,1000), (16,10000,1000)],
[1, 2, np.inf],
BOX_SIZES, LEAF_SIZES,
]
param_names = ['(m, n, r)', 'p', 'boxsize', 'leafsize']
@staticmethod
def do_setup(self, mnr, p, boxsize, leafsize):
m, n, r = mnr
np.random.seed(1234)
self.data = np.random.uniform(size=(n, m))
self.queries = np.random.uniform(size=(r, m))
self.T = cKDTree(self.data, leafsize=leafsize, boxsize=boxsize)
def setup(self, mnr, p, boxsize, leafsize):
Query.do_setup(self, mnr, p, boxsize, leafsize)
def time_query(self, mnr, p, boxsize, leafsize):
"""
Querying kd-tree
dim | # points | # queries | KDTree | cKDTree | flat cKDTree
"""
self.T.query(self.queries, p=p)
class Radius(Benchmark):
params = [
[(3,10000,1000)],
[1, 2, np.inf],
[0.2, 0.5],
BOX_SIZES, LEAF_SIZES,
]
param_names = ['(m, n, r)', 'p', 'probe radius', 'boxsize', 'leafsize']
def __init__(self):
self.time_query_pairs.__func__.params = list(self.params)
self.time_query_pairs.__func__.params[0] = [(3,1000,30),
(8,1000,30),
(16,1000,30)]
def setup(self, mnr, p, probe_radius, boxsize, leafsize):
Query.do_setup(self, mnr, p, boxsize, leafsize)
def time_query_ball_point(self, mnr, p, probe_radius, boxsize, leafsize):
self.T.query_ball_point(self.queries, probe_radius, p=p)
def time_query_pairs(self, mnr, p, probe_radius, boxsize, leafsize):
self.T.query_pairs(probe_radius, p=p)
class Neighbors(Benchmark):
params = [
[(3,1000,1000),
(8,1000,1000),
(16,1000,1000)],
[1, 2, np.inf],
[0.2, 0.5],
BOX_SIZES, LEAF_SIZES,
]
param_names = ['(m, n1, n2)', 'p', 'probe radius', 'boxsize', 'leafsize']
def setup(self, mn1n2, p, probe_radius, boxsize, leafsize):
m, n1, n2 = mn1n2
self.data1 = np.random.uniform(size=(n1, m))
self.data2 = np.random.uniform(size=(n2, m))
self.T1 = cKDTree(self.data1, boxsize=boxsize, leafsize=leafsize)
self.T2 = cKDTree(self.data2, boxsize=boxsize, leafsize=leafsize)
def time_sparse_distance_matrix(self, mn1n2, p, probe_radius, boxsize, leafsize):
self.T1.sparse_distance_matrix(self.T2, probe_radius, p=p)
def time_count_neighbors(self, mn1n2, p, probe_radius, boxsize, leafsize):
"""
Count neighbors kd-tree
dim | # points T1 | # points T2 | p | probe radius | BoxSize | LeafSize
"""
self.T1.count_neighbors(self.T2, probe_radius, p=p)
def generate_spherical_points(num_points):
# generate uniform points on sphere (see:
# http://stackoverflow.com/a/23785326/2942522)
np.random.seed(123)
points = np.random.normal(size=(num_points, 3))
points /= np.linalg.norm(points, axis=1)[:, np.newaxis]
return points
class SphericalVor(Benchmark):
params = [10, 100, 1000, 5000, 10000]
param_names = ['num_points']
def setup(self, num_points):
self.points = generate_spherical_points(num_points)
def time_spherical_voronoi_calculation(self, num_points):
"""Perform spherical Voronoi calculation, but not the sorting of
vertices in the Voronoi polygons.
"""
SphericalVoronoi(self.points, radius=1, center=np.zeros(3))
class SphericalVorSort(Benchmark):
params = [10, 100, 1000, 5000, 10000]
param_names = ['num_points']
def setup(self, num_points):
self.points = generate_spherical_points(num_points)
self.sv = SphericalVoronoi(self.points, radius=1,
center=np.zeros(3))
def time_spherical_polygon_vertex_sorting(self, num_points):
"""Time the vertex sorting operation in the Spherical Voronoi
code.
"""
self.sv.sort_vertices_of_regions()
class Cdist(Benchmark):
params = ([10, 100, 1000], ['euclidean', 'minkowski', 'cityblock',
'seuclidean', 'sqeuclidean', 'cosine', 'correlation', 'hamming', 'jaccard',
'chebyshev', 'canberra', 'braycurtis', 'mahalanobis', 'yule', 'dice',
'kulsinski', 'rogerstanimoto', 'russellrao', 'sokalmichener',
'sokalsneath', 'wminkowski'])
param_names = ['num_points', 'metric']
def setup(self, num_points, metric):
| np.random.seed(123) | numpy.random.seed |
"""
Tests for General Tree Inference Library (GTIL). The tests ensure that GTIL produces correct
prediction results for a variety of tree models.
"""
import os
import pytest
import treelite
import xgboost as xgb
import lightgbm as lgb
import numpy as np
import scipy
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, \
ExtraTreesClassifier, RandomForestRegressor, GradientBoostingRegressor, \
ExtraTreesRegressor
from sklearn.datasets import load_iris, load_breast_cancer, load_boston, load_svmlight_file
from sklearn.model_selection import train_test_split
from .metadata import dataset_db
from .util import load_txt
@pytest.mark.parametrize('clazz', [RandomForestRegressor, ExtraTreesRegressor,
GradientBoostingRegressor])
def test_skl_regressor(clazz):
"""Scikit-learn regressor"""
X, y = load_boston(return_X_y=True)
kwargs = {'max_depth': 3, 'random_state': 0, 'n_estimators': 10}
if clazz == GradientBoostingRegressor:
kwargs['init'] = 'zero'
clf = clazz(**kwargs)
clf.fit(X, y)
expected_pred = clf.predict(X)
tl_model = treelite.sklearn.import_model(clf)
out_pred = treelite.gtil.predict(tl_model, X)
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
@pytest.mark.parametrize('clazz', [RandomForestClassifier, ExtraTreesClassifier,
GradientBoostingClassifier])
def test_skl_binary_classifier(clazz):
"""Scikit-learn binary classifier"""
X, y = load_breast_cancer(return_X_y=True)
kwargs = {'max_depth': 3, 'random_state': 0, 'n_estimators': 10}
if clazz == GradientBoostingClassifier:
kwargs['init'] = 'zero'
clf = clazz(**kwargs)
clf.fit(X, y)
expected_prob = clf.predict_proba(X)[:, 1]
tl_model = treelite.sklearn.import_model(clf)
out_prob = treelite.gtil.predict(tl_model, X)
np.testing.assert_almost_equal(out_prob, expected_prob, decimal=5)
@pytest.mark.parametrize('clazz', [RandomForestClassifier, ExtraTreesClassifier,
GradientBoostingClassifier])
def test_skl_multiclass_classifier(clazz):
"""Scikit-learn multi-class classifier"""
X, y = load_iris(return_X_y=True)
kwargs = {'max_depth': 3, 'random_state': 0, 'n_estimators': 10}
if clazz == GradientBoostingClassifier:
kwargs['init'] = 'zero'
clf = clazz(**kwargs)
clf.fit(X, y)
expected_prob = clf.predict_proba(X)
tl_model = treelite.sklearn.import_model(clf)
out_prob = treelite.gtil.predict(tl_model, X)
np.testing.assert_almost_equal(out_prob, expected_prob, decimal=5)
@pytest.mark.parametrize('objective', ['reg:linear', 'reg:squarederror', 'reg:squaredlogerror',
'reg:pseudohubererror'])
@pytest.mark.parametrize('model_format', ['binary', 'json'])
def test_xgb_boston(tmpdir, model_format, objective):
# pylint: disable=too-many-locals
"""Test XGBoost with Boston data (regression)"""
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
param = {'max_depth': 8, 'eta': 1, 'silent': 1, 'objective': objective}
num_round = 10
xgb_model = xgb.train(param, dtrain, num_boost_round=num_round,
evals=[(dtrain, 'train'), (dtest, 'test')])
if model_format == 'json':
model_name = 'boston.json'
model_path = os.path.join(tmpdir, model_name)
xgb_model.save_model(model_path)
tl_model = treelite.Model.load(filename=model_path, model_format='xgboost_json')
else:
tl_model = treelite.Model.from_xgboost(xgb_model)
out_pred = treelite.gtil.predict(tl_model, X_test)
expected_pred = xgb_model.predict(dtest)
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
@pytest.mark.parametrize('model_format', ['binary', 'json'])
@pytest.mark.parametrize('objective', ['multi:softmax', 'multi:softprob'])
def test_xgb_iris(tmpdir, objective, model_format):
# pylint: disable=too-many-locals
"""Test XGBoost with Iris data (multi-class classification)"""
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
param = {'max_depth': 6, 'eta': 0.05, 'num_class': 3, 'verbosity': 0,
'objective': objective, 'metric': 'mlogloss'}
xgb_model = xgb.train(param, dtrain, num_boost_round=10,
evals=[(dtrain, 'train'), (dtest, 'test')])
if model_format == 'json':
model_name = 'iris.json'
model_path = os.path.join(tmpdir, model_name)
xgb_model.save_model(model_path)
tl_model = treelite.Model.load(filename=model_path, model_format='xgboost_json')
else:
tl_model = treelite.Model.from_xgboost(xgb_model)
out_pred = treelite.gtil.predict(tl_model, X_test)
expected_pred = xgb_model.predict(dtest)
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
@pytest.mark.parametrize('model_format', ['binary', 'json'])
@pytest.mark.parametrize('objective,max_label',
[('binary:logistic', 2),
('binary:hinge', 2),
('binary:logitraw', 2),
('count:poisson', 4),
('rank:pairwise', 5),
('rank:ndcg', 5),
('rank:map', 5)],
ids=['binary:logistic', 'binary:hinge', 'binary:logitraw',
'count:poisson', 'rank:pairwise', 'rank:ndcg', 'rank:map'])
def test_xgb_nonlinear_objective(tmpdir, objective, max_label, model_format):
# pylint: disable=too-many-locals
"""Test XGBoost with non-linear objectives with dummy data"""
nrow = 16
ncol = 8
rng = np.random.default_rng(seed=0)
X = rng.standard_normal(size=(nrow, ncol), dtype=np.float32)
y = rng.integers(0, max_label, size=nrow)
assert np.min(y) == 0
assert np.max(y) == max_label - 1
num_round = 4
dtrain = xgb.DMatrix(X, label=y)
if objective.startswith('rank:'):
dtrain.set_group([nrow])
xgb_model = xgb.train({'objective': objective, 'base_score': 0.5, 'seed': 0},
dtrain=dtrain, num_boost_round=num_round)
objective_tag = objective.replace(':', '_')
if model_format == 'json':
model_name = f'nonlinear_{objective_tag}.json'
else:
model_name = f'nonlinear_{objective_tag}.bin'
model_path = os.path.join(tmpdir, model_name)
xgb_model.save_model(model_path)
tl_model = treelite.Model.load(
filename=model_path,
model_format=('xgboost_json' if model_format == 'json' else 'xgboost'))
out_pred = treelite.gtil.predict(tl_model, X)
expected_pred = xgb_model.predict(dtrain)
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
def test_xgb_categorical_split():
"""Test toy XGBoost model with categorical splits"""
dataset = 'xgb_toy_categorical'
tl_model = treelite.Model.load(dataset_db[dataset].model, model_format='xgboost_json')
X, _ = load_svmlight_file(dataset_db[dataset].dtest, zero_based=True)
expected_pred = load_txt(dataset_db[dataset].expected_margin)
out_pred = treelite.gtil.predict(tl_model, X.toarray())
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
@pytest.mark.parametrize('model_format', ['binary', 'json'])
def test_xgb_dart(tmpdir, model_format):
# pylint: disable=too-many-locals
"""Test XGBoost DART model with dummy data"""
nrow = 16
ncol = 8
rng = np.random.default_rng(seed=0)
X = rng.standard_normal(size=(nrow, ncol))
y = rng.integers(0, 2, size=nrow)
assert np.min(y) == 0
assert np.max(y) == 1
num_round = 50
dtrain = xgb.DMatrix(X, label=y)
param = {'booster': 'dart',
'max_depth': 5, 'learning_rate': 0.1,
'objective': 'binary:logistic',
'sample_type': 'uniform',
'normalize_type': 'tree',
'rate_drop': 0.1,
'skip_drop': 0.5}
xgb_model = xgb.train(param, dtrain=dtrain, num_boost_round=num_round)
if model_format == 'json':
model_name = 'dart.json'
model_path = os.path.join(tmpdir, model_name)
xgb_model.save_model(model_path)
tl_model = treelite.Model.load(filename=model_path, model_format='xgboost_json')
else:
tl_model = treelite.Model.from_xgboost(xgb_model)
out_pred = treelite.gtil.predict(tl_model, X)
expected_pred = xgb_model.predict(dtrain)
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
@pytest.mark.parametrize('objective', ['regression', 'regression_l1', 'huber'])
@pytest.mark.parametrize('reg_sqrt', [True, False])
def test_lightgbm_regression(tmpdir, objective, reg_sqrt):
# pylint: disable=too-many-locals
"""Test LightGBM regressor"""
lgb_model_path = os.path.join(tmpdir, 'boston_lightgbm.txt')
X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
dtrain = lgb.Dataset(X_train, y_train, free_raw_data=False)
dtest = lgb.Dataset(X_test, y_test, reference=dtrain, free_raw_data=False)
param = {'task': 'train', 'boosting_type': 'gbdt', 'objective': objective, 'reg_sqrt': reg_sqrt,
'metric': 'rmse', 'num_leaves': 31, 'learning_rate': 0.05}
lgb_model = lgb.train(param, dtrain, num_boost_round=10, valid_sets=[dtrain, dtest],
valid_names=['train', 'test'])
expected_pred = lgb_model.predict(X_test)
lgb_model.save_model(lgb_model_path)
tl_model = treelite.Model.load(lgb_model_path, model_format='lightgbm')
out_pred = treelite.gtil.predict(tl_model, X_test)
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
@pytest.mark.parametrize('objective', ['binary', 'xentlambda', 'xentropy'])
def test_lightgbm_binary_classification(tmpdir, objective):
# pylint: disable=too-many-locals
"""Test LightGBM binary classifier"""
lgb_model_path = os.path.join(tmpdir, 'breast_cancer_lightgbm.txt')
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
dtrain = lgb.Dataset(X_train, y_train, free_raw_data=False)
dtest = lgb.Dataset(X_test, y_test, reference=dtrain, free_raw_data=False)
param = {'task': 'train', 'boosting_type': 'gbdt', 'objective': objective, 'metric': 'auc',
'num_leaves': 7, 'learning_rate': 0.1}
lgb_model = lgb.train(param, dtrain, num_boost_round=10, valid_sets=[dtrain, dtest],
valid_names=['train', 'test'])
expected_prob = lgb_model.predict(X_test)
lgb_model.save_model(lgb_model_path)
tl_model = treelite.Model.load(lgb_model_path, model_format='lightgbm')
out_prob = treelite.gtil.predict(tl_model, X_test)
np.testing.assert_almost_equal(out_prob, expected_prob, decimal=5)
@pytest.mark.parametrize('boosting_type', ['gbdt', 'rf'])
@pytest.mark.parametrize('objective', ['multiclass', 'multiclassova'])
def test_lightgbm_multiclass_classification(tmpdir, objective, boosting_type):
# pylint: disable=too-many-locals
"""Test LightGBM multi-class classifier"""
lgb_model_path = os.path.join(tmpdir, 'iris_lightgbm.txt')
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
dtrain = lgb.Dataset(X_train, y_train, free_raw_data=False)
dtest = lgb.Dataset(X_test, y_test, reference=dtrain, free_raw_data=False)
param = {'task': 'train', 'boosting': boosting_type, 'objective': objective,
'metric': 'multi_logloss', 'num_class': 3, 'num_leaves': 31, 'learning_rate': 0.05}
if boosting_type == 'rf':
param.update({'bagging_fraction': 0.8, 'bagging_freq': 1})
lgb_model = lgb.train(param, dtrain, num_boost_round=10, valid_sets=[dtrain, dtest],
valid_names=['train', 'test'])
expected_pred = lgb_model.predict(X_test)
lgb_model.save_model(lgb_model_path)
tl_model = treelite.Model.load(lgb_model_path, model_format='lightgbm')
out_pred = treelite.gtil.predict(tl_model, X_test)
np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5)
def test_lightgbm_categorical_data():
"""Test LightGBM with toy categorical data"""
dataset = 'toy_categorical'
lgb_model_path = dataset_db[dataset].model
tl_model = treelite.Model.load(lgb_model_path, model_format='lightgbm')
X, _ = load_svmlight_file(dataset_db[dataset].dtest, zero_based=True)
expected_pred = load_txt(dataset_db[dataset].expected_margin)
out_pred = treelite.gtil.predict(tl_model, X.toarray())
| np.testing.assert_almost_equal(out_pred, expected_pred, decimal=5) | numpy.testing.assert_almost_equal |
import numpy as np
from at import *
from at.load import load_mat
from matplotlib import pyplot as plt
import matplotlib.pyplot as plt
import at.plot
import numpy as np
from pylab import *
import pandas as pd
import csv
from random import random
def defineMatrices( Nm, C0x, C0y, C0xy, C0yx, Cxx_err, Cyy_err, Cxy_err, Cyx_err, dCx, dCy, dCxy,dCyx ):
Nk = len(dCx) # number of free parameters
Nm = 40 # number of measurements
print('NK:', Nk)
print('Nm:', Nm)
Ax = np.zeros([Nk, Nk])
Ay = np.zeros([Nk, Nk])
Axy = np.zeros([Nk, Nk])
Ayx = np.zeros([Nk, Nk])
A = np.zeros([4 * Nk, Nk])
##
Bx = np.zeros([Nk, 1])
By = np.zeros([Nk, 1])
Bxy = np.zeros([Nk, 1])
Byx = np.zeros([Nk, 1])
B = np.zeros([4 * Nk, 1])
##
Dx = (Cxx_err[0:Nm, :] - C0x[0:Nm, :]) ### dk ?
Dy = (Cyy_err[0:Nm, :] - C0y[0:Nm, :])
Dxy = (Cxy_err[0:Nm, :] - C0xy[0:Nm, :])
Dyx = (Cyx_err[0:Nm, :] - C0yx[0:Nm, :])
##
for i in range(Nk): ## i represents each quad
# print('done A:', 100.* i ,'%')
for j in range(Nk):
Ax[i, j] = np.sum(np.dot(dCx[i], dCx[j].T))
Ay[i, j] = np.sum(np.dot(dCy[i], dCy[j].T))
Axy[i, j] = np.sum(np.dot(dCxy[i], dCxy[j].T))
Ayx[i, j] = np.sum(np.dot(dCyx[i], dCyx[j].T))
A[i, :] = Ax[i, :]
A[i + Nk, :] = Ay[i, :]
A[i + 2 * Nk, :] = Axy[i, :]
A[i + 3 * Nk, :] = Ayx[i, :]
##
for i in range(Nk):
Bx[i] = np.sum(np.dot(dCx[i], Dx.T))
By[i] = np.sum(np.dot(dCy[i], Dy.T))
Bxy[i] = np.sum(np.dot(dCxy[i], Dxy.T))
Byx[i] = np.sum(np.dot(dCyx[i], Dyx.T))
B[i] = Bx[i]
B[i + Nk] = By[i]
B[i + 2 * Nk] = Bxy[i]
B[i + 3 * Nk] = Byx[i]
return A, B
def getInverse(A, B,Nk, sCut):
u, s, v = np.linalg.svd(A, full_matrices=True)
smat = 0.0 * A
si = s ** -1
n_sv = sCut
si[n_sv:] *= 0.0
print("number of singular values {}".format(len(si)))
smat[:Nk, :Nk] = np.diag(si)
print('A' + str(A.shape), 'B' + str(B.shape), 'U' + str(u.shape), 'smat' + str(smat.shape), 'v' + str(v.shape))
plt.plot(np.log(s), 'd--')
plt.title('singular value')
plt.show()
plt.plot(si, 'd--')
plt.title('singular value inverse')
plt.show()
Ai = np.dot(v.transpose(), np.dot(smat.transpose(), u.transpose()))
###
r = ( | np.dot(Ai, B) | numpy.dot |
import copy
import grp
import matplotlib
import matplotlib.cm
import numpy as np
import os
import re
import sys
import threading
# OpenCV import for python3.5
if os.environ['ROS_PYTHON_VERSION'] == '3':
import cv2
else:
sys.path.remove('/opt/ros/{}/lib/python2.7/dist-packages'.format(os.getenv('ROS_DISTRO'))) # NOQA
import cv2 # NOQA
sys.path.append('/opt/ros/{}/lib/python2.7/dist-packages'.format(os.getenv('ROS_DISTRO'))) # NOQA
from cv_bridge import CvBridge
from edgetpu.basic.edgetpu_utils import EDGE_TPU_STATE_ASSIGNED
from edgetpu.basic.edgetpu_utils import EDGE_TPU_STATE_NONE
from edgetpu.basic.edgetpu_utils import ListEdgeTpuPaths
from edgetpu.detection.engine import DetectionEngine
import PIL.Image
from resource_retriever import get_filename
import rospy
from coral_usb.util import get_panorama_sliced_image
from coral_usb.util import get_panorama_slices
from coral_usb.util import non_maximum_suppression
from jsk_recognition_msgs.msg import ClassificationResult
from jsk_recognition_msgs.msg import Rect
from jsk_recognition_msgs.msg import RectArray
from jsk_topic_tools import ConnectionBasedTransport
from sensor_msgs.msg import CompressedImage
from sensor_msgs.msg import Image
class EdgeTPUDetectorBase(ConnectionBasedTransport):
def __init__(self, model_file=None, label_file=None, namespace='~'):
# get image_trasport before ConnectionBasedTransport subscribes ~input
self.transport_hint = rospy.get_param(
namespace + 'image_transport', 'raw')
rospy.loginfo("Using transport {}".format(self.transport_hint))
super(EdgeTPUDetectorBase, self).__init__()
self.bridge = CvBridge()
self.classifier_name = rospy.get_param(
namespace + 'classifier_name', rospy.get_name())
self.model_file = rospy.get_param(namespace + 'model_file', model_file)
if self.model_file is not None:
self.model_file = get_filename(self.model_file, False)
self.label_file = rospy.get_param(namespace + 'label_file', label_file)
if self.label_file is not None:
self.label_file = get_filename(self.label_file, False)
self.duration = rospy.get_param(namespace + 'visualize_duration', 0.1)
self.enable_visualization = rospy.get_param(
namespace + 'enable_visualization', True)
device_id = rospy.get_param(namespace + 'device_id', None)
if device_id is None:
device_path = None
else:
device_paths = ListEdgeTpuPaths(EDGE_TPU_STATE_NONE)
if len(device_paths) == 0:
rospy.logerr('No device found.')
elif device_id >= len(device_paths):
rospy.logerr(
'Only {} devices are found, but device id {} is set.'
.format(len(device_paths), device_id))
device_path = device_paths[device_id]
assigned_device_paths = ListEdgeTpuPaths(EDGE_TPU_STATE_ASSIGNED)
if device_path in assigned_device_paths:
rospy.logwarn(
'device {} is already assigned: {}'.format(
device_id, device_path))
self.device_path = device_path
if not grp.getgrnam('plugdev').gr_gid in os.getgroups():
rospy.logerr('Current user does not belong to plugdev group')
rospy.logerr('Please run `sudo adduser $(whoami) plugdev`')
rospy.logerr(
'And make sure to re-login the terminal by `su -l $(whoami)`')
if self.model_file is not None:
self.engine = DetectionEngine(
self.model_file, device_path=self.device_path)
if self.label_file is None:
self.label_ids = None
self.label_names = None
else:
self.label_ids, self.label_names = self._load_labels(
self.label_file)
# dynamic reconfigure
self.start_dynamic_reconfigure(namespace)
self.pub_rects = self.advertise(
namespace + 'output/rects', RectArray, queue_size=1)
self.pub_class = self.advertise(
namespace + 'output/class', ClassificationResult, queue_size=1)
# visualize timer
if self.enable_visualization:
self.lock = threading.Lock()
self.pub_image = self.advertise(
namespace + 'output/image', Image, queue_size=1)
self.pub_image_compressed = self.advertise(
namespace + 'output/image/compressed',
CompressedImage, queue_size=1)
self.timer = rospy.Timer(
rospy.Duration(self.duration), self.visualize_cb)
self.img = None
self.header = None
self.bboxes = None
self.labels = None
self.scores = None
def start(self):
if self.model_file is not None:
self.engine = DetectionEngine(
self.model_file, device_path=self.device_path)
self.subscribe()
if self.enable_visualization:
self.timer = rospy.Timer(
rospy.Duration(self.duration), self.visualize_cb)
def stop(self):
self.unsubscribe()
del self.sub_image
if self.enable_visualization:
self.timer.shutdown()
del self.timer
del self.engine
def subscribe(self):
if self.transport_hint == 'compressed':
self.sub_image = rospy.Subscriber(
'{}/compressed'.format(rospy.resolve_name('~input')),
CompressedImage, self.image_cb, queue_size=1, buff_size=2**26)
else:
self.sub_image = rospy.Subscriber(
'~input', Image, self.image_cb, queue_size=1, buff_size=2**26)
def unsubscribe(self):
self.sub_image.unregister()
@property
def visualize(self):
return self.pub_image.get_num_connections() > 0 or \
self.pub_image_compressed.get_num_connections() > 0
def config_callback(self, config, level):
self.score_thresh = config.score_thresh
self.top_k = config.top_k
self.model_file = get_filename(config.model_file, False)
if 'label_file' in config:
self.label_file = get_filename(config.label_file, False)
self.label_ids, self.label_names = self._load_labels(
self.label_file)
if self.model_file is not None:
self.engine = DetectionEngine(
self.model_file, device_path=self.device_path)
return config
def _load_labels(self, path):
p = re.compile(r'\s*(\d+)(.+)')
with open(path, 'r', encoding='utf-8') as f:
lines = (p.match(line).groups() for line in f.readlines())
labels = {int(num): text.strip() for num, text in lines}
return list(labels.keys()), list(labels.values())
def _process_result(self, objs, H, W, y_offset=None, x_offset=None):
bboxes = []
labels = []
scores = []
for obj in objs:
x_min, y_min, x_max, y_max = obj.bounding_box.flatten().tolist()
y_max = int(np.round(y_max * H))
y_min = int(np.round(y_min * H))
if y_offset:
y_max = y_max + y_offset
y_min = y_min + y_offset
x_max = int(np.round(x_max * W))
x_min = int(np.round(x_min * W))
if x_offset:
x_max = x_max + x_offset
x_min = x_min + x_offset
bboxes.append([y_min, x_min, y_max, x_max])
labels.append(self.label_ids.index(int(obj.label_id)))
scores.append(obj.score)
bboxes = np.array(bboxes, dtype=np.int).reshape((len(bboxes), 4))
labels = np.array(labels, dtype=np.int)
scores = np.array(scores, dtype=np.float)
return bboxes, labels, scores
def _detect_step(self, img, y_offset=None, x_offset=None):
H, W = img.shape[:2]
objs = self.engine.DetectWithImage(
PIL.Image.fromarray(img), threshold=self.score_thresh,
keep_aspect_ratio=True, relative_coord=True,
top_k=self.top_k)
return self._process_result(
objs, H, W, y_offset=y_offset, x_offset=x_offset)
def _detect(self, img):
return self._detect_step(img)
def image_cb(self, msg):
if not hasattr(self, 'engine'):
return
if self.transport_hint == 'compressed':
np_arr = np.fromstring(msg.data, np.uint8)
img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
img = img[:, :, ::-1]
else:
img = self.bridge.imgmsg_to_cv2(msg, desired_encoding='rgb8')
bboxes, labels, scores = self._detect(img)
rect_msg = RectArray(header=msg.header)
for bbox in bboxes:
y_min, x_min, y_max, x_max = bbox
rect = Rect(
x=x_min, y=y_min,
width=x_max - x_min, height=y_max - y_min)
rect_msg.rects.append(rect)
cls_msg = ClassificationResult(
header=msg.header,
classifier=self.classifier_name,
target_names=self.label_names,
labels=labels,
label_names=[self.label_names[lbl] for lbl in labels],
label_proba=scores)
self.pub_rects.publish(rect_msg)
self.pub_class.publish(cls_msg)
if self.enable_visualization:
with self.lock:
self.img = img
self.header = msg.header
self.bboxes = bboxes
self.labels = labels
self.scores = scores
def visualize_cb(self, event):
if (not self.visualize or self.img is None
or self.header is None or self.bboxes is None
or self.labels is None or self.scores is None):
return
with self.lock:
vis_img = self.img.copy()
header = copy.deepcopy(self.header)
bboxes = self.bboxes.copy()
labels = self.labels.copy()
scores = self.scores.copy()
# bbox
cmap = matplotlib.cm.get_cmap('hsv')
n = max(len(bboxes) - 1, 10)
for i, (bbox, label, score) in enumerate(zip(bboxes, labels, scores)):
rgba = np.array(cmap(1. * i / n))
color = rgba[:3] * 255
label_text = '{}, {:.2f}'.format(self.label_names[label], score)
p1y = max(bbox[0], 0)
p1x = max(bbox[1], 0)
p2y = min(bbox[2], vis_img.shape[0])
p2x = min(bbox[3], vis_img.shape[1])
cv2.rectangle(
vis_img, (p1x, p1y), (p2x, p2y),
color, thickness=3, lineType=cv2.LINE_AA)
cv2.putText(
vis_img, label_text, (p1x, max(p1y - 10, 0)),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, color,
thickness=2, lineType=cv2.LINE_AA)
if self.pub_image.get_num_connections() > 0:
vis_msg = self.bridge.cv2_to_imgmsg(vis_img, 'rgb8')
# BUG: https://answers.ros.org/question/316362/sensor_msgsimage-generates-float-instead-of-int-with-python3/ # NOQA
vis_msg.step = int(vis_msg.step)
vis_msg.header = header
self.pub_image.publish(vis_msg)
if self.pub_image_compressed.get_num_connections() > 0:
# publish compressed http://wiki.ros.org/rospy_tutorials/Tutorials/WritingImagePublisherSubscriber # NOQA
vis_compressed_msg = CompressedImage()
vis_compressed_msg.header = header
vis_compressed_msg.format = "jpeg"
vis_img_rgb = cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB)
vis_compressed_msg.data = np.array(
cv2.imencode('.jpg', vis_img_rgb)[1]).tostring()
self.pub_image_compressed.publish(vis_compressed_msg)
class EdgeTPUPanoramaDetectorBase(EdgeTPUDetectorBase):
def __init__(self, model_file=None, label_file=None, namespace='~'):
super(EdgeTPUPanoramaDetectorBase, self).__init__(
model_file=model_file, label_file=label_file, namespace=namespace
)
def _detect(self, orig_img):
_, orig_W = orig_img.shape[:2]
panorama_slices = get_panorama_slices(
orig_W, self.n_split, overlap=self.overlap)
bboxes = []
labels = []
scores = []
for panorama_slice in panorama_slices:
img = get_panorama_sliced_image(orig_img, panorama_slice)
bbox, label, score = self._detect_step(
img, x_offset=panorama_slice.start)
if len(bbox) > 0:
bboxes.append(bbox)
labels.append(label)
scores.append(score)
if len(bboxes) > 0:
bboxes = np.concatenate(bboxes, axis=0).astype(np.int)
labels = np.concatenate(labels, axis=0).astype(np.int)
scores = | np.concatenate(scores, axis=0) | numpy.concatenate |
import numpy
import os
import matplotlib.pyplot as plt
import errandpy.handy as handy
import errandpy.utility as Utility
def get_test_curve():
x, y = [], []
with open(os.path.dirname(__file__) + "/forcecurve.csv") as f:
next(f)
lines = f.readlines()
for line in lines:
x.append(float(line.split(",")[0]))
y.append(float(line.split(",")[1]))
return numpy.asarray(x), | numpy.asarray(y) | numpy.asarray |
import pytest
from numpy import allclose, arange, array, asarray, dot, cov, corrcoef, float64
from thunder.series.readers import fromlist, fromarray
from thunder.images.readers import fromlist as img_fromlist
pytestmark = pytest.mark.usefixtures("eng")
def test_map(eng):
data = fromlist([array([1, 2]), array([3, 4])], engine=eng)
assert allclose(data.map(lambda x: x + 1).toarray(), [[2, 3], [4, 5]])
assert data.map(lambda x: 1.0*x, dtype=float64).dtype == float64
assert data.map(lambda x: 1.0*x).dtype == float64
def test_map_singletons(eng):
data = fromlist([array([4, 5, 6, 7]), array([8, 9, 10, 11])], engine=eng)
mapped = data.map(lambda x: x.mean())
assert mapped.shape == (2, 1)
def test_filter(eng):
data = fromlist([array([1, 2]), array([3, 4])], engine=eng)
assert allclose(data.filter(lambda x: x.sum() > 3).toarray(), [3, 4])
def test_flatten(eng):
arr = arange(2*2*5).reshape(2, 2, 5)
data = fromarray(arr, engine=eng)
assert data.flatten().shape == (4, 5)
assert allclose(data.flatten().toarray(), arr.reshape(2*2, 5))
def test_sample(eng):
data = fromlist([array([1, 5]), array([1, 10]), array([1, 15])], engine=eng)
assert allclose(data.sample(3).shape, (3, 2))
assert allclose(data.filter(lambda x: x.max() > 10).sample(1).toarray(), [1, 15])
def test_between(eng):
data = fromlist([array([4, 5, 6, 7]), array([8, 9, 10, 11])], engine=eng)
val = data.between(0, 2)
assert allclose(val.index, array([0, 1]))
assert allclose(val.toarray(), array([[4, 5], [8, 9]]))
def test_first(eng):
data = fromlist([array([4, 5, 6, 7]), array([8, 9, 10, 11])], engine=eng)
assert allclose(data.first(), [4, 5, 6, 7])
def test_select(eng):
index = ['label1', 'label2', 'label3', 'label4']
data = fromlist([array([4, 5, 6, 7]), array([8, 9, 10, 11])], engine=eng, index=index)
assert data.select('label1').shape == (2, 1)
assert allclose(data.select('label1').toarray(), [4, 8])
assert allclose(data.select(['label1']).toarray(), [4, 8])
assert allclose(data.select(['label1', 'label2']).toarray(), array([[4, 5], [8, 9]]))
assert data.select('label1').index == ['label1']
assert data.select(['label1']).index == ['label1']
def test_standardize_axis1(eng):
data = fromlist([array([1, 2, 3, 4, 5])], engine=eng)
centered = data.center(1)
standardized = data.standardize(1)
zscored = data.zscore(1)
assert allclose(centered.toarray(), array([-2, -1, 0, 1, 2]), atol=1e-3)
assert allclose(standardized.toarray(),
array([0.70710, 1.41421, 2.12132, 2.82842, 3.53553]), atol=1e-3)
assert allclose(zscored.toarray(),
array([-1.41421, -0.70710, 0, 0.70710, 1.41421]), atol=1e-3)
def test_standardize_axis0(eng):
data = fromlist([array([1, 2]), array([3, 4])], engine=eng)
centered = data.center(0)
standardized = data.standardize(0)
zscored = data.zscore(0)
assert allclose(centered.toarray(), array([[-1, -1], [1, 1]]), atol=1e-3)
assert allclose(standardized.toarray(), array([[1, 2], [3, 4]]), atol=1e-3)
assert allclose(zscored.toarray(), array([[-1, -1], [1, 1]]), atol=1e-3)
def test_squelch(eng):
data = fromlist([array([1, 2]), array([3, 4])], engine=eng)
squelched = data.squelch(5)
assert allclose(squelched.toarray(), [[0, 0], [0, 0]])
squelched = data.squelch(3)
assert allclose(squelched.toarray(), [[0, 0], [3, 4]])
squelched = data.squelch(1)
assert allclose(squelched.toarray(), [[1, 2], [3, 4]])
def test_correlate(eng):
data = fromlist([array([1, 2, 3, 4, 5])], engine=eng)
sig = [4, 5, 6, 7, 8]
corr = data.correlate(sig).toarray()
assert allclose(corr, 1)
sigs = [[4, 5, 6, 7, 8], [8, 7, 6, 5, 4]]
corrs = data.correlate(sigs).toarray()
assert allclose(corrs, [1, -1])
def test_correlate_multiindex(eng):
index = [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
data = fromlist([array([1, 2, 3, 4, 5])], index=asarray(index).T, engine=eng)
sig = [4, 5, 6, 7, 8]
corr = data.correlate(sig).toarray()
assert allclose(corr, 1)
sigs = [[4, 5, 6, 7, 8], [8, 7, 6, 5, 4]]
corrs = data.correlate(sigs).toarray()
assert allclose(corrs, [1, -1])
def test_clip(eng):
data = fromlist([array([1, 2, 3, 4, 5])], engine=eng)
assert allclose(data.clip(2).toarray(), [2, 2, 3, 4, 5])
assert allclose(data.clip(2, 3).toarray(), [2, 2, 3, 3, 3])
def test_mean(eng):
data = fromlist([arange(8), arange(8)], engine=eng)
val = data.mean().toarray()
expected = data.toarray().mean(axis=0)
assert allclose(val, expected)
assert str(val.dtype) == 'float64'
def test_sum(eng):
data = fromlist([arange(8), arange(8)], engine=eng)
val = data.sum().toarray()
expected = data.toarray().sum(axis=0)
assert allclose(val, expected)
assert str(val.dtype) == 'int64'
def test_var(eng):
data = fromlist([arange(8), arange(8)], engine=eng)
val = data.var().toarray()
expected = data.toarray().var(axis=0)
assert allclose(val, expected)
assert str(val.dtype) == 'float64'
def test_std(eng):
data = fromlist([arange(8), arange(8)], engine=eng)
val = data.std().toarray()
expected = data.toarray().std(axis=0)
assert allclose(val, expected)
assert str(val.dtype) == 'float64'
def test_max(eng):
data = fromlist([arange(8), arange(8)], engine=eng)
val = data.max().toarray()
expected = data.toarray().max(axis=0)
assert allclose(val, expected)
def test_min(eng):
data = fromlist([arange(8), arange(8)], engine=eng)
val = data.min().toarray()
expected = data.toarray().min(axis=0)
assert allclose(val, expected)
def test_labels(eng):
x = [array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7])]
data = fromlist(x, labels=[0, 1, 2, 3], engine=eng)
assert allclose(data.filter(lambda x: x[0]>2).labels, array([2, 3]))
assert allclose(data[2:].labels, array([2, 3]))
assert allclose(data[1].labels, array([1]))
assert allclose(data[1, :].labels, array([1]))
assert allclose(data[[0, 2]].labels, array([0, 2]))
assert allclose(data.flatten().labels, array([0, 1, 2, 3]))
x = [ | array([[0, 1],[2, 3]]) | numpy.array |
"""
sampling.py
We sample Metropolis-Hastings:
* Random walk proposals
* Langevin proposals
* Langevin proposals with preconditioning
* Hamiltonian MC
* Hamiltonian MC with preconditioning
NOTE:
The functionality of this module is restricted to log-densities,
i.e. densities of the form p(s) = exp(-E(s)). We work with E(s) only.
The reason is that in Bayesian inference, evaluations of exp(-E(s))
are too instable in a numerical sense.
"""
import collections
from abc import ABC, abstractmethod
import numpy as np
from difflikelihoods import logdensity
def metropolishastings_rw(logpdf, nsamps, initstate, pwidth, ninits):
"""
Convenience function for Metropolis-Hastings sampling with
random walk proposal kernel.
"""
logdens = logdensity.LogDensity(logpdf)
rwmh = RandomWalkMH(logdens)
return rwmh.sample_nd(nsamps, initstate, pwidth, ninits)
def metropolishastings_lang(logpdf, loggrad, nsamps, initstate, pwidth, ninits):
"""
Convenience function for Metropolis-Hastings sampling with
Langevin dynamics proposal kernel.
"""
logdens = logdensity.LogDensity(logpdf, loggrad)
langmh = LangevinMH(logdens)
return langmh.sample_nd(nsamps, initstate, pwidth, ninits)
def metropolishastings_plang(
logpdf, loggrad, loghess, nsamps, initstate, pwidth, ninits
):
"""
Convenience function for Metropolis-Hastings sampling with
Riemannian (preconditioned) Langevin dynamics proposal kernel.
"""
logdens = logdensity.LogDensity(logpdf, loggrad, loghess)
plangmh = PrecondLangevinMH(logdens)
return plangmh.sample_nd(nsamps, initstate, pwidth, ninits)
def metropolishastings_ham(
logpdf, loggrad, nsamps, initstate, stepsize, nsteps, ninits
):
"""
Convenience function for Hamiltonian MCMC.
"""
logdens = logdensity.LogDensity(logpdf, loggrad)
hmc = HamiltonianMC(logdens, nsteps)
return hmc.sample_nd(nsamps, initstate, stepsize, ninits)
def metropolishastings_pham(
logpdf, loggrad, loghess, nsamps, initstate, stepsize, nsteps, ninits
):
"""
Convenience function for preconditioned Hamiltonian MCMC.
"""
logdens = logdensity.LogDensity(logpdf, loggrad, loghess)
phmc = PrecondHamiltonianMC(logdens, nsteps)
return phmc.sample_nd(nsamps, initstate, stepsize, ninits)
# Convenience data structure.
MCMCState = collections.namedtuple("MCMCState", "state logdens loggrad loghess")
class MetropolisHastings(ABC):
"""
Abstract Metropolis-Hastings class. Contains everything but the
proposal kernels.
"""
def __init__(self, logdens):
"""
Initialise MH sampler with a log-density function.
Args:
logdens: LogDensity object, evaluations of a negative log-
density and derivatives
"""
self.logdens = logdens
def sample_nd(self, nsamps, init_state, pwidth, ninits=None, *optional):
"""
"""
assert init_state_is_array(
init_state
), "Please enter a (d,) dimensional initial state"
states, logprobs = np.zeros((nsamps, len(init_state))), np.zeros(nsamps)
accepted = 0
if ninits is None:
ninits = 0
currstate = self.evaluate_logdens(init_state)
states[0], logprobs[0] = currstate.state, currstate.logdens
for idx in range(1, nsamps):
if idx < ninits:
proposal, corrfact = self.generate_proposal(currstate, pwidth)
else:
proposal, corrfact = self.generate_proposal(currstate, 0.2 * pwidth)
currstate, is_accept = self.accept_or_reject(
currstate, proposal, corrfact, idx, ninits
)
states[idx], logprobs[idx] = (
currstate.state.copy(),
currstate.logdens.copy(),
)
if idx >= ninits:
accepted = accepted + int(is_accept)
ratio = accepted / nsamps
return states, logprobs, ratio
def evaluate_logdens(self, loc):
"""
"""
logdenseval = self.logdens.eval(loc)
if self.logdens.has_gradient:
gradeval = self.logdens.gradeval(loc)
else:
gradeval = 0
if self.logdens.has_hessian:
hesseval = self.logdens.hesseval(loc)
else:
hesseval = 0
return MCMCState(
state=loc, logdens=logdenseval, loggrad=gradeval, loghess=hesseval
)
def accept_or_reject(self, currstate, proposal, corrfact, idx, ninits):
"""
"""
logaccprob = self.get_logaccprob(currstate, proposal, corrfact, idx, ninits)
if logaccprob < 0 or logaccprob < -np.log(np.random.rand()):
state = proposal
is_accept = True
else:
state = currstate
is_accept = False
return state, is_accept
def get_logaccprob(self, currstate, proposal, corrfact, idx, ninits):
"""
Returns NEGATIVE log acceptance probability, i.e.
corrected proposal - corrected currstate
"""
if idx < ninits:
corrfact = -corrfact
return (corrfact) + (proposal.logdens - currstate.logdens)
@abstractmethod
def generate_proposal(self, *args):
"""
"""
pass
def init_state_is_array(init_state):
"""
Checks whether init_state is compliant with an Nd algorithm.
That is, whether init_state is an (d,) np.ndarray.
"""
assert isinstance(init_state, np.ndarray), "Please enter init_state of shape (d,)"
assert len(init_state.shape) == 1, "Please enter init_state of shape (d,)"
return True
class RandomWalkMH(MetropolisHastings):
"""
"""
def __init__(self, logdens):
"""
"""
MetropolisHastings.__init__(self, logdens)
def generate_proposal(self, currstate, pwidth):
"""
"""
newloc = self.sample_randomwalk(currstate.state, pwidth)
proposal = self.evaluate_logdens(newloc)
corrfact = 0
return proposal, corrfact
def sample_randomwalk(self, mean, var):
"""
"""
return mean + np.sqrt(var) * np.random.randn(len(mean))
class LangevinMH(MetropolisHastings):
"""
"""
def __init__(self, logdens):
"""
"""
MetropolisHastings.__init__(self, logdens)
def generate_proposal(self, currstate, pwidth):
"""
"""
newloc = self.sample_langevin(currstate, pwidth)
proposal = self.evaluate_logdens(newloc)
corrfact = self.compute_corrfact_langevin(currstate, proposal, pwidth)
return proposal, corrfact
def sample_langevin(self, currstate, pwidth):
"""
"""
noise = np.random.randn(len(currstate.state))
return (
currstate.state - pwidth * currstate.loggrad + np.sqrt(2 * pwidth) * noise
)
def compute_corrfact_langevin(self, currstate, proposal, pwidth):
"""
"""
lognomin = self.kernel_langevin(currstate, proposal, pwidth)
logdenom = self.kernel_langevin(proposal, currstate, pwidth)
return lognomin - logdenom
def kernel_langevin(self, state1, state2, pwidth):
"""
"""
state2_dyn = state2.state - pwidth * state2.loggrad
dist = np.linalg.norm(state1.state - state2_dyn) ** 2
return 0.5 * dist / (2 * pwidth)
class PrecondLangevinMH(MetropolisHastings):
"""
Preconditioning with (inverse) Hessian.
"""
def __init__(self, logdens):
"""
precondeval returns M (and not M^{-1}) as used in Cald&Gir
"""
MetropolisHastings.__init__(self, logdens)
def generate_proposal(self, currstate, pwidth):
"""
"""
newloc = self.sample_langevin(currstate, pwidth)
proposal = self.evaluate_logdens(newloc)
corrfact = self.compute_corrfact_langevin(currstate, proposal, pwidth)
return proposal, corrfact
def sample_langevin(self, currstate, pwidth):
"""
"""
noise = np.random.multivariate_normal(
np.zeros(len(currstate.loghess)), np.linalg.inv(currstate.loghess)
)
prec_dyn = np.linalg.solve(currstate.loghess, currstate.loggrad)
return currstate.state - pwidth * prec_dyn + np.sqrt(2 * pwidth) * noise
def compute_corrfact_langevin(self, currstate, proposal, pwidth):
"""
"""
lognomin = self.kernel_langevin(currstate, proposal, pwidth)
logdenom = self.kernel_langevin(proposal, currstate, pwidth)
return lognomin - logdenom
def kernel_langevin(self, state1, state2, pwidth):
"""
"""
prec_dyn = np.linalg.solve(state2.loghess, state2.loggrad)
state2_dyn = state2.state - pwidth * prec_dyn
difference = state1.state - state2_dyn
return 0.5 * difference.dot(np.dot(state2.loghess, difference)) / (2 * pwidth)
class HamiltonianMC(MetropolisHastings):
"""
"""
def __init__(self, logdens, nsteps):
"""
"""
MetropolisHastings.__init__(self, logdens)
self.nsteps = nsteps
def generate_proposal(self, currstate, pwidth):
"""
pwidth is used as stepsize for self.nsteps leapfrog steps.
The correction factor is the quotient of the hamiltonian terms.
"""
momentum = np.random.multivariate_normal(
np.zeros(len(currstate.state)), np.eye(len(currstate.state))
)
# hamilt = self.evaluate_hamiltonian(momentum, currstate)
momentum_new, proposal = self.leapfrog_dynamics(momentum, currstate, pwidth)
# prop_hamilt = self.evaluate_hamiltonian(momentum_new, proposal)
corrfact = self.get_corrfact(momentum, momentum_new)
return proposal, corrfact
def leapfrog_dynamics(self, momentum, currstate, pwidth):
"""
"""
proposal = currstate
for idx in range(self.nsteps):
momentum, proposal = self.compute_next_lfstep(momentum, proposal, pwidth)
return momentum, proposal
def compute_next_lfstep(self, momentum, proposal, pwidth):
"""
"""
momentum = momentum - 0.5 * pwidth * proposal.loggrad
pstate = proposal.state + pwidth * momentum
proposal = self.evaluate_logdens(pstate)
momentum = momentum - 0.5 * pwidth * proposal.loggrad
return momentum, proposal
def get_corrfact(self, mom_new, mom):
"""
"""
return 0.5 * (mom_new.T @ mom_new - mom.T @ mom)
class PrecondHamiltonianMC(MetropolisHastings):
"""
In fact, the true name would be either
* Riemannian-Gaussian HMC: if the preconditioner depends on the state
* Euclidean-Gaussian HMC: if the preconditioner is constant
[Girolami and Calderhead, 2011; Betancourt, 2018]
"""
def __init__(self, logdens, nsteps):
"""
evalprecond returns M (and not M^{-1}) as used in Cald&Gir.
M is the Hessian
"""
MetropolisHastings.__init__(self, logdens)
self.nsteps = nsteps
def generate_proposal(self, currstate, pwidth):
"""
pwidth is used as stepsize for self.nsteps leapfrog steps.
The correction factor is the quotient of the hamiltonian terms.
"""
momentum = np.random.multivariate_normal(
np.zeros(len(currstate.state)), currstate.loghess
)
momentum_new, proposal = self.leapfrog_dynamics(momentum, currstate, pwidth)
corrfact = self.get_corrfact(momentum, momentum_new, currstate, proposal)
return proposal, corrfact
def leapfrog_dynamics(self, momentum, currstate, pwidth):
"""
"""
proposal = currstate
for idx in range(self.nsteps):
momentum, proposal = self.compute_next_lfstep(momentum, proposal, pwidth)
return momentum, proposal
def compute_next_lfstep(self, momentum, proposal, pwidth):
"""
"""
momentum = momentum - 0.5 * pwidth * proposal.loggrad
pstate = proposal.state + pwidth * np.linalg.solve(proposal.loghess, momentum)
proposal = self.evaluate_logdens(pstate)
momentum = momentum - 0.5 * pwidth * proposal.loggrad
return momentum, proposal
def get_corrfact(self, mom, mom_new, currstate, proposal):
"""
"""
return 0.5 * (
mom_new.T @ np.linalg.solve(proposal.loghess, mom_new)
+ np.log( | np.linalg.det(proposal.loghess) | numpy.linalg.det |
'''
This module generates thin-cell transmission spectra,
accounting for cavity effects, transient atom dynamics following
depolarisation in atom-wall collisions, and atom-surface van der Waals
:math:`\propto 1/R^3` interactions.
Example:
To generate simple thin cell spectra::
from tas import *
import matplotlib.pyplot as plt
import numpy as np
laserDetuning = np.linspace(-6500,-1500,60) # (MHz)
temperature = 228 # (degree Celsius)
collisionalBroadening = 840 # (MHz)
C3 = 2 # (kHz mum^3)
cellLength = 80e-9 # (m)
collisionalShift = 0 # (MHz)
calc = ThinCellSpectra(nSurface=1.76)
T = calc.getTransmission(laserDetuning,
temperature,
collisionalBroadening,
collisionalShift,
C3,
cellLength)
plt.figure()
plt.plot(laserDetuning, T,
'b', label='Theoretical prediction')
plt.xlabel('Detuning (GHz)')
plt.ylabel('Transmission' )
plt.legend(loc='lower right')
plt.show()
'''
import numpy as np
#from pylab import *
from scipy.constants import Boltzmann as C_kb,\
atomic_mass,\
epsilon_0,\
hbar
class ThinCellSpectra():
r"""
Generates spectra for optically thin atom slabs in nano-cells.
Includes atom-surface interactions, transient effects of atom dynamics
following depolarisation at the walls of the cell, and cavity effects
due to the cell walls.
Neglects change of driving light power due to interaction with the
atomic medium.
Args:
nSurface: (Optional) refractive index of the vapour cell surface
wavelength: (Optional) transition wavelength (m)
gamma0: (Optional) transition natural linewidth (MHz)
atomMass: (Optional) mass of the atoms (atomic units)
energyLevelsF: (Optional) array of offsets of energy levels,
relative to center of gravity of HFS line (MHz)
cg_coeff: (Optional) array of Clebsch–Gordan coefficients for the energy
levels listed in `energyLevelsF`.
Note:
To include different transitions and/or atomic species
change atom specific data with optional parameters of ThinCellSpectra
during initialisation of the class instance.
Optional parameters are all set by default to conditions in the
experiment (Cs D1, :math:`F=4 \rightarrow F=3,4` ).
"""
def __init__(self, nSurface=1.76,
wavelength=894.59295986e-9,
gamma0=4.5612,
atomMass=132.905451931,
energyLevelsF=[-3510.916, -4678.597],
cg_coeff=[0.026024508, 0.0364343]
):
# === surface specific data ===
self.nSurface = nSurface
# Reflection and transmission coefficients. See Fig. 1 in supplemental material
self.t1 = 2. * nSurface / (nSurface + 1)
self.t2 = 2. / (nSurface + 1)
self.r1 = (nSurface - 1) / (nSurface + 1)
self.r2 = (1 - nSurface) / (nSurface + 1)
# === atom specific data ===
self.kProbe = 2. * np.pi / wavelength # wavector in vacuum
self.gamma0 = gamma0
self.dipole = 3.0 * np.sqrt(epsilon_0 * hbar * (2.0 * gamma0 * (10.0**6))
* (wavelength**3) / (8.0 * np.pi))
self.mass = atomMass * atomic_mass
self.energyLevelsF = np.array(energyLevelsF)
self.cg_coeff = | np.array(cg_coeff) | numpy.array |
# pylint: disable=E1101
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import average_precision_score, confusion_matrix
import numpy as np
from physionet import PhysioNet, get_data_min_max, variable_time_collate_fn2
from sklearn import model_selection
from sklearn import metrics
from sklearn.metrics import precision_score, recall_score, f1_score
from person_activity import PersonActivity
def one_hot(y_):
# Function to encode output labels from number indexes
# e.g.: [[5], [0], [3]] --> [[0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]]
y_ = y_.reshape(len(y_))
y_ = [int(x) for x in y_]
n_values = np.max(y_) + 1
return np.eye(n_values)[np.array(y_, dtype=np.int32)]
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
def log_normal_pdf(x, mean, logvar, mask):
const = torch.from_numpy(np.array([2. * np.pi])).float().to(x.device)
const = torch.log(const)
return -.5 * (const + logvar + (x - mean) ** 2. / torch.exp(logvar)) * mask
def normal_kl(mu1, lv1, mu2, lv2):
v1 = torch.exp(lv1)
v2 = torch.exp(lv2)
lstd1 = lv1 / 2.
lstd2 = lv2 / 2.
kl = lstd2 - lstd1 + ((v1 + (mu1 - mu2) ** 2.) / (2. * v2)) - .5
return kl
def mean_squared_error(orig, pred, mask):
error = (orig - pred) ** 2
error = error * mask
return error.sum() / mask.sum()
def normalize_masked_data(data, mask, att_min, att_max):
# we don't want to divide by zero
att_max[att_max == 0.] = 1.
if (att_max != 0.).all():
data_norm = (data - att_min) / att_max
else:
raise Exception("Zero!")
if torch.isnan(data_norm).any():
raise Exception("nans!")
# set masked out elements back to zero
data_norm[mask == 0] = 0
return data_norm, att_min, att_max
def evaluate(dim, rec, dec, test_loader, args, num_sample=10, device="cuda"):
mse, test_n = 0.0, 0.0
with torch.no_grad():
for test_batch in test_loader:
test_batch = test_batch.to(device)
observed_data, observed_mask, observed_tp = (
test_batch[:, :, :dim],
test_batch[:, :, dim: 2 * dim],
test_batch[:, :, -1],
)
if args.sample_tp and args.sample_tp < 1:
subsampled_data, subsampled_tp, subsampled_mask = subsample_timepoints(
observed_data.clone(), observed_tp.clone(), observed_mask.clone(), args.sample_tp)
else:
subsampled_data, subsampled_tp, subsampled_mask = \
observed_data, observed_tp, observed_mask
out = rec(torch.cat((subsampled_data, subsampled_mask), 2), subsampled_tp)
qz0_mean, qz0_logvar = (
out[:, :, : args.latent_dim],
out[:, :, args.latent_dim:],
)
epsilon = torch.randn(
num_sample, qz0_mean.shape[0], qz0_mean.shape[1], qz0_mean.shape[2]
).to(device)
z0 = epsilon * torch.exp(0.5 * qz0_logvar) + qz0_mean
z0 = z0.view(-1, qz0_mean.shape[1], qz0_mean.shape[2])
batch, seqlen = observed_tp.size()
time_steps = (
observed_tp[None, :, :].repeat(num_sample, 1, 1).view(-1, seqlen)
)
pred_x = dec(z0, time_steps)
pred_x = pred_x.view(num_sample, -1, pred_x.shape[1], pred_x.shape[2])
pred_x = pred_x.mean(0)
mse += mean_squared_error(observed_data, pred_x, observed_mask) * batch
test_n += batch
return mse / test_n
def compute_losses(dim, dec_train_batch, qz0_mean, qz0_logvar, pred_x, args, device):
observed_data, observed_mask \
= dec_train_batch[:, :, :dim], dec_train_batch[:, :, dim:2*dim]
noise_std = args.std
noise_std_ = torch.zeros(pred_x.size()).to(device) + noise_std
noise_logvar = 2. * torch.log(noise_std_).to(device)
logpx = log_normal_pdf(observed_data, pred_x, noise_logvar,
observed_mask).sum(-1).sum(-1)
pz0_mean = pz0_logvar = torch.zeros(qz0_mean.size()).to(device)
analytic_kl = normal_kl(qz0_mean, qz0_logvar,
pz0_mean, pz0_logvar).sum(-1).sum(-1)
if args.norm:
logpx /= observed_mask.sum(-1).sum(-1)
analytic_kl /= observed_mask.sum(-1).sum(-1)
return logpx, analytic_kl
def evaluate_classifier(model, test_loader, dec=None, args=None, classifier=None,
dim=41, device='cuda', reconst=False, num_sample=1, dataset='P12'):
pred = []
true = []
test_loss = 0
for test_batch, label in test_loader:
test_batch, label = test_batch.to(device), label.to(device)
batch_len = test_batch.shape[0]
observed_data, observed_mask, observed_tp \
= test_batch[:, :, :dim], test_batch[:, :, dim:2*dim], test_batch[:, :, -1]
with torch.no_grad():
out = model(
torch.cat((observed_data, observed_mask), 2), observed_tp)
if reconst:
qz0_mean, qz0_logvar = out[:, :,
:args.latent_dim], out[:, :, args.latent_dim:]
epsilon = torch.randn(
num_sample, qz0_mean.shape[0], qz0_mean.shape[1], qz0_mean.shape[2]).to(device)
z0 = epsilon * torch.exp(.5 * qz0_logvar) + qz0_mean
z0 = z0.view(-1, qz0_mean.shape[1], qz0_mean.shape[2])
if args.classify_pertp:
pred_x = dec(z0, observed_tp[None, :, :].repeat(
num_sample, 1, 1).view(-1, observed_tp.shape[1]))
out = classifier(pred_x)
else:
out = classifier(z0)
if args.classify_pertp:
N = label.size(-1)
out = out.view(-1, N)
label = label.view(-1, N)
_, label = label.max(-1)
test_loss += nn.CrossEntropyLoss()(out, label.long()).item() * batch_len * 50.
else:
label = label.unsqueeze(0).repeat_interleave(
num_sample, 0).view(-1)
test_loss += nn.CrossEntropyLoss()(out, label).item() * batch_len * num_sample
pred.append(out.cpu().numpy())
true.append(label.cpu().numpy())
pred = np.concatenate(pred, 0)
true = np.concatenate(true, 0)
acc = np.mean(pred.argmax(1) == true)
if dataset == 'P12' or dataset == 'P19' or dataset == 'eICU':
auc = metrics.roc_auc_score(true, pred[:, 1]) if not args.classify_pertp else 0.
aupr = average_precision_score(true, pred[:, 1]) if not args.classify_pertp else 0.
return test_loss / pred.shape[0], acc, auc, aupr, None, None, None
elif dataset == 'PAM':
auc = metrics.roc_auc_score(one_hot(true), pred) if not args.classify_pertp else 0.
aupr = average_precision_score(one_hot(true), pred) if not args.classify_pertp else 0.
precision = precision_score(true, pred.argmax(1), average='macro', ) if not args.classify_pertp else 0.
recall = recall_score(true, pred.argmax(1), average='macro', ) if not args.classify_pertp else 0.
F1 = 2 * (precision * recall) / (precision + recall) if not args.classify_pertp else 0.
return test_loss/pred.shape[0], acc, auc, aupr, precision, recall, F1
def random_sample(idx_0, idx_1, batch_size):
"""
Returns a balanced sample by randomly sampling without replacement.
:param idx_0: indices of negative samples
:param idx_1: indices of positive samples
:param batch_size: batch size
:return: indices of balanced batch of negative and positive samples
"""
idx0_batch = np.random.choice(idx_0, size=int(batch_size / 2), replace=False)
idx1_batch = np.random.choice(idx_1, size=int(batch_size / 2), replace=False)
idx = np.concatenate([idx0_batch, idx1_batch], axis=0)
return idx
def preprocess_P19(PT_dict, arr_outcomes, labels_ts):
total = []
for i, patient in enumerate(PT_dict):
length = patient['length']
record_id = patient['id']
tt = torch.squeeze(torch.tensor(patient['time'][:length]), 1)
vals = torch.tensor(patient['arr'][:length, :], dtype=torch.float32)
m = np.zeros(shape=patient['arr'][:length, :].shape)
m[patient['arr'][:length, :].nonzero()] = 1
mask = torch.tensor(m, dtype=torch.float32)
outcome = torch.tensor(arr_outcomes[i][0], dtype=torch.float32)
total.append((record_id, tt, vals, mask, outcome))
'''
# calculate and save P19 statistics - age, gender, density scores (can be used for all algorithms)
idx_under_65 = []
idx_over_65 = []
idx_male = []
idx_female = []
for i in range(len(PT_dict)):
if total[i][0] == PT_dict[i]['id']:
age, gender, _, _, _, _ = PT_dict[i]['extended_static']
if age > 0:
if age < 65:
idx_under_65.append(i)
else:
idx_over_65.append(i)
if gender == 0:
idx_female.append(i)
if gender == 1:
idx_male.append(i)
np.save('P19_idx_under_65.npy', np.array(idx_under_65), allow_pickle=True)
np.save('P19_idx_over_65.npy', np.array(idx_over_65), allow_pickle=True)
np.save('P19_idx_male.npy', np.array(idx_male), allow_pickle=True)
np.save('P19_idx_female.npy', np.array(idx_female), allow_pickle=True)
# save density scores
X_features = np.array([d['arr'] for d in PT_dict])
counts = np.count_nonzero(X_features, axis=(0, 1))
ascending_indices = np.argsort(counts)
density_scores = counts / (X_features.shape[0] * 60)
res = [[ind, density_scores[ind], labels_ts[:-1][ind]] for ind in ascending_indices]
np.save('P19_density_scores.npy', res, allow_pickle=True)
'''
return total
def preprocess_eICU(PT_dict, arr_outcomes, labels_ts):
total = []
for i, patient in enumerate(PT_dict):
record_id = str(i)
tt = torch.squeeze(torch.tensor(patient['time']), 1)
vals = torch.tensor(patient['arr'], dtype=torch.float32)
m = np.zeros(shape=patient['arr'].shape)
m[patient['arr'].nonzero()] = 1
mask = torch.tensor(m, dtype=torch.float32)
outcome = torch.tensor(arr_outcomes[i], dtype=torch.float32)
total.append((record_id, tt, vals, mask, outcome))
'''
# calculate and save P19 statistics - gender, density scores (can be used for all algorithms)
idx_male = []
idx_female = []
for i in range(len(PT_dict)):
if total[i][0] == str(i):
vec = PT_dict[i]['extended_static']
if vec[-3] > 0:
idx_female.append(i)
if vec[-4] > 0:
idx_male.append(i)
print('\nOnly 1.329/36.443 samples have gender data available.\n')
np.save('eICU_idx_male.npy', np.array(idx_male), allow_pickle=True)
np.save('eICU_idx_female.npy', np.array(idx_female), allow_pickle=True)
# save density scores
X_features = np.array([d['arr'] for d in PT_dict])
counts = np.count_nonzero(X_features, axis=(0, 1))
ascending_indices = np.argsort(counts)
density_scores = counts / (X_features.shape[0] * 300)
res = [[ind, density_scores[ind], labels_ts[ind]] for ind in ascending_indices]
np.save('eICU_density_scores.npy', res, allow_pickle=True)
'''
return total
def preprocess_PAM(PT_dict, arr_outcomes):
length = 600
total = []
for i, patient in enumerate(PT_dict):
record_id = str(i)
tt = torch.tensor(list(range(length)))
vals = torch.tensor(patient, dtype=torch.float32)
m = np.zeros(shape=patient.shape)
m[patient.nonzero()] = 1
mask = torch.tensor(m, dtype=torch.float32)
outcome = torch.tensor(arr_outcomes[i][0], dtype=torch.float32)
total.append((record_id, tt, vals, mask, outcome))
return total
def random_sample_8(ytrain, B, replace=False):
""" Returns a balanced sample of tensors by randomly sampling without replacement. """
idx0_batch = np.random.choice(np.where(ytrain == 0)[0], size=int(B / 8), replace=replace)
idx1_batch = np.random.choice(np.where(ytrain == 1)[0], size=int(B / 8), replace=replace)
idx2_batch = np.random.choice(np.where(ytrain == 2)[0], size=int(B / 8), replace=replace)
idx3_batch = np.random.choice(np.where(ytrain == 3)[0], size=int(B / 8), replace=replace)
idx4_batch = np.random.choice(np.where(ytrain == 4)[0], size=int(B / 8), replace=replace)
idx5_batch = np.random.choice(np.where(ytrain == 5)[0], size=int(B / 8), replace=replace)
idx6_batch = np.random.choice(np.where(ytrain == 6)[0], size=int(B / 8), replace=replace)
idx7_batch = np.random.choice(np.where(ytrain == 7)[0], size=int(B / 8), replace=replace)
idx = np.concatenate([idx0_batch, idx1_batch, idx2_batch, idx3_batch, idx4_batch, idx5_batch, idx6_batch, idx7_batch], axis=0)
return idx
def get_data(args, dataset, device, q, upsampling_batch, split_type, feature_removal_level, missing_ratio, flag=1,
reverse=False, predictive_label='mortality'):
if dataset == 'P12':
train_dataset_obj_1 = PhysioNet('data/physionet', train=True,
quantization=q,
download=True, n_samples=12000,
device=device, set_letter='a')
train_dataset_obj_2 = PhysioNet('data/physionet', train=True,
quantization=q,
download=True, n_samples=12000,
device=device, set_letter='b')
train_dataset_obj_3 = PhysioNet('data/physionet', train=True,
quantization=q,
download=True, n_samples=12000,
device=device, set_letter='c')
dataset_1 = train_dataset_obj_1[:len(train_dataset_obj_1)]
dataset_2 = train_dataset_obj_2[:len(train_dataset_obj_2)]
dataset_3 = train_dataset_obj_3[:len(train_dataset_obj_3)]
total_dataset = dataset_1 + dataset_2 + dataset_3
if predictive_label == 'LoS':
los_outcomes = np.load('../saved/LoS_y1_out.npy', allow_pickle=True)
for i, tpl in enumerate(total_dataset):
a, b, c, d, _ = tpl
los_label = los_outcomes[i][0]
los_label = torch.tensor(los_label, dtype=torch.float32)
total_dataset[i] = (a, b, c, d, los_label)
'''
# calculate and save statistics
idx_under_65 = []
idx_over_65 = []
idx_male = []
idx_female = []
P_list = np.load('P_list.npy', allow_pickle=True)
for i in range(len(P_list)):
if total_dataset[i][0] == P_list[i]['id']:
age, gender, _, _, _ = P_list[i]['static']
if age > 0:
if age < 65:
idx_under_65.append(i)
else:
idx_over_65.append(i)
if gender == 0:
idx_female.append(i)
if gender == 1:
idx_male.append(i)
np.save('mtand_idx_under_65.npy', np.array(idx_under_65), allow_pickle=True)
np.save('mtand_idx_over_65.npy', np.array(idx_over_65), allow_pickle=True)
np.save('mtand_idx_male.npy', np.array(idx_male), allow_pickle=True)
np.save('mtand_idx_female.npy', np.array(idx_female), allow_pickle=True)
'''
elif dataset == 'P19':
PT_dict = np.load('../../../P19data/processed_data/PT_dict_list_6.npy', allow_pickle=True)
labels_ts = np.load('../../../P19data/processed_data/labels_ts.npy', allow_pickle=True)
labels_demogr = np.load('../../../P19data/processed_data/labels_demogr.npy', allow_pickle=True)
arr_outcomes = np.load('../../../P19data/processed_data/arr_outcomes_6.npy', allow_pickle=True)
total_dataset = preprocess_P19(PT_dict, arr_outcomes, labels_ts)
elif dataset == 'eICU':
PT_dict = np.load('../../../eICUdata/processed_data/PTdict_list.npy', allow_pickle=True)
labels_ts = np.load('../../../eICUdata/processed_data/eICU_ts_vars.npy', allow_pickle=True)
labels_demogr = np.load('../../../eICUdata/processed_data/eICU_static_vars.npy', allow_pickle=True)
arr_outcomes = np.load('../../../eICUdata/processed_data/arr_outcomes.npy', allow_pickle=True)
total_dataset = preprocess_eICU(PT_dict, arr_outcomes, labels_ts)
elif dataset == 'PAM':
PT_dict = np.load('../../../PAMdata/processed_data/PTdict_list.npy', allow_pickle=True)
arr_outcomes = np.load('../../../PAMdata/processed_data/arr_outcomes.npy', allow_pickle=True)
total_dataset = preprocess_PAM(PT_dict, arr_outcomes)
print('len(total_dataset):', len(total_dataset))
if split_type == 'random':
# Shuffle and split
train_data, test_data = model_selection.train_test_split(total_dataset, train_size=0.9, # 80% train, 10% validation, 10% test
shuffle=True)
elif split_type == 'age' or split_type == 'gender':
if dataset == 'P12':
prefix = 'mtand'
elif dataset == 'P19':
prefix = 'P19'
elif dataset == 'eICU': # possible only with split_type == 'gender'
prefix = 'eICU'
if split_type == 'age':
if dataset == 'eICU':
print('\nCombination of eICU dataset and age split is not possible.\n')
if reverse == False:
idx_train = np.load('%s_idx_under_65.npy' % prefix, allow_pickle=True)
idx_vt = np.load('%s_idx_over_65.npy' % prefix, allow_pickle=True)
else:
idx_train = np.load('%s_idx_over_65.npy' % prefix, allow_pickle=True)
idx_vt = np.load('%s_idx_under_65.npy' % prefix, allow_pickle=True)
elif split_type == 'gender':
if reverse == False:
idx_train = np.load('%s_idx_male.npy' % prefix, allow_pickle=True)
idx_vt = np.load('%s_idx_female.npy' % prefix, allow_pickle=True)
else:
idx_train = np.load('%s_idx_female.npy' % prefix, allow_pickle=True)
idx_vt = np.load('%s_idx_male.npy' % prefix, allow_pickle=True)
np.random.shuffle(idx_train)
np.random.shuffle(idx_vt)
train_data = [total_dataset[i] for i in idx_train]
test_data = [total_dataset[i] for i in idx_vt]
record_id, tt, vals, mask, labels = train_data[0]
input_dim = vals.size(-1)
data_min, data_max = get_data_min_max(total_dataset, device)
batch_size = 128
if flag:
if args.classif:
if split_type == 'random':
train_data, val_data = model_selection.train_test_split(train_data, train_size=0.8889, shuffle=True) # 80% train, 10% validation, 10% test
elif split_type == 'age' or split_type == 'gender':
val_data, test_data = model_selection.train_test_split(test_data, train_size=0.5, shuffle=False)
if dataset == 'P12':
num_all_features = 36
elif dataset == 'P19':
num_all_features = 34
elif dataset == 'eICU':
num_all_features = 14
elif dataset == 'PAM':
num_all_features = 17
num_missing_features = round(missing_ratio * num_all_features)
if feature_removal_level == 'sample':
for i, tpl in enumerate(val_data):
idx = np.random.choice(num_all_features, num_missing_features, replace=False)
_, _, values, _, _ = tpl
tpl = list(tpl)
values[:, idx] = torch.zeros(values.shape[0], num_missing_features)
tpl[2] = values
val_data[i] = tuple(tpl)
for i, tpl in enumerate(test_data):
idx = np.random.choice(num_all_features, num_missing_features, replace=False)
_, _, values, _, _ = tpl
tpl = list(tpl)
values[:, idx] = torch.zeros(values.shape[0], num_missing_features)
tpl[2] = values
test_data[i] = tuple(tpl)
elif feature_removal_level == 'set':
if dataset == 'P12':
dict_params = train_dataset_obj_1.params_dict
density_scores_names = np.load('../saved/IG_density_scores_P12.npy', allow_pickle=True)[:, 1]
idx = [dict_params[name] for name in density_scores_names[:num_missing_features]]
elif dataset == 'P19':
labels_ts = np.load('../../../P19data/processed_data/labels_ts.npy', allow_pickle=True)
dict_params = {label: i for i, label in enumerate(labels_ts[:-1])}
density_scores_names = np.load('../saved/IG_density_scores_P19.npy', allow_pickle=True)[:, 1]
idx = [dict_params[name] for name in density_scores_names[:num_missing_features]]
elif dataset == 'eICU':
labels_ts = np.load('../../../eICUdata/processed_data/eICU_ts_vars.npy', allow_pickle=True)
dict_params = {label: i for i, label in enumerate(labels_ts)}
density_scores_names = np.load('../saved/IG_density_scores_eICU.npy', allow_pickle=True)[:, 1]
idx = [dict_params[name] for name in density_scores_names[:num_missing_features]]
elif dataset == 'PAM':
density_scores_indices = np.load('../saved/IG_density_scores_PAM.npy', allow_pickle=True)[:, 0]
idx = list(map(int, density_scores_indices[:num_missing_features]))
for i, tpl in enumerate(val_data):
_, _, values, _, _ = tpl
tpl = list(tpl)
values[:, idx] = torch.zeros(values.shape[0], num_missing_features)
tpl[2] = values
val_data[i] = tuple(tpl)
for i, tpl in enumerate(test_data):
_, _, values, _, _ = tpl
tpl = list(tpl)
values[:, idx] = torch.zeros(values.shape[0], num_missing_features)
tpl[2] = values
test_data[i] = tuple(tpl)
if upsampling_batch:
train_data_upsamled = []
true_labels = np.array(list(map(lambda x: float(x[7]), np.array(train_data)[:, 4])))
if dataset == 'P12' or dataset == 'P19' or dataset == 'eICU': # 2 classes
idx_0 = np.where(true_labels == 0)[0]
idx_1 = np.where(true_labels == 1)[0]
for _ in range(len(true_labels) // batch_size):
indices = random_sample(idx_0, idx_1, batch_size)
for i in indices:
train_data_upsamled.append(train_data[i])
elif dataset == 'PAM': # 8 classes
for b in range(len(true_labels) // batch_size):
indices = random_sample_8(true_labels, batch_size)
for i in indices:
train_data_upsamled.append(train_data[i])
train_data = train_data_upsamled
test_data_combined = variable_time_collate_fn(test_data, device, classify=args.classif, data_min=data_min, data_max=data_max)
train_data_combined = variable_time_collate_fn(train_data, device, classify=args.classif, data_min=data_min, data_max=data_max)
val_data_combined = variable_time_collate_fn(
val_data, device, classify=args.classif, data_min=data_min, data_max=data_max)
print(train_data_combined[1].sum(
), val_data_combined[1].sum(), test_data_combined[1].sum())
print(train_data_combined[0].size(), train_data_combined[1].size(),
val_data_combined[0].size(), val_data_combined[1].size(),
test_data_combined[0].size(), test_data_combined[1].size())
train_data_combined = TensorDataset(
train_data_combined[0], train_data_combined[1].long().squeeze())
val_data_combined = TensorDataset(
val_data_combined[0], val_data_combined[1].long().squeeze())
test_data_combined = TensorDataset(
test_data_combined[0], test_data_combined[1].long().squeeze())
else:
train_data_combined = variable_time_collate_fn(
train_data, device, classify=args.classif, data_min=data_min, data_max=data_max)
train_dataloader = DataLoader(
train_data_combined, batch_size=batch_size, shuffle=False)
test_dataloader = DataLoader(
test_data_combined, batch_size=batch_size, shuffle=False)
else:
train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=False,
collate_fn=lambda batch: variable_time_collate_fn2(batch, args, device, data_type="train",
data_min=data_min, data_max=data_max))
test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False,
collate_fn=lambda batch: variable_time_collate_fn2(batch, args, device, data_type="test",
data_min=data_min, data_max=data_max))
data_objects = {"dataset_obj": {},
"train_dataloader": train_dataloader,
"test_dataloader": test_dataloader,
"input_dim": input_dim,
"n_train_batches": len(train_dataloader),
"n_test_batches": len(test_dataloader),
"attr": {}, # optional
"classif_per_tp": False, # optional
"n_labels": 1} # optional
if args.classif:
val_dataloader = DataLoader(
val_data_combined, batch_size=batch_size, shuffle=False)
data_objects["val_dataloader"] = val_dataloader
return data_objects
def variable_time_collate_fn(batch, device=torch.device("cpu"), classify=False, activity=False,
data_min=None, data_max=None):
"""
Expects a batch of time series data in the form of (record_id, tt, vals, mask, labels) where
- record_id is a patient id
- tt is a 1-dimensional tensor containing T time values of observations.
- vals is a (T, D) tensor containing observed values for D variables.
- mask is a (T, D) tensor containing 1 where values were observed and 0 otherwise.
- labels is a list of labels for the current patient, if labels are available. Otherwise None.
Returns:
combined_tt: The union of all time observations.
combined_vals: (M, T, D) tensor containing the observed values.
combined_mask: (M, T, D) tensor containing 1 where values were observed and 0 otherwise.
"""
D = batch[0][2].shape[1]
# number of labels
N = batch[0][-1].shape[1] if activity else 1
len_tt = [ex[1].size(0) for ex in batch]
maxlen = np.max(len_tt)
enc_combined_tt = torch.zeros([len(batch), maxlen]).to(device)
enc_combined_vals = torch.zeros([len(batch), maxlen, D]).to(device)
enc_combined_mask = torch.zeros([len(batch), maxlen, D]).to(device)
if classify:
if activity:
combined_labels = torch.zeros([len(batch), maxlen, N]).to(device)
else:
combined_labels = torch.zeros([len(batch), N]).to(device)
for b, (record_id, tt, vals, mask, labels) in enumerate(batch):
currlen = tt.size(0)
enc_combined_tt[b, :currlen] = tt.to(device)
enc_combined_vals[b, :currlen] = vals.to(device)
enc_combined_mask[b, :currlen] = mask.to(device)
if classify:
if activity:
combined_labels[b, :currlen] = labels.to(device)
else:
if labels is not None:
combined_labels[b] = labels.to(device)
if not activity:
enc_combined_vals, _, _ = normalize_masked_data(enc_combined_vals, enc_combined_mask,
att_min=data_min, att_max=data_max)
if torch.max(enc_combined_tt) != 0.:
enc_combined_tt = enc_combined_tt / torch.max(enc_combined_tt)
combined_data = torch.cat(
(enc_combined_vals, enc_combined_mask, enc_combined_tt.unsqueeze(-1)), 2)
if classify:
return combined_data, combined_labels
else:
return combined_data
def get_activity_data(args, device):
n_samples = min(10000, args.n)
dataset_obj = PersonActivity('data/PersonActivity',
download=True, n_samples=n_samples, device=device)
print(dataset_obj)
train_data, test_data = model_selection.train_test_split(dataset_obj, train_size=0.8,
random_state=42, shuffle=True)
record_id, tt, vals, mask, labels = train_data[0]
input_dim = vals.size(-1)
batch_size = min(min(len(dataset_obj), args.batch_size), args.n)
test_data_combined = variable_time_collate_fn(test_data, device, classify=args.classif,
activity=True)
train_data, val_data = model_selection.train_test_split(train_data, train_size=0.8,
random_state=11, shuffle=True)
train_data_combined = variable_time_collate_fn(
train_data, device, classify=args.classif, activity=True)
val_data_combined = variable_time_collate_fn(
val_data, device, classify=args.classif, activity=True)
print(train_data_combined[1].sum(
), val_data_combined[1].sum(), test_data_combined[1].sum())
print(train_data_combined[0].size(), train_data_combined[1].size(),
val_data_combined[0].size(), val_data_combined[1].size(),
test_data_combined[0].size(), test_data_combined[1].size())
train_data_combined = TensorDataset(
train_data_combined[0], train_data_combined[1].long())
val_data_combined = TensorDataset(
val_data_combined[0], val_data_combined[1].long())
test_data_combined = TensorDataset(
test_data_combined[0], test_data_combined[1].long())
train_dataloader = DataLoader(
train_data_combined, batch_size=batch_size, shuffle=False)
test_dataloader = DataLoader(
test_data_combined, batch_size=batch_size, shuffle=False)
val_dataloader = DataLoader(
val_data_combined, batch_size=batch_size, shuffle=False)
data_objects = {"train_dataloader": train_dataloader,
"test_dataloader": test_dataloader,
"val_dataloader": val_dataloader,
"input_dim": input_dim,
"n_train_batches": len(train_dataloader),
"n_test_batches": len(test_dataloader),
"classif_per_tp": False, # optional
"n_labels": 1} # optional
return data_objects
def irregularly_sampled_data_gen(n=10, length=20, seed=0):
np.random.seed(seed)
obs_values, ground_truth, obs_times = [], [], []
for i in range(n):
t1 = np.sort(np.random.uniform(low=0.0, high=1.0, size=length))
t2 = np.sort(np.random.uniform(low=0.0, high=1.0, size=length))
t3 = np.sort(np.random.uniform(low=0.0, high=1.0, size=length))
a = 10 * np.random.randn()
b = 10 * np.random.rand()
f1 = .8 * np.sin(20*(t1+a) + np.sin(20*(t1+a))) + \
0.01 * np.random.randn()
f2 = -.5 * np.sin(20*(t2+a + 20) + np.sin(20*(t2+a + 20))
) + 0.01 * np.random.randn()
f3 = np.sin(12*(t3+b)) + 0.01 * np.random.randn()
obs_times.append(np.stack((t1, t2, t3), axis=0))
obs_values.append(np.stack((f1, f2, f3), axis=0))
t = np.linspace(0, 1, 100)
fg1 = .8 * np.sin(20*(t+a) + np.sin(20*(t+a)))
fg2 = -.5 * np.sin(20*(t+a + 20) + np.sin(20*(t+a + 20)))
fg3 = np.sin(12*(t+b))
ground_truth.append(np.stack((fg1, fg2, fg3), axis=0))
return obs_values, ground_truth, obs_times
def sine_wave_data_gen(args, seed=0):
np.random.seed(seed)
obs_values, ground_truth, obs_times = [], [], []
for _ in range(args.n):
t = np.sort(np.random.choice(np.linspace(
0, 1., 101), size=args.length, replace=True))
b = 10 * np.random.rand()
f = np.sin(12*(t+b)) + 0.1 * np.random.randn()
obs_times.append(t)
obs_values.append(f)
tc = np.linspace(0, 1, 100)
fg = np.sin(12*(tc + b))
ground_truth.append(fg)
obs_values = np.array(obs_values)
obs_times = np.array(obs_times)
ground_truth = np.array(ground_truth)
print(obs_values.shape, obs_times.shape, ground_truth.shape)
mask = np.ones_like(obs_values)
combined_data = np.concatenate((np.expand_dims(obs_values, axis=2), np.expand_dims(
mask, axis=2), np.expand_dims(obs_times, axis=2)), axis=2)
print(combined_data.shape)
print(combined_data[0])
train_data, test_data = model_selection.train_test_split(combined_data, train_size=0.8,
random_state=42, shuffle=True)
print(train_data.shape, test_data.shape)
train_dataloader = DataLoader(torch.from_numpy(
train_data).float(), batch_size=args.batch_size, shuffle=False)
test_dataloader = DataLoader(torch.from_numpy(
test_data).float(), batch_size=args.batch_size, shuffle=False)
data_objects = {"dataset_obj": combined_data,
"train_dataloader": train_dataloader,
"test_dataloader": test_dataloader,
"input_dim": 1,
"ground_truth": np.array(ground_truth)}
return data_objects
def kernel_smoother_data_gen(args, alpha=100., seed=0, ref_points=10):
np.random.seed(seed)
obs_values, ground_truth, obs_times = [], [], []
for _ in range(args.n):
key_values = np.random.randn(ref_points)
key_points = np.linspace(0, 1, ref_points)
query_points = np.sort(np.random.choice(
np.linspace(0, 1., 101), size=args.length, replace=True))
weights = np.exp(-alpha*(np.expand_dims(query_points,
1) - np.expand_dims(key_points, 0))**2)
weights /= weights.sum(1, keepdims=True)
query_values = np.dot(weights, key_values)
obs_values.append(query_values)
obs_times.append(query_points)
query_points = np.linspace(0, 1, 100)
weights = np.exp(-alpha*(np.expand_dims(query_points,
1) - np.expand_dims(key_points, 0))**2)
weights /= weights.sum(1, keepdims=True)
query_values = np.dot(weights, key_values)
ground_truth.append(query_values)
obs_values = np.array(obs_values)
obs_times = | np.array(obs_times) | numpy.array |
import numpy as np
import scipy.signal
import matplotlib.pyplot as plt
import matplotlib
plt.switch_backend('agg')
import sys
import pandas as pd
import os
import pickle
from multiprocessing import Pool
from itertools import repeat
import utils.EventDetection_utils as EventDetection_utils
import utils.general_utils as general_utils
import utils.plot_utils as plot_utils
import utils.list_twoP_exp as list_twoP_exp
import utils.list_behavior as list_behavior
import utils.math_utils as math_utils
experiments=list_twoP_exp.SS29579_SS51046_DFFevt_based_anlysis
# experiments=[
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '001', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '002', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '003', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '004', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '005', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '006', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '007', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '008', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# ('20190221', 'SS29579-tdTomGC6fopt', 'fly1', '009', {'kinx_factor':0.4, 'raw_thrsld':0.4, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}), # no video
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '001', {'kinx_factor':0.4, 'raw_thrsld':1, 'grad_raw_thrsld':0.5, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '002', {'kinx_factor':0.4, 'raw_thrsld':0.7, 'grad_raw_thrsld':0.5, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '003', {'kinx_factor':0.2, 'raw_thrsld':1.5, 'grad_raw_thrsld':0.3, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '004', {'kinx_factor':0.2, 'raw_thrsld':1.4, 'grad_raw_thrsld':0.3, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '005', {'kinx_factor':0.4, 'raw_thrsld':0.7, 'grad_raw_thrsld':0.5, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '006', {'kinx_factor':0.4, 'raw_thrsld':0.7, 'grad_raw_thrsld':0.5, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '007', {'kinx_factor':0.2, 'raw_thrsld':0.55, 'grad_raw_thrsld':0.2, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '008', {'kinx_factor':0.4, 'raw_thrsld':0.7, 'grad_raw_thrsld':0.5, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# # ('20191002', 'SS51046-tdTomGC6fopt', 'fly1', '009', {'kinx_factor':0.4, 'raw_thrsld':0.7, 'grad_raw_thrsld':0.5, 'diff_window':0.3, 'evt_shortest_dur':0.5, 'evt_longest_dur':2}),
# ]
##Assgining dFF difference for detecting dominant dFF events
dmnt_difference_thrsld=0.2
def make_structure_as_modelStructure(ori_list, exempl_list):
if len(ori_list)!=len(exempl_list):
anticipate_list=[]
for i,v in enumerate(exempl_list):
anticipate_list.append([])
return anticipate_list
else:
return ori_list
def add_NaNtail_to_each_Evt(Evt_list):
Evt_len_list=[]
for evt in Evt_list:
Evt_len_list.append(len(evt))
max_EvtLen=max(Evt_len_list)
# print('max_EvtLen', max_EvtLen)
EvtNaNtail_list=[]
for evt in Evt_list:
evt_NaNtail=general_utils.add_NaN_tail(evt, max_EvtLen)
#print('len evt_NaNtail', len(evt_NaNtail))
EvtNaNtail_list.append(evt_NaNtail)
return EvtNaNtail_list
def worker_for_CI_mean_trace(idx, dataset, confidence, least_realNum_amount):
dataset=np.asarray(dataset)
# print('idx', idx)
# print('shape dataset', np.shape(dataset))
# print('least_realNum_amount', least_realNum_amount)
# print('len dataset', len(dataset))
data=dataset[:, idx]
non_nan_counts=data.size - np.count_nonzero(np.isnan(data))
if non_nan_counts > least_realNum_amount:
nonnan_data_list=data[np.logical_not(np.isnan(data))]
(mean, down_CI, up_CI) = math_utils.compute_CI_and_mean(nonnan_data_list, confidence=confidence)
return mean, down_CI, up_CI
else:
return np.nan, np.nan, np.nan
def compute_CI_and_mean_trace(dataset, confidence=0.95, least_realNum_amount=4):
print('Computing event mean amd CI ...')
# args_for_pool=[]
# for j in range(0,np.shape(dataset)[1]):
# args_for_pool.append([j, dataset, confidence, least_realNum_amount])
idx_range=[i for i in range(0,np.shape(dataset)[1])]
# print('colums_range', colums_range)
p=Pool()
mean_downCI_upCI = p.starmap(worker_for_CI_mean_trace, zip(idx_range, repeat(dataset), repeat(confidence), repeat(least_realNum_amount)))
#mean_trace, down_err_trace, up_err_trace = p.starmap(worker_for_CI_mean_trace, args_for_pool)
p.close()
p.join()
del p
mean_trace=np.asarray(mean_downCI_upCI)[:,0]
down_err_trace= | np.asarray(mean_downCI_upCI) | numpy.asarray |
import argparse, os, sys
import torch
import mmcv
import numpy as np
import torch.nn.functional as F
from mmcv.parallel import collate, scatter
from mmaction.datasets.pipelines import Compose
from mmaction.apis import init_recognizer
from mmaction.datasets import build_dataloader, build_dataset
from mmcv.parallel import MMDataParallel
from tqdm import tqdm
import scipy.spatial.distance as spd
try:
import libmr
except ImportError:
print("LibMR not installed or libmr.so not found")
print("Install libmr: cd libMR/; ./compile.sh")
sys.exit()
from sklearn.metrics import f1_score, roc_auc_score, accuracy_score
import matplotlib.pyplot as plt
def set_deterministic(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # if you are using multi-GPU.
np.random.seed(seed) # Numpy module.
torch.backends.cudnn.benchmark = True
torch.backends.cudnn.deterministic = True
def parse_args():
""" Example shell script:
$ cd experiments
$ source activate mmaction
$ nohup python baseline_openmax.py --model i3d --config configs/recognition/tpn/inference_tpn_slowonly_dnn.py
"""
parser = argparse.ArgumentParser(description='MMAction2 test')
# model config
parser.add_argument('--config', help='test config file path')
parser.add_argument('--checkpoint', help='checkpoint file/url')
parser.add_argument('--trainset_split', default='data/ucf101/ucf101_train_split_1_videos.txt', help='the split file path of the training set')
parser.add_argument('--num_cls', type=int, default=101, help='The number of classes in training set.')
parser.add_argument('--cache_mav_dist', help='the result path to cache the mav and distances for each class.')
# test data config
parser.add_argument('--ind_data', help='the split file of in-distribution testing data')
parser.add_argument('--ood_data', help='the split file of out-of-distribution testing data')
parser.add_argument('--ood_ncls', type=int, help='the number of classes in unknwon dataset')
parser.add_argument('--num_rand', type=int, default=10, help='the number of random selection for ood classes')
# device
parser.add_argument('--device', type=str, default='cuda:0', help='CPU/CUDA device option')
parser.add_argument('--result_prefix', help='result file prefix')
args = parser.parse_args()
return args
def get_datalist(split_file):
assert os.path.exists(split_file), 'split file does not exist! %s'%(split_file)
video_dir = os.path.join(os.path.dirname(split_file), 'videos')
filelist, labels = [], []
with open(split_file, 'r') as f:
for line in f.readlines():
videofile = os.path.join(video_dir, line.strip().split(' ')[0])
clsid = int(line.strip().split(' ')[-1])
filelist.append(videofile)
labels.append(clsid)
return filelist, labels
def spatial_temporal_pooling(feat_blob):
if isinstance(feat_blob, tuple): # slowfast model returns a tuple of features
assert len(feat_blob) == 2, "invalid feature tuple!"
avg_pool3d = torch.nn.AdaptiveAvgPool3d((1, 1, 1))
x_fast, x_slow = feat_blob
x_fast = avg_pool3d(x_fast)
x_slow = avg_pool3d(x_slow)
# [N, channel_fast + channel_slow, 1, 1, 1]
feat_clips = torch.cat((x_slow, x_fast), dim=1).squeeze(-1).squeeze(-1).squeeze(-1)
else:
if len(feat_blob.size()) == 5: # 3D Network
# spatial temporal average pooling
kernel_size = (feat_blob.size(-3), feat_blob.size(-2), feat_blob.size(-1))
avg_pool3d = torch.nn.AvgPool3d(kernel_size, stride=1, padding=0)
feat_clips = avg_pool3d(feat_blob).view(feat_blob.size(0), feat_blob.size(1)) # (c, D)
elif len(feat_blob.size()) == 4: # 2D Network
# spatial temporal average pooling
kernel_size = (feat_blob.size(-2), feat_blob.size(-1))
avg_pool2d = torch.nn.AvgPool2d(kernel_size, stride=1, padding=0)
feat_clips = avg_pool2d(feat_blob).view(feat_blob.size(0), feat_blob.size(1)) # (c, D)
else:
print('Unsupported feature dimension: {}'.format(feat_blob.size()))
# get the mean features of all clips and crops
feat_final = torch.mean(feat_clips, dim=0, keepdim=True) # (c=1, D)
return feat_final
def inference_recognizer(model, video_path):
"""Inference a video with the detector.
Args:
model (nn.Module): The loaded recognizer.
video_path (str): The video file path/url or the rawframes directory
path. If ``use_frames`` is set to True, it should be rawframes
directory path. Otherwise, it should be video file path.
"""
cfg = model.cfg
device = next(model.parameters()).device # model device
# build the data pipeline
test_pipeline = cfg.data.test.pipeline
test_pipeline = Compose(test_pipeline)
# prepare data (by default, we use videodata)
start_index = cfg.data.test.get('start_index', 0)
data = dict(filename=video_path, label=-1, start_index=start_index, modality='RGB')
data = test_pipeline(data)
data = collate([data], samples_per_gpu=1)
if next(model.parameters()).is_cuda:
# scatter to specified GPU
data = scatter(data, [device])[0]
# forward the model
with torch.no_grad():
feat_blob, score = model(return_loss=False, return_score=True, get_feat=True, **data) # (c, D, t, h, w)
feat_blob = spatial_temporal_pooling(feat_blob)
feat_final = feat_blob.cpu().numpy()
score = score.cpu().numpy()
return feat_final, score
def extract_class_features(videolist, model, cls_gt):
features = []
for videofile in tqdm(videolist, total=len(videolist), desc='Extract Class %d Features'%(cls_gt)):
feat, score = inference_recognizer(model, videofile) # (c, D)
cls_pred = np.argmax(score, axis=1)
if cls_gt in cls_pred:
features.append(feat)
features = np.array(features) # (N, c, D)
return features
def compute_distance(mav, features):
# extract features and compute distances for each class
num_channels = mav.shape[0]
eucos_dist, eu_dist, cos_dist = [], [], []
for feat in features:
# compute distance of each channel
eu_channel, cos_channel, eu_cos_channel = [], [], []
for c in range(num_channels):
eu_channel += [spd.euclidean(mav[c, :], feat[c, :])/200.]
cos_channel += [spd.cosine(mav[c, :], feat[c, :])]
eu_cos_channel += [spd.euclidean(mav[c, :], feat[c, :]) / 200.
+ spd.cosine(mav[c, :], feat[c, :])] # Here, 200 is from the official OpenMax code
eu_dist += [eu_channel]
cos_dist += [cos_channel]
eucos_dist += [eu_cos_channel]
return np.array(eucos_dist), np.array(eu_dist), np.array(cos_dist)
def compute_channel_distance(mav_channel, feat_channel, distance_type='eucos'):
if distance_type == 'eucos':
query_distance = spd.euclidean(mav_channel, feat_channel)/200. + spd.cosine(mav_channel, feat_channel)
elif distance_type == 'eu':
query_distance = spd.euclidean(mav_channel, feat_channel)/200.
elif distance_type == 'cos':
query_distance = spd.cosine(mav_channel, feat_channel)
else:
print("distance type not known: enter either of eucos, euclidean or cosine")
return query_distance
def compute_mav_dist(videolist, labels, model, mav_dist_cachedir):
num_cls = model.cls_head.num_classes
mav_dist_list = []
for cls_gt in range(num_cls):
mav_dist_file = os.path.join(mav_dist_cachedir, 'mav_dist_cls%03d.npz'%(cls_gt))
mav_dist_list.append(mav_dist_file)
if os.path.exists(mav_dist_file):
continue
# data for the current class
inds = np.where(np.array(labels) == cls_gt)[0]
videos_cls = [videolist[i] for i in inds]
# extract MAV features
features = extract_class_features(videos_cls, model, cls_gt)
mav_train = np.mean(features, axis=0)
# compute distance
eucos_dist, eu_dist, cos_dist = compute_distance(mav_train, features)
# save MAV and distances
np.savez(mav_dist_file[:-4], mav=mav_train, eucos=eucos_dist, eu=eu_dist, cos=cos_dist)
return mav_dist_list
def weibull_fitting(mav_dist_list, distance_type='eucos', tailsize=20):
weibull_model = {}
for cls_gt in range(len(mav_dist_list)):
# load the mav_dist file
cache = np.load(mav_dist_list[cls_gt], allow_pickle=True)
mav_train = cache['mav']
distances = cache[distance_type]
weibull_model[cls_gt] = {}
weibull_model[cls_gt]['mean_vec'] = mav_train
# weibull fitting for each channel
weibull_model[cls_gt]['weibull_model'] = []
num_channels = mav_train.shape[0]
for c in range(num_channels):
mr = libmr.MR()
tailtofit = sorted(distances[:, c])[-tailsize:]
mr.fit_high(tailtofit, len(tailtofit))
weibull_model[cls_gt]['weibull_model'] += [mr]
return weibull_model
def compute_openmax_prob(openmax_score, openmax_score_u):
num_channels, num_cls = openmax_score.shape
prob_scores, prob_unknowns = [], []
for c in range(num_channels):
channel_scores, channel_unknowns = [], []
for gt_cls in range(num_cls):
channel_scores += [np.exp(openmax_score[c, gt_cls])]
total_denominator = np.sum(np.exp(openmax_score[c, :])) + np.exp(np.sum(openmax_score_u[c, :]))
prob_scores += [channel_scores/total_denominator ]
prob_unknowns += [np.exp( | np.sum(openmax_score_u[c, :]) | numpy.sum |
# imports
#region
import os
import pyreadstat
import pandas as pd
import numpy as np
from statsmodels.stats.weightstats import DescrStatsW
from sklearn.linear_model import LinearRegression
import statsmodels.api as sm
import statsmodels.formula.api as smf
import seaborn as sns
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
from libs.utils import *
from libs.plots import *
from libs.extensions import *
plt.ioff()
#endregion
# -----------------------------
# --- FOOD CARBON FOOTPRINT ---
# Can I parse the LCA meta model database? ---
root = 'D:\\projects\\fakta-o-klimatu\\work\\389-food-carbon-footprint'
path = root + '\\LCA+Meta-Analysis_database-static.xlsx'
df = pd.read_excel(path, header=2)
df.columns
labels = df[np.isfinite(df['Unnamed: 0'])][['Unnamed: 0', 'Reference']]
df['Unnamed: 0'] = df['Unnamed: 0'].fillna(method='ffill')
ghg_cols = {
'GHG Emis \n(kg CO2 eq)': 'ghg_total',
'LUC Burn': 'luc_burn',
'LUC C Stock': 'luc_stock',
'Feed': 'feed',
'Farm': 'farm',
'Prcssing': 'processing',
'Tran & Str': 'transport',
'Packging': 'packaging',
'Ret\nail': 'retail',
'Loss.1': 'loss'
}
w_col = 'Weight'
g_col = 'Unnamed: 0'
data = df[[g_col, w_col, *ghg_cols]].rename(columns={w_col: 'weight', g_col: 'product', **ghg_cols})
data['processing'] = data['processing'].replace(to_replace='-', value=0)
data.show()
data.dtypes
data['luc'] = data['']
ghgs = list(ghg_cols.values())
df.dtypes.reset_index().show()
df.columns[65:76]
data
data.dtypes
data.groupby('product')['weight'].sum()
data.groupby('product')['weight'].sum()
for c in ghgs:
data[f'{c}_w'] = data[c] * data['weight']
avgs = data.groupby('product')[[f'{c}_w' for c in ghgs]].sum().reset_index().rename(columns={f'{c}_w':c for c in ghgs})
labels.columns = ['product', 'label']
labels = labels.iloc[:-1]
avgs = pd.merge(avgs, labels)
avgs = avgs[['label', *ghgs]].copy()
avgs['luc'] = avgs.luc_burn + avgs.luc_stock
avgs.show()
plain = data.groupby('product')[ghgs].mean().reset_index()
plain = pd.merge(plain, labels)
plain = plain[['label', *ghgs]].copy()
plain['luc'] = plain.luc_burn + plain.luc_stock
plain.show()
plain['ghg'] = plain.eval('luc + feed + farm + transport + processing + packaging + retail')
avgs['ghg'] = avgs.eval('luc + feed + farm + transport + processing + packaging + retail')
avgs.show()
sns.barplot('')
cols = 'luc feed farm transport processing packaging retail'.split()
plt.rcParams['figure.figsize'] = 12, 9
plt.rcParams['figure.subplot.left'] = 0.2
sums = avgs.set_index('label')[cols].sum(axis=1).sort_values()
ax = avgs.set_index('label').loc[sums.index][cols].plot.barh(stacked=True)
for x, y in enumerate(sums):
ax.text(y + 3, x, f'{y:.3g}', va='center')
#ax.text(50, 5, 'here')
ax.show()
second_file = 'aaq0216_DataS2.xls'
path2 = root + '\\' + second_file
df2 = pd.read_excel(path2, sheet_name='Results - Global Totals', header=2)
df2.show()
ghg_cols = ['LUC', 'Feed', 'Farm', 'Processing', 'Transport', 'Packging', 'Retail']
df2 = df2.iloc[:43].set_index('Product')[ghg_cols]
sums = df2.sum(axis=1).sort_values()
ax = df2.loc[sums.index].plot.barh(stacked=True)
for x, y in enumerate(sums):
ax.text(y + 3, x, f'{y:.3g}', va='center')
ax.set_title('Total GHG based on LCA, FBS 1kg weight')
ax.show()
# THIS IS GOOD! ---
# exactly the same results as on OurWorldInData
foo = """Beef (beef herd) 16 10 22 2.1 0 0 0
Lamb & Mutton 5.7 3.7 11 0.7 0 0 0
Beef (dairy herd) 13 8.6 18 1.7 0 0 0
Buffalo 2.7 1.8 2.8 0.4 0 0 0
Crustaceans (farmed) 4.3 2.1 1.1 0.2 0 0 0
Cheese 8.3 8.0 27 1.7 0 0 0
Pig Meat 45 28 112 4.5 0 0 0
Fish (farmed) 18 7.4 12 1.7 0 0 0
Poultry Meat 39 26 51 4.5 0 0 0
Eggs 24 24 34 2.6 0 0 0
Fish (capture) 21 8.4 13 1.9 0 0 0
Crustaceans (capture) 8.5 4.2 2.1 0.4 0 0 0
Tofu 3.5 3.2 2.5 0.5 53 40 8.4
Groundnuts 4.3 3.5 21 0.9 5.9 36 1.6
Other Pulses 16 15 51 3.1 55 188 12
Nuts 6.0 2.7 16 0.5 4.7 28 0.8
Peas 2.3 2.1 7.2 0.5 7.9 27 1.8
Milk 185 171 105 6.1 0 0 0
Butter, Cream & Ghee 4.8 4.6 29 0.1 0 0 0
Soymilk 10 9.1 5.1 0.3 185 104 6.1
Cassava 55 45 44 0.4 45 44 0.4
Rice 148 134 494 9.3 146 538 10
Oatmeal 1.6 1.0 2.6 0.1 1.1 2.9 0.1
Potatoes 115 90 66 1.3 90 66 1.3
Wheat & Rye (Bread) 182 166 471 14 181 513 15
Maize (Meal) 47 28 127 3.1 31 138 3.3
Cereals & Oilcr. Misc. 39 34 93 3.2 37 101 3.5
Palm Oil 6.6 6.7 52 0 7.5 59 0
Soybean Oil 10 10 77 0 11 87 0
Olive Oil 1.2 1.3 10 0 1.5 11 0
Rapeseed Oil 4.0 4.1 33 0 4.7 37 0
Sunflower Oil 3.8 3.8 31 0 4.3 35 0
Oils Misc. 5.1 4.7 41 0 5.2 47 0
Animal Fats 4.2 3.8 27 0 0 0 0
Tomatoes 55 37 6.7 0.4 44 8.0 0.4
Brassicas 28 25 6.2 0.3 30 7.5 0.4
Onions & Leeks 29 23 8.7 0.3 28 10 0.4
Root Vegetables 13 11 2.8 0.2 14 3.4 0.2
Other Vegetables 241 213 53 2.9 256 64 3.4
Aquatic Plants 5.0 4.4 1.8 0.1 5.3 2.1 0.1
Berries 11 7.5 4.3 0 9.0 5.1 0.1
Bananas 42 29 19 0.2 35 23 0.3
Apples 25 22 9.2 0.1 27 11 0.1
Citrus 48 40 11 0.2 47 13 0.2
Other Fruit 77 58 26 0.3 69 32 0.4
Cane Sugar 50 41 145 0 41 145 0
Beet Sugar 10 7.9 28 0 7.9 28 0
Sweeteners & Honey 8.3 6.7 20 0 6.7 20 0
Beer 72 63 28 0.3 63 28 0.3
Wine 9.1 8.0 5.3 0 8.0 5.3 0
Dark Chocolate 1.7 0.6 3.0 0.1 0.6 3.0 0.1
Coffee 3.1 1.7 0.7 0.1 1.7 0.7 0.1
Stimul. & Spices Misc. 5.3 3.5 6.8 0.4 3.5 6.8 0.4""".split(sep='\n')
pat = '^([^0-9]*) ([0-9.]*) ([0-9.]*) '
res = []
for x in foo:
m = re.match(pat, x)
res.append((m.group(1), m.group(2), m.group(3)))
conv = pd.DataFrame(res, columns=['Product', 'fbs', 'retail'])
conv['fbs'] = | np.float_(conv.fbs) | numpy.float_ |
"""Tests for the atmos_flux_inversion package.
Includes tests using random data, analytic solutions, and checks that
different methods agree for simple problems.
"""
from __future__ import print_function, division
import fractions
import itertools
import operator
import os.path
import atexit
import pickle
import math
import sys
try:
from functools import reduce
except ImportError:
# reduce used to be a builtin
pass
import numpy as np
import numpy.linalg as np_la
import numpy.linalg as la
import numpy.testing as np_tst
import scipy.linalg
import scipy.sparse
import scipy.optimize
# Import from scipy.linalg if not using dask
from scipy.linalg import cholesky
from scipy.sparse.linalg.interface import LinearOperator, MatrixLinearOperator
import unittest2
import pyfftw
import pandas as pd
import xarray
try:
import sparse
HAVE_SPARSE = True
except ImportError:
HAVE_SPARSE = False
import atmos_flux_inversion.optimal_interpolation
import atmos_flux_inversion.correlations
import atmos_flux_inversion.covariances
import atmos_flux_inversion.variational
import atmos_flux_inversion.remapper
import atmos_flux_inversion.wrapper
import atmos_flux_inversion.linalg
import atmos_flux_inversion.noise
import atmos_flux_inversion.psas
import atmos_flux_inversion.util
from atmos_flux_inversion.linalg import tolinearoperator
if os.path.exists(".pyfftw.pickle"):
with open(".pyfftw.pickle", "rb") as wis_in:
WISDOM = pickle.load(wis_in)
if isinstance(WISDOM[0], str):
WISDOM = [wis.encode("ascii")
for wis in WISDOM]
pyfftw.import_wisdom(WISDOM)
del WISDOM, wis_in
def save_wisdom():
"""Save accumulated pyfftw wisdom.
Saves in hidden file in current directory.
Should help speed up subsequent test runs.
"""
with open(".pyfftw.pickle", "wb") as wis_out:
pickle.dump(pyfftw.export_wisdom(), wis_out, 2)
atexit.register(save_wisdom)
del save_wisdom
# If adding other inexact methods to the list tested, be sure to add
# those to the `if "var" in name or "psas" in name` and
# `if "psas" in name` tests as applicable.
ALL_METHODS = (
atmos_flux_inversion.optimal_interpolation.simple,
atmos_flux_inversion.optimal_interpolation.fold_common,
atmos_flux_inversion.optimal_interpolation.save_sum,
atmos_flux_inversion.optimal_interpolation.scipy_chol,
atmos_flux_inversion.variational.simple,
atmos_flux_inversion.variational.incremental,
atmos_flux_inversion.variational.incr_chol,
atmos_flux_inversion.psas.simple,
atmos_flux_inversion.psas.fold_common,
)
ITERATIVE_METHOD_START = 4
"""Where the iterative methods start in the above list.
Used to test failure modes for these solvers.
"""
PRECISE_DTYPE = np.float128
"""The dtype used to represent analytic results.
These are initialized as :class:`fractions.Fraction` then converted to
this dtype for the comparison.
"""
ITERATIVE_STATE_TOLERANCE = 1e-3
ITERATIVE_COVARIANCE_TOLERANCE = 1e-1
EXACT_TOLERANCE = 1e-7
DTYPE = np.float64
"""Default dtype for certain tests."""
def getname(method):
"""Descriptive name for the function.
A name combining the function name and module.
Parameters
----------
method: callable
Returns
-------
name: str
"""
module = method.__module__
group = module.split(".")[-1]
variant = method.__name__
return "{group:s} ({variant:s})".format(group=group,
variant=variant)
def expectFailureIf(condition):
"""Mark a test as XFAIL based on condition.
Wrapper to make :func:`unittest2.expectedFailure` conditional.
Parameters
----------
condition: bool
Returns
-------
decorator: func
"""
if condition:
return unittest2.expectedFailure
return lambda fun: fun
class TestInversionSimple(unittest2.TestCase):
"""Test inversions using simple cases."""
def test_scalar_equal_variance(self):
"""Test a direct measurement of a scalar state."""
bg = np.atleast_1d(2.)
bg_cov = np.atleast_2d(1.)
obs = np.atleast_1d(3.)
obs_cov = np.atleast_2d(1.)
obs_op = np.atleast_2d(1.)
for method in ALL_METHODS:
name = getname(method)
with self.subTest(method=name):
post, post_cov = method(
bg, bg_cov, obs, obs_cov, obs_op)
np_tst.assert_allclose(post, 2.5)
np_tst.assert_allclose(post_cov, .5)
def test_scalar_unequal_variance(self):
"""Test assimilation of a direct measurement fo a scalar state.
Variances not equal.
"""
bg = np.atleast_1d(15.)
bg_cov = np.atleast_2d(2.)
obs = np.atleast_1d(14.)
obs_cov = np.atleast_2d(1.)
obs_op = np.atleast_2d(1.)
for method in ALL_METHODS:
with self.subTest(method=getname(method)):
post, post_cov = method(
bg, bg_cov, obs, obs_cov, obs_op)
np_tst.assert_allclose(
post, PRECISE_DTYPE(14 + fractions.Fraction(1, 3)))
np_tst.assert_allclose(
post_cov, PRECISE_DTYPE(fractions.Fraction(2, 3)))
def test_multiple_priors(self):
"""Test doing multiple assimilations at once.
Simple test.
"""
bg = np.array([[2., 3.]])
bg_cov = np.atleast_2d(1.)
obs = np.array([[3., 4.]])
obs_cov = np.atleast_2d(1.)
obs_op = np.atleast_2d(1.)
for method in ALL_METHODS[:ITERATIVE_METHOD_START]:
name = getname(method)
with self.subTest(method=name):
post, post_cov = method(
bg, bg_cov, obs, obs_cov, obs_op)
np_tst.assert_allclose(post, [[2.5, 3.5]])
np_tst.assert_allclose(post_cov, .5)
def test_homework_one(self):
"""Verify that this can reproduce the answers to HW1.
Make sure the answers here are within roundoff of the analytic
solutions.
"""
bg = np.array((18., 15., 22.))
bg_var = np.array((2., 2., 2.))
bg_corr = np.array(((1, .5, .25),
(.5, 1, .5),
(.25, .5, 1)))
obs = np.array((19., 14.))
obs_var = np.array((1., 1.))
obs_op = np.array(((1., 0., 0.),
(0., 1., 0.)))
bg_std = np.sqrt(bg_var)
bg_cov = np.diag(bg_std).dot(bg_corr.dot(np.diag(bg_std)))
# obs_std = np.sqrt(obs_var)
# Assume no correlations between observations.
obs_cov = np.diag(obs_var)
for method in ALL_METHODS:
# Setup for expected degradation of solutions
name = getname(method)
# The default for assert_allclose
cov_rtol = state_rtol = EXACT_TOLERANCE
with self.subTest(method=name):
# Also tested above in scalar_unequal_variance
with self.subTest(problem=3):
state_college_index = 1
post, post_cov = method(
bg[state_college_index],
bg_cov[state_college_index, state_college_index],
obs[state_college_index],
obs_cov[state_college_index, state_college_index],
obs_op[state_college_index, state_college_index])
np_tst.assert_allclose(
post, np.asanyarray(14 + fractions.Fraction(1, 3),
dtype=PRECISE_DTYPE),
rtol=state_rtol)
np_tst.assert_allclose(
post_cov, np.asanyarray(fractions.Fraction(2, 3),
dtype=PRECISE_DTYPE),
rtol=cov_rtol)
with self.subTest(problem=4):
state_college_index = 1
post, post_cov = method(
bg, bg_cov,
obs[state_college_index],
obs_cov[state_college_index, state_college_index],
obs_op[state_college_index, :])
np_tst.assert_allclose(
post, np.asanyarray((17 + fractions.Fraction(2, 3),
14 + fractions.Fraction(1, 3),
21 + fractions.Fraction(2, 3)),
dtype=PRECISE_DTYPE),
rtol=state_rtol)
with self.subTest(problem=5):
pittsburgh_index = 0
post, post_cov = method(
bg, bg_cov,
obs[pittsburgh_index],
obs_cov[pittsburgh_index, pittsburgh_index],
obs_op[pittsburgh_index, :])
np_tst.assert_allclose(
post,
np.asanyarray((18 + fractions.Fraction(2, 3),
15 + fractions.Fraction(1, 3),
22 + fractions.Fraction(1, 6)),
PRECISE_DTYPE),
rtol=state_rtol)
with self.subTest(problem=7):
state_college_index = 1
post, post_cov = method(
bg, bg_cov,
obs[state_college_index],
4 * obs_cov[state_college_index, state_college_index],
obs_op[state_college_index, :])
np_tst.assert_allclose(
post, np.asanyarray((17 + fractions.Fraction(5, 6),
14 + fractions.Fraction(2, 3),
21 + fractions.Fraction(5, 6)),
dtype=PRECISE_DTYPE),
rtol=state_rtol)
with self.subTest(problem=8):
post, post_cov = method(
bg, bg_cov, obs, obs_cov, obs_op)
# background correlations make this problem not
# strictly linear, at least without doing
# sequential inversions. Have not verified by hand
np_tst.assert_allclose(
post, np.asanyarray(
(18 + fractions.Fraction(1, 2),
14 + fractions.Fraction(1, 2),
21 + fractions.Fraction(3, 4)),
dtype=PRECISE_DTYPE),
rtol=state_rtol)
def test_sequential_assimilations(self):
"""Make sure this follows Bayes' rule."""
bg = np.array((18., 15., 22.))
bg_var = np.array((2., 2., 2.))
bg_corr = np.array(((1, .5, .25),
(.5, 1, .5),
(.25, .5, 1)))
obs = np.array((19., 14.))
obs_var = np.array((1., 1.))
obs_op = np.array(((1., 0., 0.),
(0., 1., 0.)))
bg_std = np.sqrt(bg_var)
bg_cov = np.diag(bg_std).dot(bg_corr.dot(np.diag(bg_std)))
# obs_std = np.sqrt(obs_var)
# Assume no correlations between observations.
obs_cov = np.diag(obs_var)
for method in ALL_METHODS:
name = getname(method)
if "var" in name.lower() or "psas" in name.lower():
state_rtol = ITERATIVE_STATE_TOLERANCE
cov_rtol = ITERATIVE_COVARIANCE_TOLERANCE
else:
# The default for assert_allclose
cov_rtol = state_rtol = EXACT_TOLERANCE
with self.subTest(method=name):
inter1, inter_cov1 = method(
bg, bg_cov, obs[0], obs_cov[0, 0],
obs_op[0, :])
post1, post_cov1 = method(
inter1, inter_cov1, obs[1], obs_cov[1, 1],
obs_op[1, :])
post2, post_cov2 = method(
bg, bg_cov, obs, obs_cov, obs_op)
np_tst.assert_allclose(
post1, post2, rtol=state_rtol)
if "psas" in name.lower():
# The second covariance isn't positive definite (one
# positive entry) and no entry shares the order of
# magnitude between the two.
raise unittest2.SkipTest("Known Failure: PSAS Covariances")
np_tst.assert_allclose(
post_cov1, post_cov2, rtol=cov_rtol)
def test_iterative_failures(self):
"""Test failure modes of iterative solvers."""
bg_stds = np.logspace(-8, 1, 10)
bg_corr = scipy.linalg.toeplitz(
np.arange(1, .9, -.01))
bg_cov = np.diag(bg_stds).dot(bg_corr).dot(np.diag(bg_stds))
bg_vals = np.arange(10)
obs_op = np.eye(3, 10)
obs_vals = 10 - np.arange(3)
obs_cov = np.diag((10, 1e-3, 1e-6)) / 8
for method in ALL_METHODS[ITERATIVE_METHOD_START:]:
name = getname(method)
with self.subTest(method=name):
with self.assertRaises(
atmos_flux_inversion.ConvergenceError) as cxt_mgr:
method(bg_vals, bg_cov, obs_vals, obs_cov, obs_op)
conv_err = cxt_mgr.exception
self.assertTrue(hasattr(conv_err, "guess"))
self.assertTrue(hasattr(conv_err, "result"))
self.assertIsInstance(conv_err.result,
scipy.optimize.OptimizeResult)
self.assertTrue(hasattr(conv_err, "hess_inv"))
class TestGaussianNoise(unittest2.TestCase):
"""Test the properties of the gaussian noise."""
def test_ident_cov(self):
"""Test generation with identity as covariance."""
sample_shape = 3
cov = np.eye(sample_shape)
noise = atmos_flux_inversion.noise.gaussian_noise(cov, int(1e6))
np_tst.assert_allclose(noise.mean(axis=0),
np.zeros((sample_shape,)),
rtol=1e-2, atol=1e-2)
np_tst.assert_allclose(np.cov(noise.T), cov,
rtol=1e-2, atol=1e-2)
def test_shape(self):
"""Make sure the returned shapes are correct."""
sample_shape = (3,)
sample_cov = np.eye(sample_shape[0])
for shape in ((), (6,), (2, 3)):
with self.subTest(shape=shape):
res = atmos_flux_inversion.noise.gaussian_noise(
sample_cov, shape)
self.assertEqual(res.shape, shape + sample_shape)
with self.subTest(shape=5):
res = atmos_flux_inversion.noise.gaussian_noise(
sample_cov, 5)
self.assertEqual(res.shape, (5,) + sample_shape)
with self.subTest(shape=None):
res = atmos_flux_inversion.noise.gaussian_noise(
sample_cov, None)
self.assertEqual(res.shape, sample_shape)
def test_operator(self):
"""Test that the code works with operator covariances."""
diagonal = (1, .5, .3, .2, .1)
sample_cov = atmos_flux_inversion.covariances.DiagonalOperator(
diagonal)
sample_shape = (len(diagonal),)
noise = atmos_flux_inversion.noise.gaussian_noise(sample_cov, int(1e6))
np_tst.assert_allclose(noise.mean(axis=0),
np.zeros(sample_shape),
rtol=1e-2, atol=1e-2)
np_tst.assert_allclose(np.cov(noise.T), np.diag(diagonal),
rtol=1e-2, atol=1e-2)
def test_kron_op(self):
"""Test that large kronecker operators don't break the handling."""
op1 = scipy.linalg.toeplitz(.6 ** np.arange(15))
diag = (1, .9, .8, .7, .6, .5, .4, .3, .2, .1)
op2 = atmos_flux_inversion.covariances.DiagonalOperator(diag)
combined = atmos_flux_inversion.util.kronecker_product(op1, op2)
noise = atmos_flux_inversion.noise.gaussian_noise(combined, int(1e5))
np_tst.assert_allclose(noise.mean(axis=0),
np.zeros(combined.shape[0]),
rtol=1.1e-2, atol=1.1e-2)
np_tst.assert_allclose(np.cov(noise.T),
scipy.linalg.kron(op1, np.diag(diag)),
rtol=3e-2, atol=3e-2)
def test_off_diagonal(self):
"""Test that the code works with off-diagonal elements."""
sample_cov = scipy.linalg.toeplitz((1, .5, .25, .125))
sample_shape = (4,)
noise = atmos_flux_inversion.noise.gaussian_noise(sample_cov, int(1e6))
np_tst.assert_allclose(noise.mean(axis=0),
np.zeros(sample_shape),
rtol=1e-2, atol=1e-2)
np_tst.assert_allclose(np.cov(noise.T), sample_cov,
rtol=1e-2, atol=1e-2)
def test_slow_decay(self):
"""Test that the code handles slowly-decaying covariances."""
sample_cov = scipy.linalg.toeplitz(.8 ** np.arange(10))
sample_shape = (10,)
noise = atmos_flux_inversion.noise.gaussian_noise(sample_cov, int(1e6))
np_tst.assert_allclose(noise.mean(axis=0),
np.zeros(sample_shape),
rtol=1e-2, atol=1e-2)
np_tst.assert_allclose(np.cov(noise.T), sample_cov,
rtol=1e-2, atol=1e-2)
def test_fails(self):
"""Test that construction fails on invalid input."""
self.assertRaises(ValueError,
atmos_flux_inversion.noise.gaussian_noise,
np.ones(10))
self.assertRaises(ValueError,
atmos_flux_inversion.noise.gaussian_noise,
np.eye(3, 2))
class TestCorrelations(unittest2.TestCase):
"""Test the generation of correlation matrices."""
def test_far_correl(self):
"""Test the correlation between points far apart.
Should be zero.
"""
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction
.__subclasses__()):
with self.subTest(corr_class=corr_class.__name__):
corr_fun = corr_class(1e-8)
corr = corr_fun(1e8)
self.assertAlmostEqual(corr, 0)
def test_near_correl(self):
"""Test 2D correlation between near points.
Should be one.
"""
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction
.__subclasses__()):
with self.subTest(corr_class=corr_class.__name__):
corr_fun = corr_class(1e8)
corr = corr_fun(1e-8)
self.assertAlmostEqual(corr, 1)
def test_2d_np_fromfunction(self):
"""Test that the structure works with np.fromfunction.
This is how the integration tests will get background
covariances, so this needs to work.
"""
test_size = (int(15), int(20))
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction
.__subclasses__()):
with self.subTest(corr_class=getname(corr_class)):
corr_fun = corr_class(2.)
corr = np.fromfunction(corr_fun.correlation_from_index,
shape=test_size * 2, dtype=float)
corr_mat = corr.reshape((np.prod(test_size),) * 2)
# test postitive definite
try:
chol_upper = cholesky(corr_mat)
except la.LinAlgError:
self.fail("corr_mat not positive definite")
# test symmetry
np_tst.assert_allclose(chol_upper.T.dot(chol_upper),
corr_mat,
rtol=1e-4, atol=1e-4)
def test_2d_make_matrix(self):
"""Test make_matrix for 2D correlations.
Checks against original value.
This test is really slow.
"""
# 30x25 Gaussian 10 not close
test_nx = 30
test_ny = 20
test_points = test_ny * test_nx
# TODO: speed up
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction.
__subclasses__()):
for dist in (1, 5, 10, 15):
with self.subTest(corr_class=getname(corr_class),
dist=dist):
if (
corr_class ==
atmos_flux_inversion.correlations.
GaussianCorrelation
):
raise unittest2.SkipTest(
"Gaussian({0:d}) correlations ill-conditioned".
format(dist)
)
corr_fun = corr_class(dist)
corr_mat = atmos_flux_inversion.correlations.make_matrix(
corr_fun, (test_ny, test_nx))
# Make sure diagonal elements are ones
np_tst.assert_allclose(np.diag(corr_mat), 1, rtol=1e-6)
# check if it matches the original
np_tst.assert_allclose(
corr_mat,
np.fromfunction(
corr_fun.correlation_from_index,
(test_ny, test_nx, test_ny, test_nx)
).reshape((test_points, test_points)),
# rtol=1e-13: Gaussian 10 and 15 fail
# atol=1e-15: Gaussian 1 and 5 fail
rtol=1e-5, atol=1e-6)
# check if it actually is positive definite
cholesky(corr_mat)
def test_1d_np_fromfunction(self):
"""Test that the structure works with np.fromfunction.
This is how the integration tests will get background
covariances, so this needs to work.
"""
test_size = (200,)
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction
.__subclasses__()):
with self.subTest(corr_class=getname(corr_class)):
# This fails with a correlation length of 5
corr_fun = corr_class(2.)
corr = np.fromfunction(corr_fun.correlation_from_index,
shape=test_size * 2, dtype=float)
corr_mat = corr.reshape((np.prod(test_size),) * 2)
# test postitive definite
chol_upper = cholesky(corr_mat)
# test symmetry
np_tst.assert_allclose(chol_upper.T.dot(chol_upper),
corr_mat,
rtol=1e-4, atol=1e-4)
def test_1d_make_matrix(self):
"""Test make_matrix for 1D correlations.
Checks against original value.
"""
test_nt = 200
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction.
__subclasses__()):
for dist in (1, 5, 10, 30):
with self.subTest(corr_class=getname(corr_class),
dist=dist):
if (
corr_class ==
atmos_flux_inversion.correlations.
GaussianCorrelation
):
raise unittest2.SkipTest(
"Gaussian({0:d}) correlations ill-conditioned".
format(dist)
)
corr_fun = corr_class(dist)
corr_mat = atmos_flux_inversion.correlations.make_matrix(
corr_fun,
test_nt
)
# Make sure diagonal elements are ones
np_tst.assert_allclose(np.diag(corr_mat), 1, rtol=1e-6)
# check if it matches the original
np_tst.assert_allclose(
corr_mat,
np.fromfunction(
corr_fun.correlation_from_index, (test_nt, test_nt)
).reshape((test_nt, test_nt)),
# rtol=1e-13: Gaussian 10 and 15 fail
# atol=1e-15: Gaussian 1 and 5 fail
rtol=2e-7, atol=5e-7
)
# check if it actually is positive definite
chol_upper = cholesky(corr_mat)
# test symmetry
np_tst.assert_allclose(chol_upper.T.dot(chol_upper),
corr_mat,
rtol=1e-4, atol=1e-4)
def test_fft_correlation_structure(self):
"""Ensure the FFT-based operators satisfy conditions of correlation matrices.
Checks for symmetry and ones on the diagonal.
"""
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction.
__subclasses__()):
for test_shape in ((300,), (20, 30)):
test_size = int(np.prod(test_shape, dtype=int))
for dist in (1, 3, 10, 30):
for is_cyclic in (True, False):
corr_fun = corr_class(dist)
corr_op = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_function(corr_fun, test_shape, is_cyclic))
# This is the fastest way to get column-major
# order from da.eye.
corr_mat = corr_op.dot(np.eye(test_size).T)
with self.subTest(
corr_class=getname(corr_class), dist=dist,
test_shape=test_shape, is_cyclic=is_cyclic,
test="symmetry"):
np_tst.assert_allclose(corr_mat, corr_mat.T,
rtol=1e-14, atol=1e-15)
with self.subTest(
corr_class=getname(corr_class), dist=dist,
test_shape=test_shape, is_cyclic=is_cyclic,
test="self-correlation"):
np_tst.assert_allclose(np.diag(corr_mat), 1)
def test_1d_fft_correlation_cyclic(self):
"""Test HomogeneousIsotropicCorrelation for cyclic 1D arrays.
Check against `make_matrix` and ignore values near the edges
of the domain where the two methods are different.
"""
test_nt = 512
test_lst = (np.zeros(test_nt), np.ones(test_nt), np.arange(test_nt),
np.eye(100, test_nt)[-1])
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction.
__subclasses__()):
for dist in (1, 3, 10):
# Magic numbers
# May need to increase for larger test_nt
noncorr_dist = 20 + 8 * dist
corr_fun = corr_class(dist)
corr_mat = atmos_flux_inversion.correlations.make_matrix(
corr_fun, test_nt)
corr_op = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_function(corr_fun, test_nt))
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
inverse="no"):
np_tst.assert_allclose(
corr_op.dot(test_vec)[noncorr_dist:-noncorr_dist],
corr_mat.dot(test_vec)[noncorr_dist:-noncorr_dist],
rtol=1e-3, atol=1.5e-3)
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
inverse="yes"):
if ((corr_class is atmos_flux_inversion.correlations.
GaussianCorrelation and
dist >= 3)):
# Gaussian(3) has FFT less
# well-conditioned than make_matrix
raise unittest2.SkipTest(
"Gaussian({0:d}) correlations ill-conditioned".
format(dist))
elif ((corr_class is atmos_flux_inversion.correlations.
BalgovindCorrelation and
dist == 10)):
# This one distance is problematic
# Roughly 3% of the points disagree
# for the last half of the tests
# I have no idea why
raise unittest2.SkipTest(
"Balgovind(10) correlations weird")
np_tst.assert_allclose(
corr_op.solve(
test_vec)[noncorr_dist:-noncorr_dist],
la.solve(
corr_mat,
test_vec)[noncorr_dist:-noncorr_dist],
rtol=1e-3, atol=2e-3
)
def test_1d_fft_correlation_acyclic(self):
"""Test HomogeneousIsotropicCorrelation for acyclic 1D arrays.
Check against `make_matrix` and ignore values near the edges
of the domain where the two methods are different.
"""
test_nt = 512
test_lst = (np.zeros(test_nt), np.ones(test_nt), np.arange(test_nt),
np.eye(100, test_nt)[-1])
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction.
__subclasses__()):
for dist in (1, 3, 10):
# Magic numbers
# May need to increase for larger test_nt
corr_fun = corr_class(dist)
corr_mat = atmos_flux_inversion.correlations.make_matrix(
corr_fun, test_nt)
corr_op = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_function(corr_fun, test_nt, False))
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
inverse="no"):
np_tst.assert_allclose(
corr_op.dot(test_vec),
corr_mat.dot(test_vec),
rtol=1e-3, atol=1e-5)
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
inverse="yes"):
self.assertRaises(
NotImplementedError, corr_op.solve, test_vec)
def test_2d_fft_correlation_cyclic(self):
"""Test HomogeneousIsotropicCorrelation for cyclic 2D arrays.
Check against `make_matrix` and ignore values near the edges
where the two methods differ.
"""
test_shape = (20, 30)
test_size = np.prod(test_shape)
test_lst = (np.zeros(test_size),
np.ones(test_size),
np.arange(test_size),
np.eye(10 * test_shape[0], test_size)[-1])
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction.
__subclasses__()):
for dist in (1, 3):
# Magic numbers
# May need to increase for larger domains
noncorr_dist = 20 + 8 * dist
corr_fun = corr_class(dist)
corr_mat = atmos_flux_inversion.correlations.make_matrix(
corr_fun, test_shape)
corr_op = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_function(corr_fun, test_shape))
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
direction="forward"):
np_tst.assert_allclose(
corr_op.dot(test_vec).reshape(test_shape)
[noncorr_dist:-noncorr_dist,
noncorr_dist:-noncorr_dist],
corr_mat.dot(test_vec).reshape(test_shape)
[noncorr_dist:-noncorr_dist,
noncorr_dist:-noncorr_dist],
rtol=1e-3, atol=1e-5)
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
direction="backward"):
if ((corr_class is atmos_flux_inversion.correlations.
GaussianCorrelation and
dist >= 3)):
# Gaussian(3) has FFT less
# well-conditioned than make_matrix
raise unittest2.SkipTest(
"Gaussian({0:d}) correlations ill-conditioned".
format(dist))
np_tst.assert_allclose(
corr_op.solve(
test_vec).reshape(test_shape)
[noncorr_dist:-noncorr_dist,
noncorr_dist:-noncorr_dist],
la.solve(
corr_mat,
test_vec).reshape(test_shape)
[noncorr_dist:-noncorr_dist,
noncorr_dist:-noncorr_dist],
rtol=1e-3, atol=1e-5)
def test_2d_fft_correlation_acyclic(self):
"""Test HomogeneousIsotropicCorrelation for acyclic 2D arrays.
Check against `make_matrix` and ignore values near the edges
where the two methods differ.
"""
test_shape = (20, 30)
test_size = np.prod(test_shape)
test_lst = (np.zeros(test_size),
np.ones(test_size),
np.arange(test_size),
np.eye(10 * test_shape[0], test_size)[-1])
for corr_class in (
atmos_flux_inversion.correlations.DistanceCorrelationFunction.
__subclasses__()):
for dist in (1, 3):
# Magic numbers
# May need to increase for larger domains
corr_fun = corr_class(dist)
corr_mat = atmos_flux_inversion.correlations.make_matrix(
corr_fun, test_shape)
corr_op = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_function(corr_fun, test_shape, False))
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
direction="forward"):
np_tst.assert_allclose(
corr_op.dot(test_vec).reshape(test_shape),
corr_mat.dot(test_vec).reshape(test_shape),
rtol=1e-3, atol=1e-5)
for i, test_vec in enumerate(test_lst):
with self.subTest(corr_class=getname(corr_class),
dist=dist, test_num=i,
direction="backward"):
self.assertRaises(
NotImplementedError, corr_op.solve, test_vec)
def test_homogeneous_from_array_cyclic(self):
"""Make sure cyclic from_array can be roundtripped.
Also tests that odd state sizes work.
"""
test_size = 25
corr_class = atmos_flux_inversion.correlations.ExponentialCorrelation
for dist in (1, 3, 5):
with self.subTest(dist=dist):
corr_fun = corr_class(dist)
corr_op1 = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_function(corr_fun, test_size, True))
first_column = corr_op1.dot(np.eye(test_size, 1)[:, 0])
corr_op2 = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_array(first_column))
np_tst.assert_allclose(
corr_op1.dot(np.eye(test_size)),
corr_op2.dot(np.eye(test_size)))
def test_kron_composition(self):
"""Test that `kron` works similar to composition of the domains."""
HomogeneousIsotropicCorrelation = (
atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation
)
corr_class = atmos_flux_inversion.correlations.GaussianCorrelation
corr_fun = corr_class(5)
shape1 = (5,)
shape2 = (7,)
corr_op1 = (HomogeneousIsotropicCorrelation.
from_function(corr_fun, shape1))
corr_op2 = (HomogeneousIsotropicCorrelation.
from_function(corr_fun, shape2))
kron_corr = corr_op1.kron(corr_op2)
direct_corr = (HomogeneousIsotropicCorrelation.
from_function(corr_fun, shape1 + shape2))
self.assertEqual(kron_corr.shape, direct_corr.shape)
self.assertEqual(kron_corr._underlying_shape,
direct_corr._underlying_shape)
np_tst.assert_allclose(kron_corr._corr_fourier,
direct_corr._corr_fourier)
np_tst.assert_allclose(kron_corr._fourier_near_zero,
direct_corr._fourier_near_zero)
def test_kron_results(self):
"""Test the Kronecker product implementation."""
HomogeneousIsotropicCorrelation = (
atmos_flux_inversion.correlations.HomogeneousIsotropicCorrelation)
corr_class = atmos_flux_inversion.correlations.ExponentialCorrelation
test_shapes = (20, 25, (5, 6))
distances = (3, 5,)
for dist1, shape1, dist2, shape2 in itertools.product(
distances, test_shapes, repeat=2):
with self.subTest(dist1=dist1, dist2=dist2):
corr_fun1 = corr_class(dist1)
corr_fun2 = corr_class(dist2)
corr_op1 = (
HomogeneousIsotropicCorrelation.
from_function(corr_fun1, shape1))
corr_op2 = (
HomogeneousIsotropicCorrelation.
from_function(corr_fun2, shape2))
size1 = np.prod(shape1)
size2 = np.prod(shape2)
corr_mat1 = corr_op1.dot(np.eye(size1))
corr_mat2 = corr_op2.dot(np.eye(size2))
full_corr1 = corr_op1.kron(corr_op2)
full_corr2 = scipy.linalg.kron(np.asarray(corr_mat1),
np.asarray(corr_mat2))
self.assertIsInstance(
corr_op1, HomogeneousIsotropicCorrelation)
test_vec = np.arange(size1 * size2)
np_tst.assert_allclose(
full_corr1.dot(test_vec),
full_corr2.dot(test_vec))
test_mat = np.eye(size1 * size2)
np_tst.assert_allclose(
full_corr1.dot(test_mat),
full_corr2.dot(test_mat))
def test_kron_delegate(self):
"""Test that kron delegates where appropriate."""
op1 = (atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_array((1, .5, .25)))
mat2 = np.eye(5)
combined_op = op1.kron(mat2)
self.assertIsInstance(
combined_op,
atmos_flux_inversion.linalg.SchmidtKroneckerProduct
)
def test_sqrt_direct(self):
"""Test the square root in the most direct manner possible.
Checks whether matrices corresponding to sqrt.T@sqrt and the
original matrix are approximately equal.
"""
operator = (atmos_flux_inversion.correlations.
HomogeneousIsotropicCorrelation.
from_array((1, .5, .25, .125)))
sqrt = operator.sqrt()
sqrt_squared = sqrt.T.dot(sqrt)
mat = np.eye(4)
np_tst.assert_allclose(operator.dot(mat),
sqrt_squared.dot(mat))
def test_from_function_direct(self):
"""Directly test the output of from_function."""
corr_func = (atmos_flux_inversion.correlations.
ExponentialCorrelation(1 / np.log(2)))
from_function = (
atmos_flux_inversion.correlations.HomogeneousIsotropicCorrelation.
from_function)
toeplitz = scipy.linalg.toeplitz
with self.subTest(is_cyclic=False, nd=1):
corr_op = from_function(corr_func, [10], False)
np_tst.assert_allclose(
corr_op.dot(np.eye(10)),
toeplitz(0.5 ** np.arange(10)))
with self.subTest(is_cyclic=False, nd=2):
corr_op = from_function(corr_func, [2, 3], False)
same_row = toeplitz(0.5 ** np.array([0, 1, 2]))
other_row = toeplitz(
0.5 ** np.array([1, np.sqrt(2), np.sqrt(5)]))
np_tst.assert_allclose(
corr_op.dot(np.eye(6)),
np.block([[same_row, other_row],
[other_row, same_row]]))
corr_op = from_function(corr_func, [4, 6], False)
same_row = toeplitz(0.5 ** np.arange(6))
next_row = toeplitz(
0.5 ** np.array([1, np.sqrt(2), np.sqrt(5),
np.sqrt(10), np.sqrt(17),
np.sqrt(26)]))
row_after_next = toeplitz(
0.5 ** np.array([2, np.sqrt(5), np.sqrt(8),
np.sqrt(13), np.sqrt(20),
np.sqrt(29)]))
two_rows_on = toeplitz(
0.5 ** np.array([3, np.sqrt(10), np.sqrt(13),
np.sqrt(18), 5, np.sqrt(34)]))
np_tst.assert_allclose(
corr_op.dot(np.eye(24)),
np.block([[same_row, next_row, row_after_next, two_rows_on],
[next_row, same_row, next_row, row_after_next],
[row_after_next, next_row, same_row, next_row],
[two_rows_on, row_after_next, next_row, same_row]]))
with self.subTest(is_cyclic=True, nd=1):
corr_op = from_function(corr_func, [10], True)
np_tst.assert_allclose(
corr_op.dot(np.eye(10)),
toeplitz(
0.5 ** np.array([0, 1, 2, 3, 4, 5, 4, 3, 2, 1])))
with self.subTest(is_cyclic=True, nd=2):
corr_op = from_function(corr_func, [4, 6])
same_row = toeplitz(
0.5 ** np.array([0, 1, 2, 3, 2, 1]))
next_row = toeplitz(
0.5 ** np.array([1, np.sqrt(2), np.sqrt(5),
np.sqrt(10), np.sqrt(5), np.sqrt(2)]))
row_after_next = toeplitz(
0.5 ** np.array([2, np.sqrt(5), np.sqrt(8),
| np.sqrt(13) | numpy.sqrt |
# coding: utf-8
""" Test model class """
from __future__ import print_function
import os
import random
import string
import unittest
import yaml
import numpy as np
import sick.models as models
import sick.validation as validation
def random_string(n=10):
return ''.join(random.choice(string.ascii_uppercase + string.digits) \
for _ in range(n))
def create_temporary_filename(ext=None, n=10):
if ext is None:
ext = ""
filename = os.extsep.join([random_string(10), ext])
while os.path.exists(filename):
filename = os.extsep.join([random_string(10), ext])
return filename
class ModelTest(unittest.TestCase):
def test_non_existent_channel_keys(self):
bad_model = {
"channels": {
"one": {
"dispersion_filename": "non_existent_filename"
}
}
}
assert not os.path.exists("non_existent_filename"), "...really?"\
" you named a file 'non_existent_filename'? who does that?!"
model_filename = create_temporary_filename("yaml")
with open(model_filename, "w+") as fp:
yaml.dump(bad_model, fp)
# Assert an IOError missing the dispersion filename
self.assertRaises(IOError, models.Model, model_filename)
# OK create a dispersion filename
dispersion_filename = create_temporary_filename("txt")
np.savetxt(dispersion_filename, | np.arange(10) | numpy.arange |
import pytest
import numpy as np
import pandas as pd
import DOT_assignment.engine
import DOT_assignment.assignments
import DOT_assignment.controls
import DOT_assignment.run
import DOT_assignment.dynamics
import DOT_assignment.agents
import DOT_assignment.setup
@pytest.fixture
def sim_params_ex():
# SIM PARAMETERS CONSTANT ACROSS ENSEMBLE
dt = 0.01
maxtime = 5
dim = 2
nagents = 5
ntargets = 5
# agent_model = "Double_Integrator"
# target_model = "Double_Integrator"
agent_model = "Linearized_Quadcopter"
target_model = "Linearized_Quadcopter"
collisions = True
collision_tol = 1e-2
agent_control_policy = "LQR"
target_control_policy = "LQR"
assignment_epoch = 10
# Create directory for storage
nensemble = 0
# TODO ensemble should not default to 'identical'
ensemble_name = 'TEST_ENSEMBLE'
root_directory = '/Users/foo/my/project/'
ensemble_directory = root_directory + ensemble_name
# TODO assumes heterogeneous swarms
# formations: uniform_distribution, circle, fibonacci_sphere
initial_formation_params = {
'nagents': nagents, 'agent_model': agent_model, 'agent_swarm_formation': 'uniform_distribution',
'ntargets': ntargets, 'target_model': target_model, 'target_swarm_formation': 'fibonacci_sphere',
'nstationary_states': ntargets, 'stationary_states_formation': 'circle'
}
sim_params = {'dt': dt, 'maxtime': maxtime, 'dim': dim, 'nagents': nagents, 'ntargets': ntargets, 'agent_model': agent_model, 'target_model': target_model, 'collisions': collisions, 'collision_tol': collision_tol, 'agent_control_policy': agent_control_policy, 'target_control_policy': target_control_policy, 'assignment_epoch': assignment_epoch, 'initial_formation_params': initial_formation_params}
return sim_params
@pytest.fixture
def sim_profile_ex(sim_params_ex):
sim_params = sim_params_ex
dt = sim_params['dt']
maxtime = sim_params['maxtime']
dim = sim_params['dim']
nagents = sim_params['nagents']
ntargets = sim_params['ntargets']
agent_model = sim_params['agent_model']
target_model = sim_params['target_model']
collisions = sim_params['collisions']
collision_tol = sim_params['collision_tol']
agent_control_policy = sim_params['agent_control_policy']
target_control_policy = sim_params['target_control_policy']
assignment_epoch = sim_params['assignment_epoch']
initial_formation_params = sim_params['initial_formation_params']
initial_conditions = DOT_assignment.setup.generate_initial_conditions(dim, initial_formation_params)
###### DEFINE SIMULATION PROFILES ######
sim_profiles = {}
# EMD parameters
dt = dt
asst = 'AssignmentEMD'
sim_profile_name = 'emd'
sim_profiles = {'agent_model': agent_model, 'target_model': target_model,
'agent_control_policy': agent_control_policy, 'target_control_policy': target_control_policy,
'assignment_policy': asst, 'assignment_epoch': assignment_epoch, 'nagents': nagents, 'ntargets': ntargets,
'collisions': collisions, 'collision_tol': collision_tol, 'dim': dim, 'dt': dt, 'maxtime': maxtime,
'initial_conditions': initial_conditions}
return sim_profiles
@pytest.fixture
def engine_ex(sim_profile_ex):
sim = DOT_assignment.setup.setup_simulation(sim_profile_ex)
dim = 2
# Simulation data structures
collisions = sim["collisions"]
collision_tol = sim["collision_tol"]
dt = sim["dt"]
maxtime = sim["maxtime"]
dx = sim["dx"]
du = sim["du"]
statespace = sim["statespace"]
x0 = sim["x0"]
ltidyn = sim["agent_dyn"]
target_dyn = sim["target_dyns"]
poltrack = sim["agent_pol"]
poltargets = sim["target_pol"]
assignment_pol = sim["asst_pol"]
assignment_epoch = sim["asst_epoch"]
nagents = sim["nagents"]
ntargets = sim["ntargets"]
runner = sim["runner"]
# Other simulation information
agent_model = sim["agent_model"]
target_model = sim["target_model"]
agent_control_policy = sim["agent_control_policy"]
target_control_policy = sim["target_control_policy"]
agents = [DOT_assignment.agents.TrackingAgent(dx, du, statespace, dim, ltidyn, poltrack) for ii in range(nagents)]
targets = [DOT_assignment.agents.Agent(dx, du, statespace, dim, target_dyn, poltarget) for ii, poltarget in enumerate(poltargets)]
sys = DOT_assignment.systems.OneVOne(agents, targets, assignment_pol, assignment_epoch)
eng = DOT_assignment.engine.Engine(dim=dim, dt=dt, maxtime=maxtime, collisions=collisions, collision_tol=collision_tol)
return [x0, sys, eng]
def test_log(engine_ex):
"""
Tests the data logging within the engine
"""
x0 = engine_ex[0]
sys = engine_ex[1]
eng = engine_ex[2]
tout = np.ones((10,1))
olddata = | np.tile(x0, (tout.shape[0], 1)) | numpy.tile |
import rps.robotarium as robotarium
from rps.utilities.transformations import *
from rps.utilities.barrier_certificates import *
from rps.utilities.misc import *
from rps.utilities.controllers import *
import matplotlib.animation as animation
import matplotlib.patches as patches
import numpy as np
import time
import copy
import math
class RobotState(object):
def __init__(self, initial_pose, vel_cmd, is_team_purple, robot_number):
assert len(initial_pose) == 3, "Pose should be 3 elements (x, y, theta)"
assert len(vel_cmd) == 2, "Vel cmd should be 2 elements (linear, angular)"
self.initial_pose = initial_pose
self._pose = initial_pose
self.last_vel_cmd = vel_cmd
# If false, is team orange.
self.is_team_purple = is_team_purple
self.robot_number = robot_number
# Has this robot been tagged. If true, commands to this robot are ignored.
self.is_tagged = False
# Can this robot tag another bot / the flag.
self.can_tag = True
self.tag_cooldown = 0.0
# Has this robot captured a flag
self.has_flag = False
def update_pose(self, pose):
'''
Updates the robot pose after a simulation step has been taken.
'''
assert len(pose) == 3, "Pose should be 3 elements (x, y, theta)"
self._pose = pose
def update_last_vel(self, vel_cmd):
'''
Updates the last velocity command sent to this robot.
'''
assert len(vel_cmd) == 2, "Vel cmd should be 2 elements (linear, angular)"
self._last_vel_cmd = vel_cmd
class RobotPolicy(object):
def __init__(self, attempt_tag):
self.attempt_tag_fn = attempt_tag
def policy(self, state, observation):
# Linear and angular velocity
vel_cmd = [0., 0.]
return vel_cmd
class RobotObservation(object):
def __init__(self):
self.left_encoder = 0 # rads
self.right_encoder = 0 # rads
self.flags = list()
self.robots = list()
def populate_flags(self, ego_state, flag_loc, active, color):
flag = dict()
angle = np.arctan2(ego_state._pose[1] - flag_loc[1], ego_state._pose[0] - flag_loc[0]) - ego_state._pose[2]
angle = (angle + np.pi) % (2 * np.pi) - np.pi
flag['angle'] = angle
dist = np.linalg.norm((ego_state._pose[:2] - flag_loc))
flag['dist'] = dist
flag['color'] = color
flag['active'] = active
self.flags.append(flag)
def populate_robots(self, ego_state, bot):
bot_obs = dict()
angle = np.arctan2(ego_state._pose[1] - bot._pose[1], ego_state._pose[0] - bot._pose[0]) - ego_state._pose[2]
angle = (angle + np.pi) % (2 * np.pi) - np.pi
bot_obs['angle'] = angle
dist = np.linalg.norm((ego_state._pose[:2] - bot._pose[:2]))
bot_obs['dist'] = dist
bot_obs['color'] = 'purple' if bot.is_team_purple else 'orange'
self.robots.append(bot_obs)
class CTFGame(object):
def __init__(self, num_robots=12, store_state_history=True, max_iterations=1000, use_barriers=True):
# Instantiate Robotarium object
self.num_robots = num_robots
assert self.num_robots == 12 or self.num_robots == 4 or self.num_robots == 2
initial_conditions = np.array([0.])
if self.num_robots == 12:
initial_conditions = np.array([[-1.3, -1.3, -1.3, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, 1.3, 1.3, 1.3],
[ 0.5, 0.0, -0.5, 0.5, 0.0, -0.5, 0.5, 0.0,-0.5, 0.5, 0.0,-0.5],
[ 0., 0., 0., 0., 0., 0., np.pi, np.pi, np.pi, np.pi, np.pi, np.pi]])
elif self.num_robots == 4:
initial_conditions = np.array([[-1.0, -1.0, 1.0, 1.0],
[0.5, -0.5, 0.5, -0.5],
[0., 0., np.pi, np.pi]])
elif self.num_robots == 2:
initial_conditions = np.array([[-1.0, 1.0],
[0.0, 0.0],
[0., np.pi]])
self.robo_inst = robotarium.Robotarium(number_of_robots=num_robots,
show_figure=False,
initial_conditions=initial_conditions,
sim_in_real_time=False)
# Create barrier certificates to avoid collision
self.uni_barrier_cert = create_unicycle_barrier_certificate()
# Flags, true if present
self.purple_flags = [True, True]
self.purple_flag_locs = [(-1.45, -0.85), (-1.45, 0.85)]
self.orange_flags = [True, True]
self.orange_flag_locs = [(1.45, -0.85), (1.45, 0.85)]
self.purple_home = [-1.5, 0.0, 0.0]
self.orange_home = [1.5, 0.0, np.pi]
self.purple_points = 0
self.orange_points = 0
# Robot tag cooldowns
self.tag_cooldowns = np.zeros(self.num_robots)
self.robot_states = [None]*self.num_robots
self.robot_policies = [None]*self.num_robots
self.store_state_history = store_state_history
self.state_history = list()
# Create barrier certificates to avoid collision
self.uni_barrier_cert = create_unicycle_barrier_certificate()
self.use_barriers = use_barriers
self.max_iterations = max_iterations
self.iterations = 0
self.flag_states = list()
self.flag_states.append(copy.deepcopy(self.purple_flags + self.orange_flags))
self.score_history = list()
self.score_history.append([0., 0.])
def register_purple_team(self, states, policies):
assert len(states) == self.num_robots/2, "You must provide {} state classes for your team".format(self.num_robots/2)
assert len(policies) == self.num_robots/2, "You must provide {} policy objects for your team".format(self.num_robots/2)
self.robot_states[:int(self.num_robots/2)] = states
self.robot_policies[:int(self.num_robots/2)] = policies
def register_orange_team(self, states, policies):
assert len(states) == self.num_robots/2, "You must provide {} state classes for your team".format(self.num_robots/2)
assert len(policies) == self.num_robots/2, "You must provide {} policy objects for your team".format(self.num_robots/2)
self.robot_states[int(self.num_robots/2):] = states
self.robot_policies[int(self.num_robots/2):] = policies
@staticmethod
def is_offsides(state):
if state.is_team_purple and state._pose[0] > 0.0:
return True
elif not state.is_team_purple and state._pose[0] < 0.0:
return True
else:
return False
@staticmethod
def replace_one_flag(flags):
if flags[0] == False:
flags[0] = True
return
if flags[1] == False:
flags[1] = True
return
def attempt_tag(self, tagger_robot_state):
'''
Returns true if the tag attempt was successful, false otherwise.
'''
tag_radius = 0.25
if self.tag_cooldowns[tagger_robot_state.robot_number] > 0.0:
return False
self.tag_cooldowns[tagger_robot_state.robot_number] = 3.0
tagger_robot_state.tag_cooldown = 3.0
tagger_robot_state.can_tag = False
if tagger_robot_state.is_team_purple:
for i, loc in enumerate(self.orange_flag_locs):
if np.linalg.norm((tagger_robot_state._pose[:2] - np.array(loc))) < tag_radius:
tagger_robot_state.has_flag = True
self.orange_flags[i] = False
return True
else:
for i, loc in enumerate(self.purple_flag_locs):
if np.linalg.norm((tagger_robot_state._pose[:2] - np.array(loc))) < tag_radius:
tagger_robot_state.has_flag = True
self.purple_flags[i] = False
return True
for state in self.robot_states:
# Opposing teams
if state.is_team_purple != tagger_robot_state.is_team_purple:
if np.linalg.norm((tagger_robot_state._pose[:2] - state._pose[:2])) < tag_radius:
if self.is_offsides(state):
state.is_tagged = True
# If enemy is tagged, they lose and replace flag
if state.has_flag:
state.has_flag = False
if state.is_team_purple:
self.replace_one_flag(self.orange_flags)
else:
self.replace_one_flag(self.purple_flags)
return True
return False
def setup(self):
poses = self.robo_inst.get_poses()
self.robo_inst.step()
for i, pose in enumerate(poses.copy().T):
assert self.robot_states[i] != None and self.robot_policies[i] != None
is_team_purple = i < self.num_robots/2
# Replace classes with instantiations of those classes.
self.robot_states[i] = self.robot_states[i](pose, [0., 0.], is_team_purple, i)
self.robot_policies[i] = self.robot_policies[i](self.attempt_tag)
if self.store_state_history:
self.state_history.append(copy.deepcopy(self.robot_states))
def run(self):
while self.iterations < self.max_iterations:
poses = self.robo_inst.get_poses()
for i, pose in enumerate(poses.copy().T):
self.robot_states[i].update_pose(pose)
vel_cmds = np.array([[0., 0.]]*self.num_robots)
for i in range(self.num_robots):
# Simulate sensors
obs = RobotObservation()
for flag_loc, active in zip(self.purple_flag_locs, self.purple_flags):
obs.populate_flags(self.robot_states[i], flag_loc, active, 'purple')
for flag_loc, active in zip(self.orange_flag_locs, self.orange_flags):
obs.populate_flags(self.robot_states[i], flag_loc, active, 'orange')
for j in range(self.num_robots):
if i == j:
continue
obs.populate_robots(self.robot_states[i], self.robot_states[j])
# Run policy
vel_cmds[i] = self.robot_policies[i].policy(self.robot_states[i], obs)
# Send tagged robots back home
for i, state in enumerate(self.robot_states):
if state.is_tagged:
unicycle_pose_controller = create_hybrid_unicycle_pose_controller()
goal = [0., 0., 0.]
if state.is_team_purple:
goal = self.purple_home
else:
goal = self.orange_home
if np.linalg.norm((state._pose[:2] - goal[:2])) < 0.15:
state.is_tagged = False
else:
vel_cmds[i] = unicycle_pose_controller( | np.array([state._pose]) | numpy.array |
# This module has been generated automatically from space group information
# obtained from the Computational Crystallography Toolbox
#
"""
Space groups
This module contains a list of all the 230 space groups that can occur in
a crystal. The variable space_groups contains a dictionary that maps
space group numbers and space group names to the corresponding space
group objects.
.. moduleauthor:: <NAME> <<EMAIL>>
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2013 The Mosaic Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file LICENSE.txt, distributed as part of this software.
#-----------------------------------------------------------------------------
import numpy as N
class SpaceGroup(object):
"""
Space group
All possible space group objects are created in this module. Other
modules should access these objects through the dictionary
space_groups rather than create their own space group objects.
"""
def __init__(self, number, symbol, transformations):
"""
:param number: the number assigned to the space group by
international convention
:type number: int
:param symbol: the Hermann-Mauguin space-group symbol as used
in PDB and mmCIF files
:type symbol: str
:param transformations: a list of space group transformations,
each consisting of a tuple of three
integer arrays (rot, tn, td), where
rot is the rotation matrix and tn/td
are the numerator and denominator of the
translation vector. The transformations
are defined in fractional coordinates.
:type transformations: list
"""
self.number = number
self.symbol = symbol
self.transformations = transformations
self.transposed_rotations = N.array([N.transpose(t[0])
for t in transformations])
self.phase_factors = N.exp(N.array([(-2j*N.pi*t[1])/t[2]
for t in transformations]))
def __repr__(self):
return "SpaceGroup(%d, %s)" % (self.number, repr(self.symbol))
def __len__(self):
"""
:return: the number of space group transformations
:rtype: int
"""
return len(self.transformations)
def symmetryEquivalentMillerIndices(self, hkl):
"""
:param hkl: a set of Miller indices
:type hkl: Scientific.N.array_type
:return: a tuple (miller_indices, phase_factor) of two arrays
of length equal to the number of space group
transformations. miller_indices contains the Miller
indices of each reflection equivalent by symmetry to the
reflection hkl (including hkl itself as the first element).
phase_factor contains the phase factors that must be applied
to the structure factor of reflection hkl to obtain the
structure factor of the symmetry equivalent reflection.
:rtype: tuple
"""
hkls = N.dot(self.transposed_rotations, hkl)
p = N.multiply.reduce(self.phase_factors**hkl, -1)
return hkls, p
space_groups = {}
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(1, 'P 1', transformations)
space_groups[1] = sg
space_groups['P 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(2, 'P -1', transformations)
space_groups[2] = sg
space_groups['P -1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(3, 'P 1 2 1', transformations)
space_groups[3] = sg
space_groups['P 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(4, 'P 1 21 1', transformations)
space_groups[4] = sg
space_groups['P 1 21 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(5, 'C 1 2 1', transformations)
space_groups[5] = sg
space_groups['C 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(6, 'P 1 m 1', transformations)
space_groups[6] = sg
space_groups['P 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(7, 'P 1 c 1', transformations)
space_groups[7] = sg
space_groups['P 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(8, 'C 1 m 1', transformations)
space_groups[8] = sg
space_groups['C 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(9, 'C 1 c 1', transformations)
space_groups[9] = sg
space_groups['C 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(10, 'P 1 2/m 1', transformations)
space_groups[10] = sg
space_groups['P 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(11, 'P 1 21/m 1', transformations)
space_groups[11] = sg
space_groups['P 1 21/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(12, 'C 1 2/m 1', transformations)
space_groups[12] = sg
space_groups['C 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(13, 'P 1 2/c 1', transformations)
space_groups[13] = sg
space_groups['P 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(14, 'P 1 21/c 1', transformations)
space_groups[14] = sg
space_groups['P 1 21/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(15, 'C 1 2/c 1', transformations)
space_groups[15] = sg
space_groups['C 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(16, 'P 2 2 2', transformations)
space_groups[16] = sg
space_groups['P 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(17, 'P 2 2 21', transformations)
space_groups[17] = sg
space_groups['P 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(18, 'P 21 21 2', transformations)
space_groups[18] = sg
space_groups['P 21 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(19, 'P 21 21 21', transformations)
space_groups[19] = sg
space_groups['P 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(20, 'C 2 2 21', transformations)
space_groups[20] = sg
space_groups['C 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(21, 'C 2 2 2', transformations)
space_groups[21] = sg
space_groups['C 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(22, 'F 2 2 2', transformations)
space_groups[22] = sg
space_groups['F 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(23, 'I 2 2 2', transformations)
space_groups[23] = sg
space_groups['I 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(24, 'I 21 21 21', transformations)
space_groups[24] = sg
space_groups['I 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(25, 'P m m 2', transformations)
space_groups[25] = sg
space_groups['P m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(26, 'P m c 21', transformations)
space_groups[26] = sg
space_groups['P m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(27, 'P c c 2', transformations)
space_groups[27] = sg
space_groups['P c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(28, 'P m a 2', transformations)
space_groups[28] = sg
space_groups['P m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(29, 'P c a 21', transformations)
space_groups[29] = sg
space_groups['P c a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(30, 'P n c 2', transformations)
space_groups[30] = sg
space_groups['P n c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(31, 'P m n 21', transformations)
space_groups[31] = sg
space_groups['P m n 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(32, 'P b a 2', transformations)
space_groups[32] = sg
space_groups['P b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(33, 'P n a 21', transformations)
space_groups[33] = sg
space_groups['P n a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(34, 'P n n 2', transformations)
space_groups[34] = sg
space_groups['P n n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(35, 'C m m 2', transformations)
space_groups[35] = sg
space_groups['C m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(36, 'C m c 21', transformations)
space_groups[36] = sg
space_groups['C m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(37, 'C c c 2', transformations)
space_groups[37] = sg
space_groups['C c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(38, 'A m m 2', transformations)
space_groups[38] = sg
space_groups['A m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(39, 'A b m 2', transformations)
space_groups[39] = sg
space_groups['A b m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(40, 'A m a 2', transformations)
space_groups[40] = sg
space_groups['A m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(41, 'A b a 2', transformations)
space_groups[41] = sg
space_groups['A b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(42, 'F m m 2', transformations)
space_groups[42] = sg
space_groups['F m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(43, 'F d d 2', transformations)
space_groups[43] = sg
space_groups['F d d 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(44, 'I m m 2', transformations)
space_groups[44] = sg
space_groups['I m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(45, 'I b a 2', transformations)
space_groups[45] = sg
space_groups['I b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(46, 'I m a 2', transformations)
space_groups[46] = sg
space_groups['I m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(47, 'P m m m', transformations)
space_groups[47] = sg
space_groups['P m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(48, 'P n n n :2', transformations)
space_groups[48] = sg
space_groups['P n n n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(49, 'P c c m', transformations)
space_groups[49] = sg
space_groups['P c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(50, 'P b a n :2', transformations)
space_groups[50] = sg
space_groups['P b a n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(51, 'P m m a', transformations)
space_groups[51] = sg
space_groups['P m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(52, 'P n n a', transformations)
space_groups[52] = sg
space_groups['P n n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(53, 'P m n a', transformations)
space_groups[53] = sg
space_groups['P m n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(54, 'P c c a', transformations)
space_groups[54] = sg
space_groups['P c c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(55, 'P b a m', transformations)
space_groups[55] = sg
space_groups['P b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(56, 'P c c n', transformations)
space_groups[56] = sg
space_groups['P c c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(57, 'P b c m', transformations)
space_groups[57] = sg
space_groups['P b c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(58, 'P n n m', transformations)
space_groups[58] = sg
space_groups['P n n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(59, 'P m m n :2', transformations)
space_groups[59] = sg
space_groups['P m m n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(60, 'P b c n', transformations)
space_groups[60] = sg
space_groups['P b c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(61, 'P b c a', transformations)
space_groups[61] = sg
space_groups['P b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(62, 'P n m a', transformations)
space_groups[62] = sg
space_groups['P n m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(63, 'C m c m', transformations)
space_groups[63] = sg
space_groups['C m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(64, 'C m c a', transformations)
space_groups[64] = sg
space_groups['C m c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(65, 'C m m m', transformations)
space_groups[65] = sg
space_groups['C m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(66, 'C c c m', transformations)
space_groups[66] = sg
space_groups['C c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(67, 'C m m a', transformations)
space_groups[67] = sg
space_groups['C m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(68, 'C c c a :2', transformations)
space_groups[68] = sg
space_groups['C c c a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(69, 'F m m m', transformations)
space_groups[69] = sg
space_groups['F m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(70, 'F d d d :2', transformations)
space_groups[70] = sg
space_groups['F d d d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(71, 'I m m m', transformations)
space_groups[71] = sg
space_groups['I m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(72, 'I b a m', transformations)
space_groups[72] = sg
space_groups['I b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(73, 'I b c a', transformations)
space_groups[73] = sg
space_groups['I b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(74, 'I m m a', transformations)
space_groups[74] = sg
space_groups['I m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(75, 'P 4', transformations)
space_groups[75] = sg
space_groups['P 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(76, 'P 41', transformations)
space_groups[76] = sg
space_groups['P 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(77, 'P 42', transformations)
space_groups[77] = sg
space_groups['P 42'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(78, 'P 43', transformations)
space_groups[78] = sg
space_groups['P 43'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(79, 'I 4', transformations)
space_groups[79] = sg
space_groups['I 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(80, 'I 41', transformations)
space_groups[80] = sg
space_groups['I 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(81, 'P -4', transformations)
space_groups[81] = sg
space_groups['P -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(82, 'I -4', transformations)
space_groups[82] = sg
space_groups['I -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(83, 'P 4/m', transformations)
space_groups[83] = sg
space_groups['P 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(84, 'P 42/m', transformations)
space_groups[84] = sg
space_groups['P 42/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(85, 'P 4/n :2', transformations)
space_groups[85] = sg
space_groups['P 4/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(86, 'P 42/n :2', transformations)
space_groups[86] = sg
space_groups['P 42/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(87, 'I 4/m', transformations)
space_groups[87] = sg
space_groups['I 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(88, 'I 41/a :2', transformations)
space_groups[88] = sg
space_groups['I 41/a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(89, 'P 4 2 2', transformations)
space_groups[89] = sg
space_groups['P 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(90, 'P 4 21 2', transformations)
space_groups[90] = sg
space_groups['P 4 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(91, 'P 41 2 2', transformations)
space_groups[91] = sg
space_groups['P 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(92, 'P 41 21 2', transformations)
space_groups[92] = sg
space_groups['P 41 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(93, 'P 42 2 2', transformations)
space_groups[93] = sg
space_groups['P 42 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(94, 'P 42 21 2', transformations)
space_groups[94] = sg
space_groups['P 42 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(95, 'P 43 2 2', transformations)
space_groups[95] = sg
space_groups['P 43 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(96, 'P 43 21 2', transformations)
space_groups[96] = sg
space_groups['P 43 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(97, 'I 4 2 2', transformations)
space_groups[97] = sg
space_groups['I 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(98, 'I 41 2 2', transformations)
space_groups[98] = sg
space_groups['I 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(99, 'P 4 m m', transformations)
space_groups[99] = sg
space_groups['P 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(100, 'P 4 b m', transformations)
space_groups[100] = sg
space_groups['P 4 b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(101, 'P 42 c m', transformations)
space_groups[101] = sg
space_groups['P 42 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(102, 'P 42 n m', transformations)
space_groups[102] = sg
space_groups['P 42 n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(103, 'P 4 c c', transformations)
space_groups[103] = sg
space_groups['P 4 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(104, 'P 4 n c', transformations)
space_groups[104] = sg
space_groups['P 4 n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(105, 'P 42 m c', transformations)
space_groups[105] = sg
space_groups['P 42 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(106, 'P 42 b c', transformations)
space_groups[106] = sg
space_groups['P 42 b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(107, 'I 4 m m', transformations)
space_groups[107] = sg
space_groups['I 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(108, 'I 4 c m', transformations)
space_groups[108] = sg
space_groups['I 4 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(109, 'I 41 m d', transformations)
space_groups[109] = sg
space_groups['I 41 m d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(110, 'I 41 c d', transformations)
space_groups[110] = sg
space_groups['I 41 c d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(111, 'P -4 2 m', transformations)
space_groups[111] = sg
space_groups['P -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(112, 'P -4 2 c', transformations)
space_groups[112] = sg
space_groups['P -4 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(113, 'P -4 21 m', transformations)
space_groups[113] = sg
space_groups['P -4 21 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(114, 'P -4 21 c', transformations)
space_groups[114] = sg
space_groups['P -4 21 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(115, 'P -4 m 2', transformations)
space_groups[115] = sg
space_groups['P -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(116, 'P -4 c 2', transformations)
space_groups[116] = sg
space_groups['P -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(117, 'P -4 b 2', transformations)
space_groups[117] = sg
space_groups['P -4 b 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(118, 'P -4 n 2', transformations)
space_groups[118] = sg
space_groups['P -4 n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(119, 'I -4 m 2', transformations)
space_groups[119] = sg
space_groups['I -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(120, 'I -4 c 2', transformations)
space_groups[120] = sg
space_groups['I -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(121, 'I -4 2 m', transformations)
space_groups[121] = sg
space_groups['I -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(122, 'I -4 2 d', transformations)
space_groups[122] = sg
space_groups['I -4 2 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(123, 'P 4/m m m', transformations)
space_groups[123] = sg
space_groups['P 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(124, 'P 4/m c c', transformations)
space_groups[124] = sg
space_groups['P 4/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(125, 'P 4/n b m :2', transformations)
space_groups[125] = sg
space_groups['P 4/n b m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(126, 'P 4/n n c :2', transformations)
space_groups[126] = sg
space_groups['P 4/n n c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(127, 'P 4/m b m', transformations)
space_groups[127] = sg
space_groups['P 4/m b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(128, 'P 4/m n c', transformations)
space_groups[128] = sg
space_groups['P 4/m n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(129, 'P 4/n m m :2', transformations)
space_groups[129] = sg
space_groups['P 4/n m m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(130, 'P 4/n c c :2', transformations)
space_groups[130] = sg
space_groups['P 4/n c c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(131, 'P 42/m m c', transformations)
space_groups[131] = sg
space_groups['P 42/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(132, 'P 42/m c m', transformations)
space_groups[132] = sg
space_groups['P 42/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(133, 'P 42/n b c :2', transformations)
space_groups[133] = sg
space_groups['P 42/n b c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(134, 'P 42/n n m :2', transformations)
space_groups[134] = sg
space_groups['P 42/n n m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(135, 'P 42/m b c', transformations)
space_groups[135] = sg
space_groups['P 42/m b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(136, 'P 42/m n m', transformations)
space_groups[136] = sg
space_groups['P 42/m n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(137, 'P 42/n m c :2', transformations)
space_groups[137] = sg
space_groups['P 42/n m c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(138, 'P 42/n c m :2', transformations)
space_groups[138] = sg
space_groups['P 42/n c m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(139, 'I 4/m m m', transformations)
space_groups[139] = sg
space_groups['I 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(140, 'I 4/m c m', transformations)
space_groups[140] = sg
space_groups['I 4/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(141, 'I 41/a m d :2', transformations)
space_groups[141] = sg
space_groups['I 41/a m d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(142, 'I 41/a c d :2', transformations)
space_groups[142] = sg
space_groups['I 41/a c d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(143, 'P 3', transformations)
space_groups[143] = sg
space_groups['P 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(144, 'P 31', transformations)
space_groups[144] = sg
space_groups['P 31'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(145, 'P 32', transformations)
space_groups[145] = sg
space_groups['P 32'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(146, 'R 3 :H', transformations)
space_groups[146] = sg
space_groups['R 3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(147, 'P -3', transformations)
space_groups[147] = sg
space_groups['P -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(148, 'R -3 :H', transformations)
space_groups[148] = sg
space_groups['R -3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(149, 'P 3 1 2', transformations)
space_groups[149] = sg
space_groups['P 3 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(150, 'P 3 2 1', transformations)
space_groups[150] = sg
space_groups['P 3 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(151, 'P 31 1 2', transformations)
space_groups[151] = sg
space_groups['P 31 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(152, 'P 31 2 1', transformations)
space_groups[152] = sg
space_groups['P 31 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(153, 'P 32 1 2', transformations)
space_groups[153] = sg
space_groups['P 32 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(154, 'P 32 2 1', transformations)
space_groups[154] = sg
space_groups['P 32 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(155, 'R 3 2 :H', transformations)
space_groups[155] = sg
space_groups['R 3 2 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(156, 'P 3 m 1', transformations)
space_groups[156] = sg
space_groups['P 3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(157, 'P 3 1 m', transformations)
space_groups[157] = sg
space_groups['P 3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(158, 'P 3 c 1', transformations)
space_groups[158] = sg
space_groups['P 3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(159, 'P 3 1 c', transformations)
space_groups[159] = sg
space_groups['P 3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(160, 'R 3 m :H', transformations)
space_groups[160] = sg
space_groups['R 3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(161, 'R 3 c :H', transformations)
space_groups[161] = sg
space_groups['R 3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(162, 'P -3 1 m', transformations)
space_groups[162] = sg
space_groups['P -3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(163, 'P -3 1 c', transformations)
space_groups[163] = sg
space_groups['P -3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(164, 'P -3 m 1', transformations)
space_groups[164] = sg
space_groups['P -3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(165, 'P -3 c 1', transformations)
space_groups[165] = sg
space_groups['P -3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(166, 'R -3 m :H', transformations)
space_groups[166] = sg
space_groups['R -3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(167, 'R -3 c :H', transformations)
space_groups[167] = sg
space_groups['R -3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(168, 'P 6', transformations)
space_groups[168] = sg
space_groups['P 6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(169, 'P 61', transformations)
space_groups[169] = sg
space_groups['P 61'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(170, 'P 65', transformations)
space_groups[170] = sg
space_groups['P 65'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(171, 'P 62', transformations)
space_groups[171] = sg
space_groups['P 62'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(172, 'P 64', transformations)
space_groups[172] = sg
space_groups['P 64'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(173, 'P 63', transformations)
space_groups[173] = sg
space_groups['P 63'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(174, 'P -6', transformations)
space_groups[174] = sg
space_groups['P -6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(175, 'P 6/m', transformations)
space_groups[175] = sg
space_groups['P 6/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(176, 'P 63/m', transformations)
space_groups[176] = sg
space_groups['P 63/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(177, 'P 6 2 2', transformations)
space_groups[177] = sg
space_groups['P 6 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(178, 'P 61 2 2', transformations)
space_groups[178] = sg
space_groups['P 61 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(179, 'P 65 2 2', transformations)
space_groups[179] = sg
space_groups['P 65 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(180, 'P 62 2 2', transformations)
space_groups[180] = sg
space_groups['P 62 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(181, 'P 64 2 2', transformations)
space_groups[181] = sg
space_groups['P 64 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(182, 'P 63 2 2', transformations)
space_groups[182] = sg
space_groups['P 63 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(183, 'P 6 m m', transformations)
space_groups[183] = sg
space_groups['P 6 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(184, 'P 6 c c', transformations)
space_groups[184] = sg
space_groups['P 6 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(185, 'P 63 c m', transformations)
space_groups[185] = sg
space_groups['P 63 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(186, 'P 63 m c', transformations)
space_groups[186] = sg
space_groups['P 63 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(187, 'P -6 m 2', transformations)
space_groups[187] = sg
space_groups['P -6 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(188, 'P -6 c 2', transformations)
space_groups[188] = sg
space_groups['P -6 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(189, 'P -6 2 m', transformations)
space_groups[189] = sg
space_groups['P -6 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(190, 'P -6 2 c', transformations)
space_groups[190] = sg
space_groups['P -6 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(191, 'P 6/m m m', transformations)
space_groups[191] = sg
space_groups['P 6/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(192, 'P 6/m c c', transformations)
space_groups[192] = sg
space_groups['P 6/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(193, 'P 63/m c m', transformations)
space_groups[193] = sg
space_groups['P 63/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(194, 'P 63/m m c', transformations)
space_groups[194] = sg
space_groups['P 63/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(195, 'P 2 3', transformations)
space_groups[195] = sg
space_groups['P 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(196, 'F 2 3', transformations)
space_groups[196] = sg
space_groups['F 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(197, 'I 2 3', transformations)
space_groups[197] = sg
space_groups['I 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(198, 'P 21 3', transformations)
space_groups[198] = sg
space_groups['P 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(199, 'I 21 3', transformations)
space_groups[199] = sg
space_groups['I 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(200, 'P m -3', transformations)
space_groups[200] = sg
space_groups['P m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(201, 'P n -3 :2', transformations)
space_groups[201] = sg
space_groups['P n -3 :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(202, 'F m -3', transformations)
space_groups[202] = sg
space_groups['F m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, 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]) | numpy.array |
from osgeo import gdal
import math
import matplotlib.pyplot as plt
import numpy as np
import os
from osgeo import gdal_array
import pandas as pd
import uuid
import warnings
from .pipesegment import PipeSegment, LoadSegment, MergeSegment
class Image:
def __init__(self, data, name='image', metadata={}):
self.name = name
self.metadata = metadata
self.set_data(data)
def set_data(self, data):
if isinstance(data, np.ndarray) and data.ndim == 2:
data = np.expand_dims(data, axis=0)
self.data = data
def __str__(self):
if self.data.ndim < 3:
raise Exception('! Image data has too few dimensions.')
metastring = str(self.metadata)
if len(metastring)>400:
metastring = metastring[:360] + '...'
return '%s: %d bands, %dx%d, %s, %s' % (self.name,
*np.shape(self.data),
str(self.data.dtype),
metastring)
class Identity(PipeSegment):
"""
This class is an alias for the PipeSegment base class to emphasize
its role as the identity element.
"""
pass
class LoadImageFromDisk(LoadSegment):
"""
Load an image from the file system using GDAL, so it can be fed
into subsequent PipeSegments.
"""
def __init__(self, pathstring, name=None, verbose=False):
super().__init__()
self.pathstring = pathstring
self.name = name
self.verbose = verbose
def load(self):
return self.load_from_disk(self.pathstring, self.name, self.verbose)
def load_from_disk(self, pathstring, name=None, verbose=False):
# Use GDAL to open image file
dataset = gdal.Open(pathstring)
if dataset is None:
raise Exception('! Image file ' + pathstring + ' not found.')
data = dataset.ReadAsArray()
if data.ndim == 2:
data = np.expand_dims(data, axis=0)
metadata = {
'geotransform': dataset.GetGeoTransform(),
'projection_ref': dataset.GetProjectionRef(),
'gcps': dataset.GetGCPs(),
'gcp_projection': dataset.GetGCPProjection(),
'meta': dataset.GetMetadata()
}
metadata['band_meta'] = [dataset.GetRasterBand(band).GetMetadata()
for band in range(1, dataset.RasterCount+1)]
if name is None:
name = os.path.splitext(os.path.split(pathstring)[1])[0]
dataset = None
# Create an Image-class object, and return it
imageobj = Image(data, name, metadata)
if verbose:
print(imageobj)
return imageobj
class LoadImageFromMemory(LoadSegment):
"""
Points to an 'Image'-class image so it can be fed
into subsequent PipeSegments.
"""
def __init__(self, imageobj, name=None, verbose=False):
super().__init__()
self.imageobj = imageobj
self.name = name
self.verbose = verbose
def load(self):
return self.load_from_memory(self.imageobj, self.name, self.verbose)
def load_from_memory(self, imageobj, name=None, verbose=False):
if type(imageobj) is not Image:
raise Exception('! Invalid input type in LoadImageFromMemory.')
if name is not None:
imageobj.name = name
if verbose:
print(imageobj)
return(imageobj)
class LoadImage(LoadImageFromDisk, LoadImageFromMemory):
"""
Makes an image available to subsequent PipeSegments, whether the image
is in the filesystem (in which case 'imageinput' is the path) or an
Image-class variable (in which case 'imageinput' is the variable name).
"""
def __init__(self, imageinput, name=None, verbose=False):
PipeSegment.__init__(self)
self.imageinput = imageinput
self.name = name
self.verbose = verbose
def load(self):
if type(self.imageinput) is Image:
return self.load_from_memory(self.imageinput, self.name, self.verbose)
elif type(self.imageinput) in (str, np.str_):
return self.load_from_disk(self.imageinput, self.name, self.verbose)
else:
raise Exception('! Invalid input type in LoadImage.')
class SaveImage(PipeSegment):
"""
Save an image to disk using GDAL.
"""
def __init__(self, pathstring, driver='GTiff', return_image=True,
save_projection=True, save_metadata=True, no_data_value=None):
super().__init__()
self.pathstring = pathstring
self.driver = driver
self.return_image = return_image
self.save_projection = save_projection
self.save_metadata = save_metadata
self.no_data_value = no_data_value
def transform(self, pin):
# Save image to disk
driver = gdal.GetDriverByName(self.driver)
datatype = gdal_array.NumericTypeCodeToGDALTypeCode(pin.data.dtype)
if datatype is None:
if pin.data.dtype in (bool, np.dtype('bool')):
datatype = gdal.GDT_Byte
else:
warnings.warn('! SaveImage did not find data type match; saving as float.')
datatype = gdal.GDT_Float32
dataset = driver.Create(self.pathstring, pin.data.shape[2], pin.data.shape[1], pin.data.shape[0], datatype)
for band in range(pin.data.shape[0]):
bandptr = dataset.GetRasterBand(band+1)
bandptr.WriteArray(pin.data[band, :, :])
if isinstance(self.no_data_value, str) \
and self.no_data_value.lower() == 'nan':
bandptr.SetNoDataValue(math.nan)
elif self.no_data_value is not None:
bandptr.SetNoDataValue(self.no_data_value)
bandptr.FlushCache()
if self.save_projection:
#First determine which projection system, if any, is used
proj_lens = [0, 0]
proj_keys = ['projection_ref', 'gcp_projection']
for i, proj_key in enumerate(proj_keys):
if proj_key in pin.metadata.keys():
proj_lens[i] = len(pin.metadata[proj_key])
if proj_lens[0] > 0 and proj_lens[0] >= proj_lens[1]:
dataset.SetGeoTransform(pin.metadata['geotransform'])
dataset.SetProjection(pin.metadata['projection_ref'])
elif proj_lens[1] > 0 and proj_lens[1] >= proj_lens[0]:
dataset.SetGCPs(pin.metadata['gcps'],
pin.metadata['gcp_projection'])
if self.save_metadata and 'meta' in pin.metadata.keys():
dataset.SetMetadata(pin.metadata['meta'])
dataset.FlushCache()
# Optionally return image
if self.driver.lower() == 'mem':
return dataset
elif self.return_image:
return pin
else:
return None
class ShowImage(PipeSegment):
"""
Display an image using matplotlib.
"""
def __init__(self, show_text=False, show_image=True, cmap='gray',
vmin=None, vmax=None, bands=None, caption=None,
width=None, height=None):
super().__init__()
self.show_text = show_text
self.show_image = show_image
self.cmap = cmap
self.vmin = vmin
self.vmax = vmax
self.bands = bands
self.caption = caption
self.width = width
self.height = height
def transform(self, pin):
if self.caption is not None:
print(self.caption)
if self.show_text:
print(pin)
if self.show_image:
# Select data, and format it for matplotlib
if self.bands is None:
image_formatted = pin.data
else:
image_formatted = pin.data[self.bands]
pyplot_formatted = np.squeeze(np.moveaxis(image_formatted, 0, -1))
if np.ndim(pyplot_formatted)==3 and self.vmin is not None and self.vmax is not None:
pyplot_formatted = np.clip((pyplot_formatted - self.vmin) / (self.vmax - self.vmin), 0., 1.)
# Select image size
if self.height is None and self.width is None:
rc = {}
elif self.height is None and self.width is not None:
rc = {'figure.figsize': [self.width, self.width]}
elif self.height is not None and self.width is None:
rc = {'figure.figsize': [self.height, self.height]}
else:
rc = {'figure.figsize': [self.width, self.height]}
# Show image
with plt.rc_context(rc):
plt.imshow(pyplot_formatted, cmap=self.cmap,
vmin=self.vmin, vmax=self.vmax)
plt.show()
return pin
class ImageStats(PipeSegment):
"""
Calculate descriptive statististics about an image
"""
def __init__(self, print_desc=True, print_props=True, return_image=True, return_props=False, median=True, caption=None):
super().__init__()
self.print_desc = print_desc
self.print_props = print_props
self.return_image = return_image
self.return_props = return_props
self.median = median
self.caption = caption
def transform(self, pin):
if self.caption is not None:
print(self.caption)
if self.print_desc:
print(pin)
print()
props = pd.DataFrame({
'min': np.nanmin(pin.data, (1,2)),
'max': np.nanmax(pin.data, (1,2)),
'mean': np.nanmean(pin.data, (1,2)),
'std': np.nanstd(pin.data, (1,2)),
'pos': np.count_nonzero(np.nan_to_num(pin.data, nan=-1.)>0, (1,2)),
'zero': np.count_nonzero(pin.data==0, (1,2)),
'neg': np.count_nonzero( | np.nan_to_num(pin.data, nan=1.) | numpy.nan_to_num |
import numpy as np
import array
import os, sys
import re
import time
import multiprocessing
import h5py
import logging
from astropy.table import Table, Column
from astropy import units as u
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-p","--params", type=str,
help = "Parameter file")
parser.add_argument("-q", "--quiet", help = "Suppress extra outputs",
action = "store_true")
args = parser.parse_args()
quiet = args.quiet
params_root = re.split(".py", args.params)[0]
if os.path.isfile(params_root+".pyc"):
os.remove(params_root+".pyc")
import importlib
try:
params = importlib.import_module(params_root)
print('Successfully loaded "{0}" as params'.format(args.params))
importlib.reload(params)
except:
print('Failed to load "{0}" as params'.format(args.params))
raise
if quiet:
quietprint = lambda *a: None
else:
def quietprint(*args):
for arg in args:
print(arg, end=' ')
print()
# Fitting function definition for later use by Processess
def galaxyFit(inputQueue, printQueue, printlock):
for gal in iter(inputQueue.get, 'STOP'):
j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift
flux_obs = obs[gal,:]
flux_err = obs_err[gal,:]
#flux_obs[fo <= 0.] = 0. # Set negative fluxes to zero
I = np.where(flux_err > 0.)[0] # Find bands with no observation
if len(I) == 0:
if include_rest:
M_scaled = np.ones(len(fo)) * -99.
restframe_output = ' '.join(M_scaled.astype('str'))
output_string = '{0} {1} {2} {3} {4} {5} {6} {7}' \
' {8} {9} {10} {11} {12} {13} {14} {15} {16}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99, -99, -99,-99,len(I),-99,z[j],restframe_output,'\n')
else:
output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99,-99, -99,-99,len(I),-99,'\n')
printQueue.put(output_string)
continue
flux_obs = flux_obs[I] # and exclude from fit
flux_err = flux_err[I]
flux_models = f[j,I,:]
tot_err = np.sqrt(flux_err**2 + (0.1*flux_obs)**2)
top = 0.
bottom = 0.
for i in range(len(flux_obs)):
top += (flux_models[i,:]*flux_obs[i])/(tot_err[i]**2)
bottom += (flux_models[i,:]**2)/(tot_err[i]**2)
scale = top/bottom
scale = np.reshape(scale, (n_metal, n_tg, n_tau, n_tauv, n_fesc))
chisq = 0.
for i in range(len(flux_obs)):
chisq += ((np.abs(scale*flux_models[i,:]-flux_obs[i])**2)/(flux_err[i])**2)
chimin, minind = np.nanmin(chisq), np.nanargmin(chisq)
if np.isinf(chimin) or np.isnan(minind):
if include_rest:
M_scaled = np.ones(len(flux_obs)) * -99.
restframe_output = ' '.join(M_scaled.astype('str'))
output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14} {15} {16}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99, -99, -99,-99,len(I),-99,z[j],restframe_output,'\n')
else:
output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99,-99, -99,-99,len(I),-99,'\n')
printQueue.put(output_string)
continue
#Find the coordinate of the model with the bestfit mass
mi, tgi, ti, tvi, fi = np.unravel_index(minind,
(n_metal, n_tg,
n_tau, n_tauv, n_fesc))
Bestfit_Mass = np.log10(scale[mi, tgi, ti, tvi, fi]*flux_corr)
Bestfit_SFR = (scale[mi, tgi, ti, tvi, fi] *
SFR[mi, tgi, ti, tvi, fi]*flux_corr)
#Bestfit_Beta = beta[tgi,tvi,ti,mi]
Bestfit_Beta = -99.
#Scale the observed tot_mag band of the template to be the same as the observed tot_mag band of the galaxy
#Convert the templates so they are no longer units of per stellar mass
F_rest = f[0,:]*scale[mi, tgi, ti, tvi, fi]*flux_corr
restframeMags = 23.9 - 2.5*np.log10(F_rest)
#UV_rest = UV_flux[0]*scale[tgi,tvi,ti,mi]*flux_corr
#restframeMUV = 23.9 - 2.5*np.log10(UV_rest)
M_scaled = restframeMags[:, mi, tgi, ti, tvi, fi]
#MUV_scaled = restframeMUV[tgi,tvi,ti,mi]
MUV_scaled = -99.
if np.isnan(Bestfit_Mass) or np.isinf(chimin):
Bestfit_Mass = -99
#M_scaled[:] = -99
tgs = -99
tvs = -99
taus = -99
mis = -99
escape_fraction = -99
else:
tgs = tg[tgi]/1e9
tvs = tv[tvi]
taus = tau[ti]
mis = metallicities[mi]
escape_fraction = fesc[fi]
printlock.acquire()
print('{0:6d} {1:8d} {2:>5.2f} {3:>7.2f} {4:>8.1f} {5:>8.3f} {6:>5.1f} {7:>8.2f} {8:>4.2f} {9:>5.2f}'.format(gal+1,ID[gal], zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis, | np.log10(Bestfit_SFR) | numpy.log10 |
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 1 13:37:29 2018
Class for implementing the scores for the composition UI and also the display image
with all the scores@author: <NAME>
"""
import cv2
import numpy as np
import itertools
from scipy.spatial import distance as dist
from skimage.measure import compare_ssim as ssim
from skimage.segmentation import slic
from skimage.segmentation import mark_boundaries
from skimage.util import img_as_float
import pandas as pd
from SaliencyMap import Saliency
class AutoScoreML ():
def __init__(self, extractedFeatures ):
self.df = pd.DataFrame(np.array(extractedFeatures))
def autoScoreML(self):
filepath_01 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoringApril30.csv'
filepath_02 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoringApril30_B.csv'
# =============================================================================
# filepath_03 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoring20apr2018_c.csv'
# filepath_04 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoring20apr2018_d.csv'
# filepath_05 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoring20apr2018_e.csv'
# filepath_06 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoring21apr2018_a.csv'
# filepath_07 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoring21apr2018_b.csv'
# filepath_08 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoring21apr2018_c.csv'
# filepath_09 = 'D:\\google drive\A PhD Project at Godlsmiths\ArtistSupervisionMaya\csv_file\scoring22apr2018_a.csv'
#
# =============================================================================
df_01 = pd.read_csv(filepath_01)
df_02 = pd.read_csv(filepath_02)
# =============================================================================
# df_03 = pd.read_csv(filepath_03)
# df_04 = pd.read_csv(filepath_04)
# df_05 = pd.read_csv(filepath_05)
# df_06 = pd.read_csv(filepath_06)
# df_07 = pd.read_csv(filepath_07)
# df_08 = pd.read_csv(filepath_08)
# df_09 = pd.read_csv(filepath_09)
# =============================================================================
frames= [df_01, df_02
#,df_03, df_04, df_05, df_06, df_07, df_08, df_09
]
df = pd.concat(frames)
df.reset_index(drop = True, inplace = True)
# drop the Null Value
df.dropna(inplace=True)
# select the features to use:
df.drop(['file', 'CompositionUserChoice'], axis=1, inplace=True)
X_train = df.drop('judge', axis = 1)
#y = df['judge']
X_test = self.df
from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)
# construct the ANN
# import the Keras Library and the required packages
import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
import os
# load json and create model
json_file = open("D:\\google drive\\A PhD Project at Godlsmiths\\ArtistSupervisionProject\\code\\classifier.json", 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("D:\\google drive\\A PhD Project at Godlsmiths\\ArtistSupervisionProject\\code\\classifier.h5")
print("Loaded model from disk")
# evaluate loaded model on test data
loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
# =============================================================================
# score = loaded_model.evaluate(X_test, y_test, verbose=0)
# print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))
# =============================================================================
# predict the test set results
# =============================================================================
y_pred = loaded_model.predict(X_test)
for y in y_pred:
res = np.argmax(y)
return res
class CompositionAnalysis ():
def __init__ (self, image = None, imagepath = None, mask = None):
if imagepath:
self.image = cv2.imread(imagepath)
self.imagepath = imagepath
else:
self.image = image
self.totalPixels = self.image.size
self.gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)
# =============================================================================
#
# def _borderCut(self, borderCutted):
#
#
# borderCutted[0:2, :] = 0
# borderCutted[-2:self.image.shape[0], :] = 0
# borderCutted[:, 0:2] = 0
# borderCutted[:, -2:self.image.shape[1]] = 0
#
# return borderCutted
# =============================================================================
def synthesisScores (self):
# return the display image for the UI
rows, cols, depth = self.image.shape
scoreSynthesisImg = np.zeros(self.image.shape, dtype="uint8")
# make solid color for the background
scoreSynthesisImg[:] = (218,218,218)
cv2.line(scoreSynthesisImg, ( int(self.image.shape[1] * 0.6), 20), ( int(self.image.shape[1] * 0.6),self.image.shape[0]), (50,50,140), 1)
cv2.line(scoreSynthesisImg, ( int(self.image.shape[1] * 0.75), 20), ( int(self.image.shape[1] * 0.75),self.image.shape[0]), (60,140,90), 1)
# collect the balance scores:
VisualBalanceScore = ( self.scoreVisualBalance + self.scoreHullBalance ) / 2
# corner balance and line
lineandcornerBalance = (self.cornersBalance + self.verticalandHorizBalanceMean ) / 2
# collect the rythm scores:
#asymmetry = (self.scoreFourier + self.verticalandHorizBalanceMean + self.ssimAsymmetry) / 3
asymmetry = (self.ssimAsymmetry +self.diagonalAsymmetry) / 2
scoreFourier = self.scoreFourier
# collect the gold proportion scores:
goldScore = self.scoreProportionAreaVsGoldenRatio
#score composition
scoreCompMax = max(self.diagonalasymmetryBalance, self.ScoreFourTriangleAdapted,self.ScoreBigTriangle)
ruleOfThird = self.ScoreRuleOfThird
# diagonal balance commposition
#diagonalasymmetryBalance = self.diagonalasymmetryBalance
# spiral
spiralScore = self.scoreSpiralGoldenRatio
# fractal
fractalScoreFromTarget = self.fractalScoreFromTarget
cv2.putText(scoreSynthesisImg, "Balance", (20, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[20:24, 10:int(VisualBalanceScore*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "Rule of Third", (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[35:39, 10:int(ruleOfThird*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "Composition Max", (20, 45), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[50:54, 10:int(scoreCompMax*cols*0.9)] = (120,60,120)
#cv2.putText(scoreSynthesisImg, "Diagonal Comp", (20, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
#scoreSynthesisImg[65:70, 10:int(diagonalasymmetryBalance*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "Spiral ", (20, 75), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[80:84, 10:int(spiralScore*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "Asymmetry ", (20, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[95:99, 10:int(asymmetry*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "Fourier ", (20, 105), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[110:114, 10:int(scoreFourier*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "CornerLinesBalance ", (20, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[125:129, 10:int(lineandcornerBalance*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "Proportion ", (20, 135), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[140:144, 10:int(goldScore*cols*0.9)] = (120,60,120)
cv2.putText(scoreSynthesisImg, "Fractal ", (20, 150), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
scoreSynthesisImg[155:159, 10:int(fractalScoreFromTarget*cols*0.9)] = (120,60,120)
#cv2.putText(scoreSynthesisImg, "Balance, asymmetry, Proportion, corner, spiral ", (20, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
#cv2.putText(scoreSynthesisImg, "Possible Comp: {} ".format(selectedComp), (10, 110), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (50, 50, 50), 1)
return scoreSynthesisImg
def fourierOnEdgesDisplay (self):
ImgImpRegionA, contours, keypoints = self._orbSegmentation ( maxKeypoints = 10000, edged = False, edgesdilateOpen = True, method = cv2.RETR_EXTERNAL)
cropped_img_lf = ImgImpRegionA[0:int(ImgImpRegionA.shape[0]), 0: int(ImgImpRegionA.shape[1] / 2) ]
cropped_img_rt = ImgImpRegionA[0:int(ImgImpRegionA.shape[0]), int(ImgImpRegionA.shape[1] / 2): ImgImpRegionA.shape[1] ]
#imgDftGray = self._returnDFT(ImgImpRegionA)
imgDftGraylf = self._returnDFT(cropped_img_lf)
imgDftGrayRt = self._returnDFT(cropped_img_rt)
# number of pixels in left and number of pixels in right
numberOfWhite_lf = (imgDftGraylf>0).sum()
numberOfWhite_Rt = (imgDftGrayRt > 0).sum()
# create the stiched picture
stichedDft = self.image.copy()
stichedDft = np.concatenate((imgDftGraylf,imgDftGrayRt ), axis = 1)
score = (abs(numberOfWhite_lf - numberOfWhite_Rt)) / (numberOfWhite_lf + numberOfWhite_Rt)
# to penalise the change in rithm
scoreFourier = np.exp(-score * self.image.shape[0]/2)
#cv2.putText(stichedDft, "diff: {:.3f}".format(score), (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 1)
self.scoreFourier = scoreFourier
return stichedDft, scoreFourier
def _returnDFT (self, imageForDft):
ImgImpRegionA = imageForDft
ImgImpRegionA = cv2.cvtColor(ImgImpRegionA, cv2.COLOR_BGR2GRAY)
#dft = cv2.dft(np.float32(self.gray),flags = cv2.DFT_COMPLEX_OUTPUT)
dft = cv2.dft(np.float32(ImgImpRegionA),flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))
cv2.normalize( magnitude_spectrum, magnitude_spectrum, alpha = 0 , beta = 1 , norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)
imgDftGray = np.array(magnitude_spectrum * 255, dtype = np.uint8)
meanThres = np.mean(imgDftGray)
_, imgDftGray = cv2.threshold(imgDftGray,meanThres, 255, cv2.THRESH_BINARY)
imgDftGray = cv2.cvtColor(imgDftGray, cv2.COLOR_GRAY2BGR)
return imgDftGray
def HOGcompute (self):
gray = self.gray.copy()
# h x w in pixels
cell_size = (8, 8)
# h x w in cells
block_size = (2, 2)
# number of orientation bins
nbins = 9
# Using OpenCV's HOG Descriptor
# winSize is the size of the image cropped to a multiple of the cell size
hog = cv2.HOGDescriptor(_winSize=(gray.shape[1] // cell_size[1] * cell_size[1],
gray.shape[0] // cell_size[0] * cell_size[0]),
_blockSize=(block_size[1] * cell_size[1],
block_size[0] * cell_size[0]),
_blockStride=(cell_size[1], cell_size[0]),
_cellSize=(cell_size[1], cell_size[0]),
_nbins=nbins)
# Create numpy array shape which we use to create hog_feats
n_cells = (gray.shape[0] // cell_size[0], gray.shape[1] // cell_size[1])
# We index blocks by rows first.
# hog_feats now contains the gradient amplitudes for each direction,
# for each cell of its group for each group. Indexing is by rows then columns.
hog_feats = hog.compute(gray).reshape(n_cells[1] - block_size[1] + 1,
n_cells[0] - block_size[0] + 1,
block_size[0], block_size[1], nbins).transpose((1, 0, 2, 3, 4))
# Create our gradients array with nbin dimensions to store gradient orientations
gradients = np.zeros((n_cells[0], n_cells[1], nbins))
# Create array of dimensions
cell_count = np.full((n_cells[0], n_cells[1], 1), 0, dtype=int)
# Block Normalization
for off_y in range(block_size[0]):
for off_x in range(block_size[1]):
gradients[off_y:n_cells[0] - block_size[0] + off_y + 1,
off_x:n_cells[1] - block_size[1] + off_x + 1] += \
hog_feats[:, :, off_y, off_x, :]
cell_count[off_y:n_cells[0] - block_size[0] + off_y + 1,
off_x:n_cells[1] - block_size[1] + off_x + 1] += 1
# Average gradients
gradients /= cell_count
# =============================================================================
# # Plot HOGs using Matplotlib
# # angle is 360 / nbins * direction
# print (gradients.shape)
#
# color_bins = 5
# plt.pcolor(gradients[:, :, color_bins])
# plt.gca().invert_yaxis()
# plt.gca().set_aspect('equal', adjustable='box')
# plt.colorbar()
# plt.show()
# cv2.destroyAllWindows()
# =============================================================================
return
def goldenProportionOnCnts(self, numberOfCnts = 25, method = cv2.RETR_CCOMP, minArea = 2):
edgedForProp = self._edgeDetection( scalarFactor = 1, meanShift = 0, edgesdilateOpen = True, kernel = 3)
goldenPropImg = self.image.copy()
# create the contours from the segmented image
ing2, contours, hierarchy = cv2.findContours(edgedForProp, method,
cv2.CHAIN_APPROX_SIMPLE)
innerCnts = []
for cnt, h in zip (contours, hierarchy[0]):
if h[2] == -1 :
innerCnts.append(cnt)
sortedContours = sorted(innerCnts, key = cv2.contourArea, reverse = True)
selectedContours = [cnt for cnt in sortedContours if cv2.contourArea(cnt) > minArea]
for cnt in selectedContours[0: numberOfCnts]:
cv2.drawContours(goldenPropImg, [cnt], -1, (255, 0, 255), 1)
# get all the ratio to check
ratioAreas = []
for index, cnt in enumerate(selectedContours[0: numberOfCnts]):
if index < len(selectedContours[0: numberOfCnts]) -1:
areaGoldenToCheck_previous = cv2.contourArea(selectedContours[index])
areaGoldenToCheck_next = cv2.contourArea(selectedContours[index + 1])
ratioArea = areaGoldenToCheck_previous / areaGoldenToCheck_next
ratioAreas.append(ratioArea)
meanAreaRatio = (np.mean(ratioAreas))
diffFromGoldenRatio = abs(1.618 - meanAreaRatio)
scoreProportionAreaVsGoldenRatio = | np.exp(-diffFromGoldenRatio) | numpy.exp |
"""Module for performing optimization over the stiefel manifold."""
import numpy as np
from scipy import linalg as linalg
import neuropy.temp as tmp
def optimize(ObjFn):
"""Perform optimization over the Stiefel manifold."""
# Parameters
max_iter = 1000
max_ls_iter = 500 # Maximum number of line search iterations
n_restarts = 5 # Number of random restarts to use
delta_b = 0.9 #
eps_f = 1e-10
# Get size of space -- it would be good to get these from the obj. fn.
x_dim = ObjFn.x_dim # Size of the data (high-d)
m_dim = ObjFn.m_dim # Size of the desired orthonormal space
# Initialize results
S = [] # List to store results for each random restart
for i in range(n_restarts):
# Initialize M (randomly)
A = | np.random.randn(x_dim, m_dim) | numpy.random.randn |
"""Define LineDetectorModel class."""
from typing import Callable, Dict, Tuple
import numpy as np
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from text_recognizer.datasets.iam_paragraphs_dataset import IamParagraphsDataset
from text_recognizer.models.base import Model
from text_recognizer.networks import fcn
_DATA_AUGMENTATION_PARAMS = {
"width_shift_range": 0.06,
"height_shift_range": 0.1,
"horizontal_flip": True,
"zoom_range": 0.1,
"fill_mode": "constant",
"cval": 0,
"shear_range": 3,
}
class LineDetectorModel(Model):
"""Model to detect lines of text in an image."""
def __init__(
self,
dataset_cls: type = IamParagraphsDataset,
network_fn: Callable = fcn,
dataset_args: Dict = None,
network_args: Dict = None,
):
"""Define the default dataset and network values for this model."""
super().__init__(dataset_cls, network_fn, dataset_args, network_args)
self.data_augmentor = ImageDataGenerator(**_DATA_AUGMENTATION_PARAMS)
self.batch_augment_fn = self.augment_batch
def loss(self): # pylint: disable=no-self-use
return "categorical_crossentropy"
def optimizer(self): # pylint: disable=no-self-use
return Adam(0.001 / 2)
def metrics(self): # pylint: disable=no-self-use
return None
def augment_batch(self, x_batch: np.ndarray, y_batch: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
"""Perform different random transformations on the whole batch of x, y samples."""
x_augment, y_augment = zip(*[self._augment_sample(x, y) for x, y in zip(x_batch, y_batch)])
return np.stack(x_augment, axis=0), np.stack(y_augment, axis=0)
def _augment_sample(self, x: np.ndarray, y: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
"""
Perform the same random image transformation on both x and y.
x is a 2d image of shape self.image_shape, but self.data_augmentor needs the channel image too.
"""
x_3d = | np.expand_dims(x, axis=-1) | numpy.expand_dims |
import logging
import bpy
import numpy as np
import kubric as kb
from kubric.core import materials
from kubric.renderer import Blender
from kubric.renderer.blender import Blender as KubricBlender
def get_proper_time(nums: int, times: np.ndarray) -> np.ndarray:
return np.concatenate([times] * nums)
logging.basicConfig(level="INFO") # < CRITICAL, ERROR, WARNING, INFO, DEBUG
world_matrix = {
"bunny": np.array(
(
(-1.0, 3.2584136988589307e-07, 0.0, 0.7087775468826294),
(-3.2584136988589307e-07, -1.0, 0.0, -1.2878063917160034),
(0.0, 0.0, 1.0, 0.0),
(0.0, 0.0, 0.0, 1.0),
),
),
"suzanne": np.array(
(
(1.0, 0.0, 0.0, -0.8567398190498352),
(0.0, 1.0, 0.0, 0.0),
(0.0, 0.0, 1.0, 0.0),
(0.0, 0.0, 0.0, 1.0),
)
),
"teapot": np.array(
(
(1.0, 0.0, 0.0, -0.9078792333602905),
(0.0, 1.0, 0.0, 1.2115877866744995),
(0.0, 0.0, 1.0, 0.0),
(0.0, 0.0, 0.0, 1.0),
)
),
"camera_train": np.array(
(
(1.0, 0.0, 0.0, 5.299691677093506),
(0.0, 1.0, 0.0, 2.9463558197021484),
(0.0, 0.0, 1.0, 4.46529483795166),
(0.0, 0.0, 0.0, 1.0),
)
),
"camera_valid": np.array(
(
(1.0, 0.0, 0.0, 5.299691677093506),
(0.0, 1.0, 0.0, 2.946355819702148),
(0.0, 0.0, 1.0, 3.7338485717773438),
(0.0, 0.0, 0.0, 1.0),
)
),
}
points = {
"bunny": np.array(
(
(
0.044713765382766724,
-1.0193415880203247,
0.8044384121894836,
1.0,
),
(
0.056191492825746536,
-0.31232786178588867,
0.8044384121894836,
1.0,
),
(0.0, 0.0, 0.0, 1.0),
(1.0, 0.0, 0.0, 1.0),
),
),
"suzanne": np.array(
(
(-1.0, 0.0, 0.0, 1.0),
(-0.2928931713104248, 2.9802322387695312e-08, 0.0, 1.0),
(0.0, 0.0, 0.0, 1.0),
(1.0, 0.0, 0.0, 1.0),
)
),
"teapot": np.array(
(
(
0.044713765382766724,
-1.0193415880203247,
0.8044384121894836,
1.0,
),
(
0.056191492825746536,
-0.31232786178588867,
0.8044384121894836,
1.0,
),
(0.0, 0.0, 0.0, 1.0),
(1.0, 0.0, 0.0, 1.0),
),
),
"camera": np.array(
(
(
0.11302351206541061,
-2.022498846054077,
-0.03925067186355591,
1.0,
),
(0.2999248206615448, -2.991917133331299, 0.536824643611908, 1.0),
(0.1303337812423706, -5.388640403747559, 0.32903361320495605, 1.0),
(0.3103395700454712, -6.060530662536621, -0.3085057735443115, 1.0),
),
),
}
def interpolate_position(
t: np.ndarray, handles: np.ndarray, world_matrix: np.ndarray
) -> np.ndarray:
p0, p1, p2, p3 = handles[:, np.newaxis]
t = t[..., np.newaxis]
r = 1 - t
out = r ** 3 * p0 + 3 * r ** 2 * t * p1 + 3 * r * t ** 2 * p2 + t ** 3 * p3
out = out / out[..., [-1]]
return (world_matrix @ out.T).T[..., :-1]
# --- create scene and attach a renderer and simulator
cam_frames = 20
obj_frames = 45
num_fake_cameras = 100
obj_xs = np.linspace(-np.pi / 2, np.pi / 2, obj_frames)
cam_xs = np.linspace(-np.pi / 2, np.pi / 2, cam_frames)
fake_xs = np.linspace(-np.pi / 2, np.pi / 2, num_fake_cameras)
train_times = {
"bunny": np.abs(np.cos(obj_xs * 3.33)),
"teapot": np.abs(np.cos(obj_xs * 3.33)),
"suzanne": np.abs(np.cos(obj_xs * 3.33)),
"camera": np.abs(np.cos(cam_xs) ** 2),
}
val_times = {
"bunny": np.abs(np.cos(obj_xs * 3.33)),
"teapot": np.abs(np.cos(obj_xs * 2.13)),
"suzanne": np.abs(np.cos(obj_xs * 4.11)),
"camera": np.abs(np.cos(cam_xs) ** 2),
}
def generate_single_dataset(times: np.ndarray, is_train: bool):
scene = kb.Scene(resolution=(256, 256))
scene.frame_end = cam_frames * obj_frames # < numbers of frames to render
scene.frame_rate = 24 # < rendering framerate
scene.ambient_illumination = kb.Color(0.05, 0.05, 0.05)
renderer = KubricBlender(scene)
# --- populate the scene with objects, lights, cameras
rng = np.random.RandomState(0)
wall_material = kb.FlatMaterial(color=kb.get_color("silver"))
floor_material = kb.FlatMaterial(color=kb.get_color("gray"))
bunny_material = kb.PrincipledBSDFMaterial(
color=kb.random_hue_color(rng=rng)
)
bunny = kb.FileBasedObject(
render_filename="objects/bunny.obj",
name="bunny",
scale=(4.89, 4.89, 4.89),
position=(0, -1, -0.47044),
quaternion=(0.0, 0.0, 0.707, 0.707),
material=bunny_material,
)
suzanne_material = kb.PrincipledBSDFMaterial(
color=kb.random_hue_color(rng=rng)
)
suzanne = kb.FileBasedObject(
render_filename="objects/suzanne.obj",
name="suzanne",
scale=(0.316, 0.316, 0.316),
position=(0, 0, 0.001821),
quaternion=(0.5, 0.5, 0.5, 0.5),
material=suzanne_material,
)
teapot_material = kb.PrincipledBSDFMaterial(
color=kb.random_hue_color(rng=rng)
)
teapot = kb.FileBasedObject(
render_filename="objects/teapot.obj",
name="teapot",
scale=(0.19, 0.19, 0.19),
position=(0, 1, -0.28363),
quaternion=(0.707, 0.70, 0.0, 0.0),
material=teapot_material,
)
scene += bunny
scene += suzanne
scene += teapot
scene += kb.Cube(
scale=(0.1, 100, 100),
position=(-4, 0, 0),
material=wall_material,
static=True,
background=True,
)
scene += kb.Cube(
scale=(100, 100, 0.01),
position=(0, 0, -0.7),
material=floor_material,
static=True,
background=True,
)
scene += kb.DirectionalLight(
name="sun", position=(4, 0, 3), look_at=(0, 0, 0), intensity=1.5
)
camera = kb.PerspectiveCamera(
name="camera", position=(0.64658, 0.81138, 0.50452), look_at=(0, 0, 0)
)
fake_camera = kb.PerspectiveCamera(
name="fake_camera",
position=(0.64658, 0.81138, 0.50452),
look_at=(0, 0, 0),
)
scene.camera = camera
suffix = "_train" if is_train else "_valid"
positions = {
"bunny": interpolate_position(
times["bunny"],
points["bunny"],
world_matrix["bunny"],
),
"teapot": interpolate_position(
times["teapot"],
points["teapot"],
world_matrix["teapot"],
),
"suzanne": interpolate_position(
times["suzanne"],
points["suzanne"],
world_matrix["suzanne"],
),
"camera": interpolate_position(
times["camera"],
points["camera"],
world_matrix[f"camera{suffix}"],
),
"fake_camera": interpolate_position(
np.abs(np.cos(fake_xs) ** 2),
points["camera"],
world_matrix[f"camera{suffix}"],
),
}
min_z = 10
for obj in ["bunny", "teapot", "suzanne"]:
min_z = positions[obj][..., -1].min()
for obj in ["bunny", "teapot", "suzanne"]:
if obj == "bunny":
positions[obj][..., -1] = min_z - 0.42538
elif obj == "teapot":
positions[obj][..., -1] = min_z - 0.22788
for obj in ["bunny", "suzanne"]:
positions[obj][..., 1] = positions[obj][..., 1].min()
for obj in ["teapot"]:
positions[obj][..., 1] = positions[obj][..., 1].max()
positions = {
"bunny": (
np.zeros_like(positions["bunny"])
+ np.mean(positions["bunny"], axis=0)
),
"teapot": (
np.zeros_like(positions["teapot"])
+ np.mean(positions["teapot"], axis=0)
),
"suzanne": (
np.zeros_like(positions["suzanne"])
+ | np.mean(positions["suzanne"], axis=0) | numpy.mean |
# Copyright 2021 The TensorFlow Recommenders 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 Cross layer."""
import os
import tempfile
import numpy as np
import tensorflow as tf
from tensorflow_recommenders.layers.dcn import Cross
class CrossTest(tf.test.TestCase):
# Do not use layer_test due to multiple inputs.
def test_full_matrix(self):
x0 = np.asarray([[0.1, 0.2, 0.3]]).astype(np.float32)
x = np.asarray([[0.4, 0.5, 0.6]]).astype(np.float32)
layer = Cross(projection_dim=None, kernel_initializer="ones")
output = layer(x0, x)
self.evaluate(tf.compat.v1.global_variables_initializer())
self.assertAllClose(np.asarray([[0.55, 0.8, 1.05]]), output)
def test_low_rank_matrix(self):
x0 = np.asarray([[0.1, 0.2, 0.3]]).astype(np.float32)
x = np.asarray([[0.4, 0.5, 0.6]]).astype(np.float32)
layer = Cross(projection_dim=1, kernel_initializer="ones")
output = layer(x0, x)
self.evaluate(tf.compat.v1.global_variables_initializer())
self.assertAllClose(np.asarray([[0.55, 0.8, 1.05]]), output)
def test_one_input(self):
x0 = np.asarray([[0.1, 0.2, 0.3]]).astype(np.float32)
layer = Cross(projection_dim=None, kernel_initializer="ones")
output = layer(x0)
self.evaluate(tf.compat.v1.global_variables_initializer())
self.assertAllClose(np.asarray([[0.16, 0.32, 0.48]]), output)
def test_invalid_proj_dim(self):
with self.assertRaisesRegexp(ValueError,
r"should be smaller than last_dim / 2"):
x0 = np.random.random((12, 5))
x = np.random.random((12, 5))
layer = Cross(projection_dim=6)
layer(x0, x)
def test_unsupported_input_dim(self):
with self.assertRaisesRegexp(ValueError,
r"dimension mismatch"):
x0 = np.random.random((12, 5))
x = np.random.random((12, 7))
layer = Cross()
layer(x0, x)
def test_invalid_diag_scale(self):
with self.assertRaisesRegexp(ValueError,
r"`diag_scale` should be non-negative"):
x0 = | np.asarray([[0.1, 0.2, 0.3]]) | numpy.asarray |
import sqlite3
from tqdm import tqdm
import numpy as np
import array
import sys
import math
import os
import multiprocessing
import shutil
import pandas as pd
from scipy.signal import savgol_filter
class Reload:
def __init__(self, path_pri, path_tra, fold):
self.path_pri = path_pri
self.path_tra = path_tra
self.fold = fold
def sqlite_read(self, path):
"""
python读取sqlite数据库文件
"""
mydb = sqlite3.connect(path) # 链接数据库
mydb.text_factory = lambda x: str(x, 'gbk', 'ignore')
cur = mydb.cursor() # 创建游标cur来执行SQL语句
# 获取表名
cur.execute("SELECT name FROM sqlite_master WHERE type='table'")
Tables = cur.fetchall() # Tables 为元组列表
# 获取表结构的所有信息
if path[-5:] == 'pridb':
cur.execute("SELECT * FROM {}".format(Tables[3][0]))
res = cur.fetchall()[-2][1]
elif path[-5:] == 'tradb':
cur.execute("SELECT * FROM {}".format(Tables[1][0]))
res = cur.fetchall()[-3][1]
return int(res)
def read_with_time(self, time):
conn_pri = sqlite3.connect(self.path_pri)
result_pri = conn_pri.execute(
"Select SetID, Time, Chan, Thr, Amp, RiseT, Dur, Eny, RMS, Counts, TRAI FROM view_ae_data")
chan_1, chan_2, chan_3, chan_4 = [], [], [], []
t = [[] for _ in range(len(time) - 1)]
N_pri = self.sqlite_read(self.path_pri)
for _ in tqdm(range(N_pri)):
i = result_pri.fetchone()
if i[-2] is not None and i[-2] >= 6 and i[-1] > 0:
for idx, chan in zip(np.arange(1, 5), [chan_1, chan_2, chan_3, chan_4]):
if i[2] == idx:
chan.append(i)
for j in range(len(t)):
if time[j] <= i[1] < time[j + 1]:
t[j].append(i)
break
break
chan_1 = np.array(chan_1)
chan_2 = np.array(chan_2)
chan_3 = np.array(chan_3)
chan_4 = np.array(chan_4)
return t, chan_1, chan_2, chan_3, chan_4
def read_vallen_data(self, lower=2, t_cut=float('inf'), mode='all'):
data_tra, data_pri, chan_1, chan_2, chan_3, chan_4 = [], [], [], [], [], []
if mode == 'all' or mode == 'tra only':
conn_tra = sqlite3.connect(self.path_tra)
result_tra = conn_tra.execute(
"Select Time, Chan, Thr, SampleRate, Samples, TR_mV, Data, TRAI FROM view_tr_data")
N_tra = self.sqlite_read(self.path_tra)
for _ in tqdm(range(N_tra), ncols=80):
i = result_tra.fetchone()
if i[0] > t_cut:
continue
data_tra.append(i)
if mode == 'all' or mode == 'pri only':
conn_pri = sqlite3.connect(self.path_pri)
result_pri = conn_pri.execute(
"Select SetID, Time, Chan, Thr, Amp, RiseT, Dur, Eny, RMS, Counts, TRAI FROM view_ae_data")
N_pri = self.sqlite_read(self.path_pri)
for _ in tqdm(range(N_pri), ncols=80):
i = result_pri.fetchone()
if i[0] > t_cut:
continue
if i[-2] is not None and i[-2] > lower and i[-1] > 0:
data_pri.append(i)
if i[2] == 1:
chan_1.append(i)
if i[2] == 2:
chan_2.append(i)
elif i[2] == 3:
chan_3.append(i)
elif i[2] == 4:
chan_4.append(i)
data_tra = sorted(data_tra, key=lambda x: x[-1])
data_pri = np.array(data_pri)
chan_1 = np.array(chan_1)
chan_2 = np.array(chan_2)
chan_3 = np.array(chan_3)
chan_4 = | np.array(chan_4) | numpy.array |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from torchvision import transforms
import numpy as np
import re
from PIL import Image
import sys
import cv2
def read_img(filename):
# Convert to RGB for scene flow finalpass data
# rand = np.random.uniform()
# img = np.array(transforms.functional.adjust_gamma(Image.open(filename).convert('RGB'),gamma=rand)).astype(np.float32)
img = np.array(Image.open(filename).convert('RGB')).astype(np.float32)
if np.random.random() < 0.5:
kernel = np.random.choice([3,5,7,9])
img = cv2.GaussianBlur(img,(kernel, kernel),0)
return img
def read_disp(filename, subset=False):
# Scene Flow dataset
if filename.endswith('pfm'):
# For finalpass and cleanpass, gt disparity is positive, subset is negative
disp = np.ascontiguousarray(_read_pfm(filename)[0])
if subset:
disp = -disp
# KITTI
elif filename.endswith('png'):
disp = _read_kitti_disp(filename)
elif filename.endswith('npy'):
disp = | np.load(filename) | numpy.load |
# This file is part of Patsy
# Copyright (C) 2012-2013 <NAME> <<EMAIL>>
# See file LICENSE.txt for license information.
# There are a number of unit tests in build.py, but this file contains more
# thorough tests of the overall design matrix building system. (These are
# still not exhaustive end-to-end tests, though -- for that see
# test_highlevel.py.)
from __future__ import print_function
import six
import numpy as np
from nose.tools import assert_raises
from patsy import PatsyError
from patsy.util import (atleast_2d_column_default,
have_pandas, have_pandas_categorical)
from patsy.desc import Term, INTERCEPT
from patsy.build import *
from patsy.categorical import C
from patsy.user_util import balanced, LookupFactor
from patsy.design_info import DesignMatrix
if have_pandas:
import pandas
def assert_full_rank(m):
m = atleast_2d_column_default(m)
if m.shape[1] == 0:
return True
u, s, v = np.linalg.svd(m)
rank = np.sum(s > 1e-10)
assert rank == m.shape[1]
def test_assert_full_rank():
assert_full_rank(np.eye(10))
assert_full_rank([[1, 0], [1, 0], [1, 0], [1, 1]])
assert_raises(AssertionError,
assert_full_rank, [[1, 0], [2, 0]])
assert_raises(AssertionError,
assert_full_rank, [[1, 2], [2, 4]])
assert_raises(AssertionError,
assert_full_rank, [[1, 2, 3], [1, 10, 100]])
# col1 + col2 = col3
assert_raises(AssertionError,
assert_full_rank, [[1, 2, 3], [1, 5, 6], [1, 6, 7]])
def make_termlist(*entries):
terms = []
for entry in entries:
terms.append(Term([LookupFactor(name) for name in entry]))
return terms
def check_design_matrix(mm, expected_rank, termlist, column_names=None):
assert_full_rank(mm)
assert set(mm.design_info.terms) == set(termlist)
if column_names is not None:
assert mm.design_info.column_names == column_names
assert mm.ndim == 2
assert mm.shape[1] == expected_rank
def make_matrix(data, expected_rank, entries, column_names=None):
termlist = make_termlist(*entries)
def iter_maker():
yield data
builders = design_matrix_builders([termlist], iter_maker)
matrices = build_design_matrices(builders, data)
matrix = matrices[0]
assert (builders[0].design_info.term_slices
== matrix.design_info.term_slices)
assert (builders[0].design_info.column_names
== matrix.design_info.column_names)
assert matrix.design_info.builder is builders[0]
check_design_matrix(matrix, expected_rank, termlist,
column_names=column_names)
return matrix
def test_simple():
data = balanced(a=2, b=2)
x1 = data["x1"] = np.linspace(0, 1, len(data["a"]))
x2 = data["x2"] = data["x1"] ** 2
m = make_matrix(data, 2, [["a"]], column_names=["a[a1]", "a[a2]"])
assert np.allclose(m, [[1, 0], [1, 0], [0, 1], [0, 1]])
m = make_matrix(data, 2, [[], ["a"]], column_names=["Intercept", "a[T.a2]"])
assert | np.allclose(m, [[1, 0], [1, 0], [1, 1], [1, 1]]) | numpy.allclose |
import numpy as np
from scipy import constants
# FIXME STILL HAS BUGS; DOES NOT GIVE CORRECT VALUES!
def getdedx(betagamma, thickness, density_correction=True, restricted=True, MP=False):
''' Thickness [um] '''
if restricted and not density_correction:
raise NotImplementedError(
'Restricted energy loss can only be calculated with density correction on')
# Some derivations of the input to simplify the formulars
betagamma2 = betagamma * betagamma
gamma = (betagamma2 + 1) ** 0.5 # Calculate gamma from betagamma squared
# Calculate beta from betagamma squared
beta = (1 - 1. / (1 + betagamma2)) ** 0.5
beta2 = beta * beta
assert np.allclose(beta, (1 - 1. / (gamma * gamma)) ** 0.5) # Cross check
z = 1 # Charge of incident particle [e]
mp = 938.27231 # mass of a proton [MeV/c**2]
re = 2.817940325 * 10 ** -13 # electron radius [cm]
Z = 14 # atomic number [#nucleons]
A = 28.0855 # atomic mass of silicon absorber [amu = g/mol]
Na = 6.0221415 * 10 ** 23 # avogrado number
me = 0.510998918 # mass of an electron [MeV/c**2]
I = 173 * 10 ** (-6) # mean excitation energy [MeV]
K = 4 * np.pi * Na * re ** 2 * me # constant(?) [MeV]
Alpha = 1 / 137.03599911 # fine structure constant
# Density correction parameters for silicon, from
# Atomic data and nuclear tables 30, 261-271 (1984)
Omega_p = 31.06 # plasma energy in silicon [eV]
C_d = -4.4351 # density correction parameter
A_d = 0.14921 # density correction parameter
M_d = 3.2546 # density correction parameter
X_0_d = 0.2014 # density correction parameter
X_1_d = 2.8715 # density correction parameter
# Restricted Eloss, thin absorbers correction parameters
# [MeV] for 200 um silicon from Nucl. Phys. B288 (1987) 681-716
T_cut = 19e-3
# MP Eloss, <NAME>
detector_density = 2.3290 # density of detector material [g cm**-3]
# material length [g/cm**2]
mat_length = thickness * 1e-4 * detector_density
j = 0.198 # parameter [no unit]
# Calculate dEdx
# Maximum energy transfer possible in single collision
Tmax = (2.0 * me * betagamma2) / \
(1.0 + 2.0 * gamma * (me / mp) + (me / mp) ** 2)
# dedx from semiempiric Bethe Bloch formular
if not density_correction and not restricted:
dedx = (-K * z ** 2 * Z) / (A * beta2) * \
(0.5 * np.log((2 * me * betagamma2 * Tmax) / I ** 2) - beta2)
return dedx
# dEdx with density effect (with silicon parameters)
# Density effect correction, from
# PDG 30. Passage of particles through matter
X = np.log(betagamma) # Derivation of the input to simplify the formular
# Calculate delta with three cases
# Else case: zero for X < X_0
delta = np.zeros_like(betagamma)
# Case X >= X1: 2*ln 10 * X - C
delta[X >= X_1_d] = 2 * np.log(10) * X[X >= X_1_d] + C_d
selection = | np.logical_and(X >= X_0_d, X < X_1_d) | numpy.logical_and |
import os
import time
import numpy as np
from .callback import Callback
from molecules.utils import open_h5
class SaveEmbeddingsCallback(Callback):
"""
Saves embeddings
"""
def __init__(self, out_dir,
interval=1,
sample_interval=20,
mpi_comm=None):
"""
Parameters
----------
out_dir : str
Directory to store output embedding files.
interval : int
Plots every interval epochs, default is once per epoch.
sample_interval : int
Plots every sample_interval'th point in the data set
mpi_comm : mpi communicator for distributed training
"""
super().__init__(interval, mpi_comm)
if self.is_eval_node:
os.makedirs(out_dir, exist_ok=True)
self.out_dir = out_dir
self.sample_interval = sample_interval
def on_validation_begin(self, epoch, logs):
self.sample_counter = 0
self.embeddings = []
self.rmsd = []
self.fnc = []
def on_validation_batch_end(self, batch, epoch, logs, mu=None,
rmsd=None, fnc=None, **kwargs):
if self.sample_interval == 0:
return
if epoch % self.interval != 0:
return
if (mu is None) or (rmsd is None) or (fnc is None):
return
# decide what to store
for idx in range(len(mu)):
if (self.sample_counter + idx) % self.sample_interval == 0:
# use a singleton slice to keep dimensions intact
self.embeddings.append(mu[idx:idx+1].detach().cpu().numpy())
self.rmsd.append(rmsd[idx:idx+1].detach().cpu().numpy())
self.fnc.append(fnc[idx:idx+1].detach().cpu().numpy())
# increase sample counter
self.sample_counter += len(mu)
def on_validation_end(self, epoch, logs):
if epoch % self.interval != 0:
return
# if the sample interval was too large, we should warn here and return
if not self.embeddings or not self.rmsd or not self.fnc:
print('Warning, not enough samples collected for tSNE, \
try to reduce sampling interval')
return
# prepare plot data
embeddings = np.concatenate(self.embeddings, axis=0).astype(np.float32)
rmsd = np.concatenate(self.rmsd, axis=0).astype(np.float32)
fnc = np.concatenate(self.fnc, axis=0).astype(np.float32)
# communicate if necessary
if self.comm is not None:
# gather data
embeddings_gather = self.comm.gather(embeddings, root=0)
rmsd_gather = self.comm.gather(rmsd, root=0)
fnc_gather = self.comm.gather(fnc, root=0)
# concat
if self.is_eval_node:
embeddings = np.concatenate(embeddings_gather, axis=0)
rmsd = np.concatenate(rmsd_gather, axis=0)
fnc = | np.concatenate(fnc_gather, axis=0) | numpy.concatenate |
import numpy as np
import math
import pandas as pd
class SVM:
def __init__(self, X, Y):
# load the data
self.X = X
self.Y = Y
self.example_num = self.X.shape[0] # len(self.X)
# init alpha and b
self.alpha = np.zeros(self.example_num)
self.b = 0
self.w = 0
# hyparamters
self.MAX_ITER_NUM = 100
# 惩罚参数，是个超参数。越大对误分类的惩罚越大。
self.C = 10 # TODO the C need to init the some method
self.tol = 1e-3 # 容忍度，越小说明对KKT条件越苛刻
self.E = np.zeros(self.example_num)
def rand_j(self, i, m):
"""
generate a index j of alpha2 different with i
:param i: the alpha i
:param m:
:return: j index
"""
j = np.random.randint(0, m)
while (j == i):
j = np.random.randint(0, m)
return j
def fxi(self, x_):
"""
f(x) function
:param X: the datasets
:param x_: the predict data
:return: the distance.
"""
# ans = self.alpha * self.Y * self.kernel(X, x_) + self.b
# w =0
# for i in range(self.example_num):
# w += self.alpha[i] * self.Y[i] * self.X[i]
# self.w = w
# ans = w.dot(x_.T) + self.b
# return ans
ans = 0
for i in range(self.example_num):
ans += self.alpha[i] * self.Y[i] * self.kernel(self.X[i], x_)
ans += self.b
return ans
def predict(self, x_):
# ans = self.w.dot(x_.T) + self.b
ans = self.fxi(x_)
return np.sign(ans)
def kernel(self, X1, X2, kernel_type='default', **kwargs):
# TODO 加入其他的kernel方法
if kernel_type == "default" or kernel_type == "linear":
return np.dot(X1, X2.T) # linear SVM
if kernel_type == "polynomial":
return | np.dot(X1, X2.T) | numpy.dot |
import sys
import os
sys.path.insert(0, os.path.abspath('..\\diffpy'))
import numpy as np
import pandas as pd
from scipy.optimize import curve_fit
from scipy.ndimage.interpolation import rotate
from scipy.spatial import ConvexHull
import msds as msds
def anomalous(x, D, alpha, dt):
# The anomalous diffusion model
return 4*D*(x*dt)**alpha
def anomModels(MSD, dt, skips=1):
# Calculates the anomalous diffusion model parameters for a single particle
# from its MSD profile over multiple timespans
# By default, fits the model to all possible MSD profiles of at least 10 frames
def anom(x, D, alpha):
return anomalous(x, D, alpha, dt=dt)
steps = MSD.shape[0] + 1
N = np.linspace(1, steps-1, steps-1)
alphas = np.zeros(steps-1)
Ds = np.zeros(steps-1)
for i in range(10, steps-1, skips):
ps, _ = curve_fit(anom, N[:i], MSD[:i], p0=[6,1])
Ds[i] = ps[0]
alphas[i] = ps[1]
return Ds, alphas
def anomModel(MSD, dt, frame=100):
# Calculates the anomalous diffusion model parameters for multiple
# particle trajectories. The user specifies up to which frame to include
# in the MSD trajectory to use in the model fit.
def anom(x, D, alpha):
return anomalous(x, D, alpha, dt=dt)
steps = MSD.shape[0] + 1
N = np.linspace(1, steps-1, steps-1)
ps, _ = curve_fit(anom, N[:frame], MSD[:frame], p0=[6,1])
D = ps[0]
alpha = ps[1]
return D, alpha
def anomModelN(MSD, dt, frame=100):
# Calculate the anomalous diffusion model parameters for multiple particle
# trajectories.
def anom(x, D, alpha):
return anomalous(x, D, alpha, dt=dt)
steps, N = MSD.shape
n = np.linspace(1, steps, steps)
# For arrays that contain NaNs
mask = MSD > -10000
cutoff = steps*np.average(mask, axis=0)
Ds = np.zeros(N)
alphas = np.zeros(N)
for i in range(N):
cut = int(cutoff[i])
if cut < frame:
frame = cut
ps, _ = curve_fit(anom, n[:frame], MSD[:frame, i], p0=[6,1])
Ds[i] = ps[0]
alphas[i] = ps[1]
return Ds, alphas
def anomModelsN(MSD, dt, skips=1):
# Calculate the anomalous diffusion model parameters for multiple particle
# trajectories over multiple MSD window frames.
def anom(x, D, alpha):
return anomalous(x, D, alpha, dt=dt)
steps, N = MSD.shape
n = np.linspace(1, steps, steps)
# For arrays that contain NaNs
mask = MSD > -10000
cutoff = steps*np.average(mask, axis=0)
Ds = np.zeros((steps, N))
alphas = np.zeros((steps, N))
for i in range(N):
for frame in range(10, steps, skips):
cut = int(cutoff[i])
if cut < frame:
frame = cut
ps, _ = curve_fit(anom, n[:frame], MSD[:frame, i], p0=[6,1])
Ds[frame, i] = ps[0]
alphas[frame, i] = ps[1]
return Ds, alphas
def asym(x, y):
# Calculates three asymmetry features based on the eigenvectors
# of the radius of gyration tensor for a single trajectory
# Calculuates the eigenvalues of the radius of gyration tensor
# This tensor is just the covariance matrix of the x, y coordinates
n = x.shape[0]
# Modified n for trajectories that have NaNs
mask = x > -10000
n = n*np.average(mask)
x, y = x[:int(n)], y[:int(n)]
eigs, vecs = np.linalg.eig(np.cov(x, y))
a1 = (eigs[0]**2 - eigs[1]**2)**2/(eigs[0]**2 + eigs[1]**2)**2
a2 = min(eigs)/max(eigs)
a3 = -np.log(1 - 0.5*(eigs[0] - eigs[1])**2/(eigs[0] + eigs[1])**2)
# kurtosis, which requires the eigenvectors
xi, yi = x.reshape((-1,1)), y.reshape((-1,1))
xy = np.concatenate((xi, yi), axis=1)
xp = np.dot(xy, vecs[:,0])
K = np.sum((xp - np.mean(xp))**4/np.std(xp)**4)/n
return [a1, a2, a3], eigs, vecs, K
def asyms(x, y):
steps, N = x.shape
a1, a2, a3, Ks = np.zeros(N), np.zeros(N), np.zeros(N), np.zeros(N)
for i in range(N):
a123, eigs, vecs, Ks[i] = asym(x[:, i], y[:, i])
a1[i], a2[i], a3[i] = a123[0], a123[1], a123[2]
return a1, a2, a3, Ks
def minBoundRect(x, y):
"""
Find the smallest bounding rectangle for a set of points.
Returns a set of points representing the corners of the bounding box.
:param points: an nx2 matrix of coordinates
:rval: an nx2 matrix of coordinates
"""
n = x.shape[0]
# Modified n for trajectories that have NaNs
mask = x > -10000
n = n*np.average(mask)
x, y = x[:int(n)], y[:int(n)]
points = np.concatenate((x.reshape((-1, 1)), y.reshape((-1, 1))), axis=1)
pi2 = np.pi/2.
# get the convex hull for the points
hull_points = points[ConvexHull(points).vertices]
# calculate edge angles
edges = np.zeros((len(hull_points)-1, 2))
edges = hull_points[1:] - hull_points[:-1]
angles = np.zeros((len(edges)))
angles = np.arctan2(edges[:, 1], edges[:, 0])
angles = np.abs(np.mod(angles, pi2))
angles = np.unique(angles)
# find rotation matrices
# XXX both work
rotations = np.vstack([
np.cos(angles),
np.cos(angles-pi2),
np.cos(angles+pi2),
np.cos(angles)]).T
# rotations = np.vstack([
# np.cos(angles),
# -np.sin(angles),
# np.sin(angles),
# np.cos(angles)]).T
rotations = rotations.reshape((-1, 2, 2))
# apply rotations to the hull
rot_points = np.dot(rotations, hull_points.T)
# find the bounding points
min_x = np.nanmin(rot_points[:, 0], axis=1)
max_x = np.nanmax(rot_points[:, 0], axis=1)
min_y = np.nanmin(rot_points[:, 1], axis=1)
max_y = np.nanmax(rot_points[:, 1], axis=1)
# find the box with the best area
areas = (max_x - min_x) * (max_y - min_y)
best_idx = np.argmin(areas)
# return the best box
x1 = max_x[best_idx]
x2 = min_x[best_idx]
y1 = max_y[best_idx]
y2 = min_y[best_idx]
r = rotations[best_idx]
rval = np.zeros((4, 2))
rval[0] = np.dot([x1, y2], r)
rval[1] = np.dot([x2, y2], r)
rval[2] = np.dot([x2, y1], r)
rval[3] = | np.dot([x1, y1], r) | numpy.dot |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 21 18:19:27 2020
@author: <NAME>
"""
import logging
import numpy as np
import pandas as pd
from numpy import linalg as LA
from numpy.core.umath_tests import inner1d
from scipy.spatial.transform import Rotation as R
from scipy.interpolate import Rbf
import sys
logger = logging.getLogger(__name__)
class Mesh_Def:
def __init__(self,args,aeroframeSettings,lattice):
"""
*_p : lattice points
*r_ p: lattice points reshaped array for ease of use
*_v : horseshoe vortex points
*r_v : horseshoe vortex points reshaped for ease of use
*_c : cell collocation points
*_n : normal vector directions
*_b : bound leg midpoints
f_a : final area of each individual panels
u_* : defomation of the given type of point. follows the same naming
pattern as for the previous 5 items
"""
self.args = args
self.aeroframeSettings = aeroframeSettings
self.lattice = lattice
# stores lattice shapes (only theses two are needed, the others are
# of identical shape)
self.s_p = lattice.p.shape
self.s_v = lattice.v.shape
self.s_c = lattice.c.shape
self.s_b = lattice.bound_leg_midpoints.shape
self.s_n = lattice.n.shape
# stores lattice intitial (i_) data
self.i_p = np.copy(lattice.p)
self.ir_p = self.i_p.reshape((self.s_p[0] * self.s_p[1], self.s_p[2]))
self.i_v = np.copy(lattice.v)
self.ir_v = self.i_v.reshape((self.s_v[0] * self.s_v[1], self.s_v[2]))
self.i_c = np.copy(lattice.c)
self.i_n = np.copy(lattice.n)
self.i_b = np.copy(lattice.bound_leg_midpoints)
# stores lattice final (f_) data
self.f_p = np.zeros([self.s_p[0], self.s_p[1], self.s_p[2]])
self.fr_p = np.zeros([self.s_p[0] * self.s_p[1], self.s_p[2]])
self.f_v = np.zeros([self.s_p[0], self.s_p[1], self.s_p[2]])
self.fr_v = np.zeros([self.s_p[0] * self.s_p[1], self.s_p[2]])
self.f_c = np.zeros([self.s_c[0] * self.s_c[1]])
self.f_n = np.zeros([self.s_c[0] * self.s_c[1]])
self.f_b = np.zeros([self.s_c[0] * self.s_c[1]])
self.f_a = np.zeros([self.s_c[0] * self.s_c[1]])
# Cells absolute y corrdinates (needed for testing and debug)
self.y_p = np.abs(self.ir_p[:,1])
self.y_v = np.abs(self.ir_v[:,1])
self.y_c = np.abs(self.i_c[:,1])
self.y_b = | np.abs(self.i_b[:,1]) | numpy.abs |
# coding=utf-8
# Copyright 2018 The Google AI Language Team 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.
"""Common utilities for data preprocessing."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import scipy.sparse as sp
def filter_sparse_rows(sp_mat, max_cols):
"""Filter rows of a CSR sparse matrix to retain upto max_cols."""
all_remove_idx = []
num_removed = np.zeros((sp_mat.indptr.shape[0] - 1,), dtype=np.int64)
for ii in range(sp_mat.shape[0]):
row_st = sp_mat.indptr[ii]
row_en = sp_mat.indptr[ii + 1]
my_scores = sp_mat.data[row_st:row_en]
if len(my_scores) > max_cols:
remove = | np.argpartition(-my_scores, max_cols) | numpy.argpartition |
import cv2
import warnings
import numpy as np
from tqdm import tqdm
from PIL import Image
from os import listdir
import skimage.io as io
import tensorflow as tf
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from os.path import join as pjoin
from skimage.filters import gaussian
from skimage.util import random_noise
from skimage.transform import rotate, AffineTransform, warp
warnings.filterwarnings('ignore')
def normalize(arr):
''' Function to scale an input array to [-1, 1]
arr : Array that is to be normalized
return: Normalized array'''
arr_min = arr.min()
arr_max = arr.max()
arr_range = arr_max - arr_min
scaled = np.array((arr - arr_min) / float(arr_range), dtype='f')
arr_new = -1 + (scaled * 2)
return arr_new
def section_and_masks_to_npy(line, low, high, image_type="plt"):
'''get section and mask from image folder and save it in npy format
line : "inlines"/"crosslines"
low & high : section number
image_type : "plt"/"PIL"
Returns : npy file'''
sections = []
masks = []
for i, filename in enumerate(listdir(line)):
if filename.split('.')[1] == 'tiff':
line_num = int((filename.split('.')[0]).split('_')[1])
if (line_num > low) and (line_num <= high):
if image_type == "plt":
seismic_section = plt.imread(pjoin(line, filename))[:, :, 0]
elif image_type == "PIL":
seismic_section = Image.open(pjoin(line, filename))
else:
'Unknown image type! possible input: ["plt", "PIL"]'
seismic_section = np.array(seismic_section)
seismic_section = normalize(seismic_section)
sections.append(seismic_section)
mask_filename = filename.split('.')[0] + '_mask.png'
seismic_facies = Image.open(pjoin('masks', mask_filename))
seismic_facies = np.array(seismic_facies)
masks.append(seismic_facies)
npy_sections = np.asarray(sections)
npy_masks = np.asarray(masks)
print("Section Shape\t:{0}\nMask Shape\t:{1}".format(npy_sections.shape, npy_masks.shape))
return npy_sections, npy_masks
def plot_section_mask(section, mask, vmin = None, vmax = None, figsize = (25, 8)):
'''Plot section and corresponding mask, works for both section based and patch based
section : Seismic Sections in 3D array
mask : Corresponding Mask
vmin, vmax : Normalize Section array between vmin, vmax value for visualization purpose'''
idx = np.random.randint(0, mask.shape[0], (20))
_, ax = plt.subplots(2, 20, figsize = figsize)
for i in range(len(ax[0])):
ax[0][i].imshow(mask[idx[i]], vmin = vmin, vmax = vmax)
ax[0][i].set_yticks([])
ax[0][i].set_xticks([])
ax[1][i].imshow(section[idx[i]])
ax[1][i].set_yticks([])
ax[1][i].set_xticks([])
plt.tight_layout()
def extract_patch(section, mask, stride = 50, patch = 99, padding = "VALID"):
'''Extract patch from section and mask array using TesorFlow
patch : size of patch to be extracted
Stride : stride of patch window
padding : Don't use "SAME" as it will pad with 0'''
images = section[:,:,:]
labels = mask[:,:,:]
images = np.expand_dims(images, axis=3)
labels = np.expand_dims(labels, axis=3)
patch_images = tf.image.extract_patches(images, (1,patch,patch,1), (1,stride,stride,1), (1,1,1,1), padding = padding, name=None)
patch_labels = tf.image.extract_patches(labels, (1,patch,patch,1), (1,stride,stride,1), (1,1,1,1), padding = padding, name=None)
patch_images = tf.reshape(patch_images, (-1,patch,patch)).numpy()
patch_labels = tf.reshape(patch_labels, (-1,patch,patch)).numpy()
print("Patch Images Shape\t:{0}\nPatch Masks Shape\t:{1}".format(patch_images.shape, patch_labels.shape))
return patch_images, patch_labels
def labels_conversion_canada_new(labels):
'''Converts unwanted labels (0, 5, 6, 7) to 255 and renames (1, 2, 3, 4) to (0, 1, 2, 3) for Penobscot dataset'''
labels = np.where(labels == 1, 255, labels)
labels = np.where(labels == 0, 255, labels)
labels = np.where(labels == 5, 255, labels)
labels = np.where(labels == 6, 255, labels)
labels = np.where(labels == 7, 255, labels)
labels = np.where(labels == 2, 0, labels)
labels = np.where(labels == 3, 1, labels)
labels = np.where(labels == 4, 2, labels)
return labels
def labels_conversion_canada_new_class_1_2_from_sections(labels):
'''Converts unwanted labels (0, 5, 6, 7) to 255 and renames (1, 2, 3, 4) to (0, 1, 2, 3) for Penobscot dataset'''
labels = np.where(labels == 1, 255, labels)
labels = | np.where(labels == 2, 255, labels) | numpy.where |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.