prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
# coding: utf-8
# # Imaging and deconvolution demonstration
# This script makes a fake data set and then deconvolves it. Finally the full and residual visibility are plotted.
# In[1]:
import os
import sys
sys.path.append(os.path.join('..', '..'))
from rascil.data_models.parameters import rascil_path
results_dir = rascil_path('test_results')
from matplotlib import pylab
pylab.rcParams['figure.figsize'] = (8.0, 8.0)
pylab.rcParams['image.cmap'] = 'rainbow'
import numpy
from astropy.coordinates import SkyCoord, EarthLocation, AltAz
from astropy import units as u
from astropy.wcs.utils import pixel_to_skycoord
from matplotlib import pyplot as plt
from processing_library.util.coordinate_support import *
from rascil.processing_components.image.iterators import image_raster_iter
from rascil.processing_components.visibility.base import create_visibility
from rascil.processing_components.skycomponent.operations import create_skycomponent
from rascil.processing_components.image.operations import show_image, export_image_to_fits
from rascil.processing_components.image.deconvolution import deconvolve_cube, restore_cube
from rascil.processing_components.visibility.iterators import vis_timeslice_iter
from rascil.processing_components.simulation.configurations import create_named_configuration
from rascil.processing_components.simulation.testing_support import create_test_image
from rascil.processing_components.imaging.base import create_image_from_visibility
from rascil.processing_components.imaging.base import advise_wide_field
from rascil.workflows.serial.imaging.imaging_serial import invert_list_serial_workflow, predict_list_serial_workflow
from rascil.data_models.polarisation import PolarisationFrame
import logging
log = logging.getLogger()
log.setLevel(logging.DEBUG)
log.addHandler(logging.StreamHandler(sys.stdout))
mpl_logger = logging.getLogger("matplotlib")
mpl_logger.setLevel(logging.WARNING)
# In[2]:
pylab.rcParams['figure.figsize'] = (6.0, 6.0)
pylab.rcParams['image.cmap'] = 'rainbow'
# Construct LOW core configuration
# In[3]:
def plotuvw(uvwcoord, x=0, y=1, z=2):
plt.clf()
plt.plot(uvwcoord[:,x], uvwcoord[:,y], '.', color='b')
plt.show()
# In[5]:
def xyz_to_uvw(xyz, ha, dec):
"""
Rotate :math:`(x,y,z)` positions in earth coordinates to
:math:`(u,v,w)` coordinates relative to astronomical source
position :math:`(ha, dec)`. Can be used for both antenna positions
as well as for baselines.
Hour angle and declination can be given as single values or arrays
of the same length. Angles can be given as radians or astropy
quantities with a valid conversion.
:param xyz: :math:`(x,y,z)` co-ordinates of antennas in array
:param ha: hour angle of phase tracking centre (:math:`ha = ra - lst`)
:param dec: declination of phase tracking centre.
"""
x, y, z = numpy.hsplit(xyz, 3) # pylint: disable=unbalanced-tuple-unpacking
# Two rotations:
# 1. by 'ha' along the z axis
# 2. by '90-dec' along the u axis
u = x * numpy.cos(ha) - y * numpy.sin(ha)
v0 = x * numpy.sin(ha) + y * numpy.cos(ha)
w = z * numpy.sin(dec) - v0 * numpy.cos(dec)
lat = 180.0 * numpy.arctan2(v0,z) / numpy.pi
v = z * numpy.cos(dec) + v0 * | numpy.sin(dec) | numpy.sin |
#!/usr/bin/env python3
import matplotlib.pyplot as plt
import numpy as np
from scipy.signal import periodogram
from scipy.spatial import distance
from scipy.stats import norm
from sympy.combinatorics.graycode import GrayCode
# Carrier signal
f_c = 100.0
t_c = 1.0 / f_c
# Sampling rate
f_s = 10000.0
t_s = 1.0 / f_s
# MPSK Parameters
Tb = 0.01
Eb = 0.001
def bits_to_symbols(msg, k):
bucket_of_buckets = []
for i in range(k):
bucket_of_buckets.append(msg[i::k])
symbols = np.array(bucket_of_buckets)
return symbols
def constellation_angles(M):
return np.arange(0.0, 2.0 * np.pi, 2.0 * np.pi / M)
def graycode(k):
return list(GrayCode(k).generate_gray())
def generate_constellation_table(constellation, gray_code):
constellation_table = {}
for i, code in enumerate(gray_code):
constellation_table[code] = constellation[i]
return constellation_table
def generate_theta_vector(symbols, constellation_table):
theta = np.zeros(np.size(symbols, axis=1), dtype="float")
for j in range(np.size(symbols, axis=1)):
bits = []
for i in range(np.size(symbols, axis=0)):
bits.append(symbols[i, j])
bits_str = ""
for bit in bits:
bits_str += str(bit)
theta[j] = constellation_table[bits_str]
return theta
def generate_I_Q_signals(theta):
A = np.sqrt(Eb)
I = A * np.cos(theta) # in-phase component
Q = A * np.sin(theta) # quadrature component
return I, Q
def plot_constellation_diagram(I, Q):
plt.figure()
# Makes it look like a circle instead of an ellipse
plt.axes().set_aspect("equal", "datalim")
# Time vector for sine and cosine
t_csd = np.linspace(0.0, 2.0 * np.math.pi, 100)
plt.plot(
np.sqrt(Eb) * np.sin(t_csd), np.sqrt(Eb) * np.cos(t_csd)
) # sqrt(Eb)*sin and sqrt(Eb)*cos
plt.plot(I, Q, "ro", markersize=12)
plt.grid()
plt.title("Constellation diagram for QPSK", fontsize=14)
plt.tick_params(labelsize=12)
plt.show()
def modulate_signal(symbols, I, Q):
t = np.linspace(0.0, Tb, int(Tb * f_s))
modulated_signal = np.empty(
np.size(symbols, axis=1) * len(t), dtype="float")
phi_1 = np.sqrt(2 / Tb) * np.cos(2.0 * np.math.pi * f_c * t)
phi_2 = np.sqrt(2 / Tb) * np.sin(2.0 * np.math.pi * f_c * t)
for k in range(np.size(symbols, axis=1)):
# Calculates modulated signal for each symbol
# Page 12, Lecture 16
modulated_signal[k * len(t): (k + 1) * len(t)
] = I[k] * phi_1 - Q[k] * phi_2
return modulated_signal
def plot_modulated_signal(symbols, modulated_signal):
# Time vector for symbols
# t_sym = np.arange(0.0, np.size(symbols, axis=1)*2.0*t_c, t_s)
t_sym = np.linspace(
0, np.size(symbols, axis=1) *
Tb, int(np.size(symbols, axis=1) * Tb * f_s)
)
plt.figure()
plt.title("MPSK", fontsize=14)
plt.xlabel("t", fontsize=14)
plt.ylabel("Amplitude", fontsize=14)
plt.tick_params(labelsize=12)
plt.plot(t_sym, modulated_signal)
plt.show()
def add_noise(modulated_signal):
# Noise
ns = len(modulated_signal)
noise = np.random.normal(size=ns)
f, psd = periodogram(noise, f_s)
# Plot noise
# fig, ax = plt.subplots(2,1)
# ax[0].plot(noise)
# ax[1].plot(f, psd)
psd_av = np.mean(psd)
N0 = 2 * psd_av
# modulated_signal += noise
return N0, modulated_signal
def generate_decoding_table(gray_code, constellation_table):
decoding_table = {}
for code in gray_code:
amp = np.zeros(2, dtype="float")
amp[0] = | np.cos(constellation_table[code]) | numpy.cos |
"""Functions for generating random data with injected relationships"""
from itertools import product
import os
import json
import re
import random
import numpy as np
from numpy import random as rd
from scipy.special import comb
from ntp.util.util_kb import load_from_list
def gen_relationships(n_pred, n_rel, body_predicates=1):
"""
Generates random relationships between predicates of the form goal predicate <-- {set of body predicates}.
Goal predicates have a higher number than body predicates.
Args:
n_pred: number of total predicates
n_rel: number of relationships
body_predicates: number of body predicates for each relationship
Returns:
Dict, entries where keys are goal predicates and values are list of body predicates
"""
relationship_dict = {}
n_rel_possible = comb(n_pred, body_predicates + 1)
pred_probs = [comb(i, body_predicates)/n_rel_possible for i in range(n_pred)]
relationship_head_array = list( | rd.choice(n_pred, size=n_rel, replace=False, p=pred_probs) | numpy.random.choice |
import numpy as np
import matplotlib.pyplot as plt
import os
import skimage
import tensorflow as tf
from .sac import td_target
from .sac_classifier import SACClassifier
from softlearning.misc.utils import mixup
from softlearning.models.utils import flatten_input_structure
from maml.meta_nml import MetaNML
from model import VAE, MetaMNISTConvModel as MetaConvModel
from notebook_helpers import *
import torch
MAZE_LOW = -6
MAZE_HIGH = 6
N_BINS = (MAZE_HIGH - MAZE_LOW) * 2
class VICE(SACClassifier):
"""Varitational Inverse Control with Events (VICE)
References
----------
[1] Variational Inverse Control with Events: A General
Framework for Data-Driven Reward Definition. <NAME>, <NAME>,
<NAME>, <NAME>, <NAME>, NIPS 2018.
"""
def __init__(
self,
*args,
positive_on_first_occurence=False,
active_query_frequency=None,
gradient_penalty_weight=0,
death_reward=0,
sparse_goal=None,
append_qpos=False,
use_meta_nml=False,
use_laplace_smoothing_rewards=False,
recompute_rewards=False,
laplace_smoothing_weight=1,
meta_nml_train_on_positives=False,
meta_nml_train_every_k=1,
meta_nml_reset_frequency=0,
meta_nml_negatives_only=False,
meta_nml_add_vice_reward=False,
meta_nml_do_metatraining=True,
meta_nml_shuffle_states=False,
n_initial_classifier_train_steps=1,
meta_nml_checkpoint_frequency=100,
meta_nml_layers=[2048, 2048],
meta_nml_num_finetuning_layers=None,
meta_nml_uniform_train_data=False,
meta_nml_use_preprocessor=False,
meta_nml_custom_embedding_key=None,
meta_nml_use_vae=False,
meta_nml_vae_model=None,
meta_nml_train_vae=False,
meta_nml_train_embedding_frequency=None,
num_initial_train_embedding_epochs=800,
meta_nml_train_embedding_epochs=50,
meta_nml_reward_type='probs', # Options are {'probs', 'log_probs'}
meta_train_sample_size=128,
meta_test_sample_size=1000,
meta_task_batch_size=1,
accumulation_steps=16,
meta_test_batch_size=16,
num_initial_meta_epochs=10,
num_meta_epochs=1,
nml_grad_steps=1,
points_per_meta_task=1,
equal_pos_neg_test=True,
dist_weight_thresh=None,
query_point_weight=1,
test_strategy='all',
**kwargs
):
self._active_query_frequency = active_query_frequency
self._gradient_penalty_weight = gradient_penalty_weight
self._append_qpos = append_qpos
self._sparse_goal = sparse_goal
self._death_reward = death_reward
self._use_laplace_smoothing_rewards = use_laplace_smoothing_rewards
self._recompute_rewards = recompute_rewards
self._laplace_smoothing_weight = laplace_smoothing_weight
self._use_meta_nml = use_meta_nml
self._meta_nml_checkpoint_frequency = meta_nml_checkpoint_frequency
self._meta_nml_train_every_k = meta_nml_train_every_k
self._meta_nml_reward_type = meta_nml_reward_type
self._meta_nml_reset_frequency = meta_nml_reset_frequency
self._meta_nml_train_on_positives = meta_nml_train_on_positives
self._meta_nml_uniform_train_data = meta_nml_uniform_train_data
self._meta_nml_negatives_only = meta_nml_negatives_only
self._meta_nml_add_vice_reward = meta_nml_add_vice_reward
self._meta_nml_shuffle_states = meta_nml_shuffle_states
self._meta_nml_use_preprocessor = meta_nml_use_preprocessor
self._meta_nml_custom_embedding_key = meta_nml_custom_embedding_key
self._meta_nml_use_vae = meta_nml_use_vae
self._meta_nml_train_vae = meta_nml_train_vae
self._meta_nml_train_embedding_frequency = meta_nml_train_embedding_frequency
self._meta_nml_train_embedding_epochs = meta_nml_train_embedding_epochs
self._num_initial_train_embedding_epochs = num_initial_train_embedding_epochs
self._n_initial_classifier_train_steps = n_initial_classifier_train_steps
super(VICE, self).__init__(*args, **kwargs)
print(f"[VICE] Epoch length: {self._epoch_length}")
if self._use_laplace_smoothing_rewards:
self.rewards_matrix = np.repeat(0.5, N_BINS * N_BINS).reshape((N_BINS, N_BINS))
self._from_vision = 'pixels' in self._classifier.observation_keys
if self._use_meta_nml:
vae_kwargs = {}
input_dim = 0
if self._from_vision:
# Using a convolutional network for image inputs
vae_kwargs['model'] = MetaConvModel(2, in_channels=3)
print(f"[MetaNML] Using convolutional network for classifier")
print(vae_kwargs['model'])
else:
# Using a feedforward network. Figure out what the input dimension
# should be based on the classifier observation keys (or preprocessor embedding dim)
if self._meta_nml_use_preprocessor:
assert hasattr(self._classifier, "observations_preprocessors"), \
"Must define a preprocessor for the reward classifier" \
+ " when setting meta_nml_use_preprocessor=True"
self._preprocessor = tf.keras.Model(inputs=self._classifier.layers[0].input, outputs=self._classifier.layers[1].output)
self._init_preprocessor_outputs()
input_dim = self._classifier.layers[1].output.shape[-1]
else:
input_dim = self._concat_classifier_obs({
key: self._goal_examples[key][0,None]
for key in self._goal_examples
}).shape[-1]
print(f"[MetaNML] Using feedforward classifier, input dimension {input_dim}")
if meta_nml_vae_model:
model_vae = VAE(img_channels=3)
model_vae.load_state_dict(torch.load(meta_nml_vae_model))
model_vae.cuda()
vae_kwargs['model_vae'] = model_vae
vae_kwargs['embedding_type'] = 'vae'
vae_kwargs['num_finetuning_layers'] = 2
print(f"[MetaNML] Loaded VAE weights from {meta_nml_vae_model}")
if meta_nml_custom_embedding_key:
print(f"[MetaNML] Using custom embedding key: {meta_nml_custom_embedding_key}")
vae_kwargs['embedding_type'] = 'custom'
self.meta_nml_kwargs = {
**vae_kwargs,
"hidden_sizes": list(meta_nml_layers),
"input_dim": input_dim,
"points_per_task": points_per_meta_task,
"equal_pos_neg_test": equal_pos_neg_test and not meta_nml_negatives_only,
"dist_weight_thresh": dist_weight_thresh,
"query_point_weight": query_point_weight,
"do_metalearning": meta_nml_do_metatraining,
"train_vae": meta_nml_train_vae,
"num_finetuning_layers": meta_nml_num_finetuning_layers,
}
self.meta_nml = MetaNML(**self.meta_nml_kwargs)
self._meta_train_sample_size = meta_train_sample_size
self._meta_test_sample_size = meta_test_sample_size
self._meta_task_batch_size = meta_task_batch_size
self._accumulation_steps = accumulation_steps
self._meta_test_batch_size = meta_test_batch_size
self._num_initial_meta_epochs = num_initial_meta_epochs
self._num_meta_epochs = num_meta_epochs
self._nml_grad_steps = nml_grad_steps
self._test_strategy = test_strategy
self._positive_on_first_occurence = positive_on_first_occurence
if positive_on_first_occurence:
env = self._training_environment.unwrapped
# self._seen_states = set()
self._seen_states = [
[False for _ in range(env.n_bins + 1)]
for _ in range(env.n_bins + 1)
]
# def _init_extrinsic_reward(self):
# classifier_inputs = flatten_input_structure({
# name: tf.exp(self._placeholders['observations'][name])
# for name in self._classifier.observation_keys
# })
# observation_log_p = self._classifier(classifier_inputs)
# self._reward_t = self._unscaled_ext_reward = observation_log_p
def _use_fixed_rewards(self):
return self._use_meta_nml or self._use_laplace_smoothing_rewards
def _init_classifier_reward(self):
classifier_inputs = flatten_input_structure({
name: self._placeholders['observations'][name]
for name in self._classifier.observation_keys
})
observation_logits = self._classifier(classifier_inputs)
if self._meta_nml_reward_type == 'logits':
self._clf_reward = observation_logits
elif self._meta_nml_reward_type == 'probs':
self._clf_reward = tf.nn.sigmoid(observation_logits)
else:
raise NotImplementedError(
f"Unknown meta-NML reward type: {self._meta_nml_reward_type}")
def _init_preprocessor_outputs(self):
classifier_inputs = flatten_input_structure({
name: self._placeholders['observations'][name]
for name in self._classifier.observation_keys
})
self._preprocessor_outputs = self._preprocessor(classifier_inputs)
def _init_extrinsic_reward(self):
if self._use_fixed_rewards():
if self._meta_nml_add_vice_reward or self._meta_nml_use_preprocessor:
self._init_classifier_reward()
# Don't include classifier reward evaluation in the computation graph,
# because meta-NML is very expensive. Instead, we'll compute the rewards
# directly when the states are sampled (by using ClassifierSampler),
# and store them as `learned_rewards` in the replay pool.
self._reward_t = self._unscaled_ext_reward = self._placeholders['learned_rewards']
else:
super(VICE, self)._init_extrinsic_reward()
def _get_feed_dict(self, iteration, batch):
feed_dict = super(VICE, self)._get_feed_dict(iteration, batch)
if 'learned_rewards' in batch:
if self._recompute_rewards:
# Recompute rewards with the most recent classifier params
feed_dict[self._placeholders['learned_rewards']] = self.get_reward(batch['observations'])[:,None]
# else:
# # Include the stale classifier rewards, which were assigned when states were first encountered
# feed_dict[self._placeholders['learned_rewards']] = batch['learned_rewards']
return feed_dict
def _get_episode_reward_feed_dict(self, episodes):
feed_dict = super(VICE, self)._get_episode_reward_feed_dict(episodes)
if self._use_fixed_rewards():
feed_dict[self._placeholders['learned_rewards']] = np.concatenate([
episode['learned_rewards'] for episode in episodes
])
return feed_dict
def _get_classifier_feed_dict(self):
negatives = self.sampler.random_batch(
self._classifier_batch_size
)['observations']
if self._positive_on_first_occurence:
# Still things left to explore
env = self._training_environment.unwrapped
first_occ_idxs = []
for i in range(len(negatives[next(iter(negatives))])):
x_d, y_d = env._discretize_observation({
key: val[i]
for key, val in negatives.items()
})
if not self._seen_states[x_d][y_d]:
# if (x_d, y_d) not in self._seen_states:
first_occ_idxs.append(i)
# self._seen_states.add((x_d, y_d))
self._seen_states[x_d][y_d] = True
# DEBUG: Testing with the same negatives pool for each training iteration
# negatives = type(self._pool.data)(
# (key[1], value[:self._classifier_batch_size])
# for key, value in self._pool.data.items()
# if key[0] == 'observations')
rand_positive_ind = np.random.randint(
self._goal_examples[next(iter(self._goal_examples))].shape[0],
size=self._classifier_batch_size)
positives = {
key: values[rand_positive_ind]
for key, values in self._goal_examples.items()
}
if self._positive_on_first_occurence:
positives = {
key: np.concatenate([val, negatives[key][first_occ_idxs]], axis=0)
for key, val in positives.items()
}
labels_batch = np.zeros(
(self._classifier_batch_size +
(self._classifier_batch_size + len(first_occ_idxs)), 2),
dtype=np.int32)
labels_batch[:self._classifier_batch_size, 0] = 1
labels_batch[self._classifier_batch_size:, 1] = 1
else:
labels_batch = np.zeros(
(2 * self._classifier_batch_size, 2),
dtype=np.int32)
labels_batch[:self._classifier_batch_size, 0] = 1
labels_batch[self._classifier_batch_size:, 1] = 1
observations_batch = {
key: np.concatenate((negatives[key], positives[key]), axis=0)
# for key in self._classifier.observation_keys
for key in self._policy.observation_keys
}
if self._mixup_alpha > 0:
observations_batch, labels_batch = mixup(
observations_batch, labels_batch, alpha=self._mixup_alpha)
feed_dict = {
**{
self._placeholders['observations'][key]:
observations_batch[key]
# for key in self._classifier.observation_keys
for key in self._policy.observation_keys
},
self._placeholders['labels']: labels_batch,
}
return feed_dict
def _init_placeholders(self):
super()._init_placeholders()
self._placeholders['labels'] = tf.placeholder(
tf.int32,
shape=(None, 2),
name='labels',
)
if self._use_fixed_rewards():
self._placeholders['learned_rewards'] = tf.placeholder(
tf.float32,
shape=(None, 1),
name='learned_rewards',
)
def _init_classifier_update(self):
if (self._use_fixed_rewards() and not self._meta_nml_add_vice_reward
and not self._meta_nml_use_preprocessor):
return
classifier_inputs = flatten_input_structure({
name: self._placeholders['observations'][name]
for name in self._classifier.observation_keys
})
log_p = self._classifier(classifier_inputs)
policy_inputs = flatten_input_structure({
name: self._placeholders['observations'][name]
for name in self._policy.observation_keys
})
sampled_actions = self._policy.actions(policy_inputs)
log_pi = self._policy.log_pis(policy_inputs, sampled_actions)
# pi / (pi + f), f / (f + pi)
log_pi_log_p_concat = tf.concat([log_pi, log_p], axis=1)
self._classifier_loss_t = tf.reduce_mean(
tf.compat.v1.losses.softmax_cross_entropy(
self._placeholders['labels'],
log_pi_log_p_concat,
)
)
self._classifier_training_op = self._get_classifier_training_op()
def _concat_classifier_obs(self, batch, shuffle=True):
if self._meta_nml_shuffle_states and shuffle:
states = discretized_states(
batch['state_observation'],
bins=N_BINS, low=MAZE_LOW, high=MAZE_HIGH
)
results = (np.hstack([self._random_mapping_x[states[:,0]][:,None], self._random_mapping_y[states[:,1]][:,None]]) - 8) / 2
return results
if self._meta_nml_use_vae or self._meta_nml_custom_embedding_key:
return batch['pixels'].transpose((0, 3, 1, 2))
return np.hstack([batch[name] for name in self._classifier.observation_keys])
def _get_laplace_obs(self, batch):
if self._meta_nml_use_vae or self._meta_nml_custom_embedding_key:
return batch['state_observation']
else:
return self._concat_classifier_obs(batch, shuffle=False)
def _sample_negatives(self, size):
batch = self.sampler.random_batch(size)['observations']
if self._meta_nml_use_preprocessor:
# If using a preprocessor, we train & evaluate meta-NML on the embedding
# given by the preprocessor instead of the raw inputs.
negatives = self._compute_preprocessor_embedding(batch)
else:
negatives = self._concat_classifier_obs(batch)
labels = np.zeros(len(negatives))
if self._meta_nml_custom_embedding_key:
return negatives.astype(np.float32), labels, batch[self._meta_nml_custom_embedding_key]
else:
return negatives.astype(np.float32), labels
def _sample_positives(self, size, shuffle=True, for_laplace=False):
rand_positive_ind = np.random.randint(
self._goal_examples[next(iter(self._goal_examples))].shape[0],
size=size)
if for_laplace:
return self._goal_examples['state_observation'][rand_positive_ind]
batch = {
key: values[rand_positive_ind]
for key, values in self._goal_examples.items()
if key in self._classifier.observation_keys
}
if self._meta_nml_use_preprocessor:
# If using a preprocessor, we train & evaluate meta-NML on the embedding
# given by the preprocessor instead of the raw inputs.
positives = self._compute_preprocessor_embedding(batch)
else:
positives = self._concat_classifier_obs(batch, shuffle=shuffle)
if self._meta_nml_custom_embedding_key:
return (positives.astype(np.float32), np.ones(len(positives)),
self._goal_examples[self._meta_nml_custom_embedding_key][rand_positive_ind])
else:
return positives.astype(np.float32), np.ones(len(positives))
def _sample_meta_test_batch(self, size):
if self._meta_nml_negatives_only:
return self._sample_negatives(size)
else:
negatives = self._sample_negatives(size // 2)
positives = self._sample_positives(size // 2)
return tuple(np.concatenate([a, b], axis=0) for a, b in zip(negatives, positives))
def _get_grid_vals(self):
n_bins = (MAZE_HIGH - MAZE_LOW) * 2
grid_vals = | np.arange(n_bins * n_bins) | numpy.arange |
# -*- coding: utf-8 -*-
# Copyright (c) <NAME>
# Distributed under the terms of the MIT License.
"""Utilities for scaling the capture coefficient.
This module provides various utilities that are necessary to scale the
capture coefficient to the final value.
"""
from itertools import groupby
from typing import Optional, Tuple, Union
import numpy as np
from numpy.polynomial.laguerre import laggauss
from pymatgen.io.vasp.outputs import Wavecar
from scipy import constants as const
from scipy.optimize import curve_fit
try:
from numba import njit
except ModuleNotFoundError:
def njit(*args, **kwargs): # pylint: disable=W0613
"""Fake njit when numba can't be found."""
def _njit(func):
return func
return _njit
def sommerfeld_parameter(
T: Union[float, np.ndarray],
Z: int,
m_eff: float,
eps0: float,
method: str = 'Integrate'
) -> Union[float, np.ndarray]:
"""Compute the sommerfeld parameter.
Computes the sommerfeld parameter at a given temperature using the
definitions in R. Pässler et al., phys. stat. sol. (b) 78, 625 (1976). We
assume that theta_{b,i}(T) ~ T.
Parameters
----------
T : float, np.array(dtype=float)
temperature in K
Z : int
Z = Q / q where Q is the charge of the defect and q is the charge of
the carrier. Z < 0 corresponds to attractive centers and Z > 0
corresponds to repulsive centers
m_eff : float
effective mass of the carrier in units of m_e (electron mass)
eps0 : float
static dielectric constant
method : str
specify method for evaluating sommerfeld parameter ('Integrate' or
'Analytic'). The default is recommended as the analytic equation may
introduce significant errors for the repulsive case at high T.
Returns
-------
float, np.array(dtype=float)
sommerfeld factor evaluated at the given temperature
"""
if Z == 0:
return 1.
if method.lower()[0] == 'i':
kT = const.k * T
m = m_eff * const.m_e
eps = (4 * np.pi * const.epsilon_0) * eps0
f = -2 * np.pi * Z * m * const.e**2 / const.hbar**2 / eps
def s_k(k):
return f / k / (1 - np.exp(-f / k))
t = 0.
x, w = laggauss(64)
for ix, iw in zip(x, w):
t += iw * np.sqrt(ix) * s_k(np.sqrt(2 * m * kT * ix) / const.hbar)
return t / np.sum(w * np.sqrt(x))
# that 4*pi from Gaussian units....
theta_b = np.pi**2 * (m_eff * const.m_e) * const.e**4 / \
(2 * const.k * const.hbar**2 * (eps0 * 4*np.pi*const.epsilon_0)**2)
zthetaT = Z**2 * theta_b / T
if Z < 0:
return 4 * np.sqrt(zthetaT / np.pi)
return (8 / np.sqrt(3)) * \
zthetaT**(2/3) * np.exp(-3 * zthetaT**(1/3))
@njit(cache=True)
def find_charge_center(density: np.ndarray, lattice: np.ndarray) -> np.ndarray:
"""Compute the center of the charge density.
Parameters
----------
density : np.array
density of the wavecar returned by wavecar.fft_mesh
lattice : np.array
lattice to use to compute PBC
Returns
-------
np.array
position of the center in cartesian coordinates
"""
avg = np.zeros(3)
for i in range(density.shape[0]):
for j in range(density.shape[1]):
for k in range(density.shape[2]):
avg += np.dot(np.array((i, j, k)) / np.array(density.shape),
lattice) * density[(i, j, k)]
return avg / np.sum(density)
@njit(cache=True)
def distance_PBC(a: np.ndarray, b: np.ndarray, lattice: np.ndarray) -> float:
"""Compute the distance between a and b on the lattice with periodic BCs.
Parameters
----------
a, b : np.array
points in cartesian coordinates
lattice : np.array
lattice to use to compute PBC
Returns
-------
float
distance
"""
min_dist = np.inf
for i in [-1, 0, 1]:
for j in [-1, 0, 1]:
for k in [-1, 0, 1]:
R = np.dot(np.array((i, j, k), dtype=np.float64), lattice)
dist = np.linalg.norm(a - b + R)
min_dist = dist if dist < min_dist else min_dist
return min_dist
@njit(cache=True)
def radial_distribution(
density: np.ndarray,
point: np.ndarray,
lattice: np.ndarray
) -> Tuple[np.ndarray, np.ndarray]:
"""Compute the radial distribution.
Computes the radial distribution of the density around the given point with
the defined lattice.
Parameters
----------
density : np.array
density of the wavecar returned by wavecar.fft_mesh
point : np.array
position of the defect in cartesian coordinates
lattice : np.array
lattice to use to compute PBC
Returns
-------
r : np.array
array of radii that the density corresponds to
n : np.array
array of densities at the corresponding radii
"""
N = density.shape[0] * density.shape[1] * density.shape[2]
r, n = (np.zeros(N), np.zeros(N))
m = 0
for i in range(density.shape[0]):
for j in range(density.shape[1]):
for k in range(density.shape[2]):
r[m] = distance_PBC(np.dot(
np.array((i, j, k), dtype=np.float64) /
np.array(density.shape),
lattice
), point, lattice)
n[m] = density[(i, j, k)]
m += 1
return r, n
def charged_supercell_scaling_VASP(
wavecar_path: str,
bulk_index: int,
def_index: int = -1,
def_coord: Optional[np.ndarray] = None,
cutoff: float = 0.02,
limit: float = 5.,
spin: int = 0,
kpoint: int = 1,
fig=None,
full_range=False
) -> float:
"""
Estimate the interaction between the defect and bulk wavefunction.
This function estimates the interaction between the defect and bulk
wavefunction due to spurious effects as a result of using a charged
supercell. The radial distribution of the bulk wavefunction is compared to
a perfectly homogenous wavefunction to estimate the scaling.
Either def_index or def_coord must be specified.
If you get wonky results with def_index, try using def_coord as there may
be a problem with finding the defect position if the defect charge is at
the boundary of the cell.
Parameters
----------
wavecar_path : str
path to the WAVECAR file that contains the relevant wavefunctions
def_index, bulk_index : int
index of the defect and bulk wavefunctions in the WAVECAR file
def_coord : np.array(dim=(3,))
cartesian coordinates of defect position
cutoff : float
cutoff for determining zero slope regions
limit : float
upper limit for windowing procedure
spin : int
spin channel to read from (0 - up, 1 - down)
kpoint : int
kpoint to read from (defaults to the first kpoint)
fig : matplotlib.figure.Figure
optional figure object to plot diagnostic information (recommended)
full_range : bool
determines if full range of first plot is shown
Returns
-------
float
estimated scaling value to apply to the capture coefficient
"""
if def_index == -1 and def_coord is None:
raise ValueError('either def_index or def_coord must be specified')
wavecar = Wavecar(wavecar_path)
# compute relevant things
if def_coord is None:
psi_def = wavecar.fft_mesh(spin=spin, kpoint=kpoint-1,
band=def_index-1)
fft_psi_def = np.fft.ifftn(psi_def)
den_def = np.abs(np.conj(fft_psi_def) * fft_psi_def) / \
np.abs(np.vdot(fft_psi_def, fft_psi_def))
def_coord = find_charge_center(den_def, wavecar.a)
psi_bulk = wavecar.fft_mesh(spin=spin, kpoint=kpoint-1, band=bulk_index-1)
fft_psi_bulk = np.fft.ifftn(psi_bulk)
return charged_supercell_scaling(fft_psi_bulk, wavecar.a, def_coord,
cutoff=cutoff, limit=limit, fig=fig,
full_range=full_range)
def charged_supercell_scaling(
wavefunc: np.ndarray,
lattice: np.ndarray,
def_coord: np.ndarray,
cutoff: float = 0.02,
limit: float = 5.,
fig=None,
full_range=False
) -> float:
"""
Estimate the interaction between the defect and bulk wavefunction.
This function estimates the interaction between the defect and bulk
wavefunction due to spurious effects as a result of using a charged
supercell. The radial distribution of the bulk wavefunction is compared to
a perfectly homogenous wavefunction to estimate the scaling.
Parameters
----------
wavefunc : np.array(dim=(NX, NY, NZ))
bulk wavefunction in real-space on a NX by NY by NZ FFT grid
lattice : np.array(dim=(3, 3))
real-space lattice vectors for your system
def_coord : np.array(dim=(3,))
cartesian coordinates of defect position
cutoff : float
cutoff for determining zero slope regions
limit : float
upper limit for windowing procedure
fig : matplotlib.figure.Figure
optional figure object to plot diagnostic information (recommended)
full_range : bool
determines if full range of first plot is shown
Returns
-------
float
estimated scaling value to apply to the capture coefficient
"""
volume = np.dot(lattice[0, :], np.cross(lattice[1, :], lattice[2, :]))
den_bulk = np.abs(np.conj(wavefunc) * wavefunc) / \
np.abs(np.vdot(wavefunc, wavefunc))
r, density = radial_distribution(den_bulk, def_coord, lattice)
# fitting procedure
def f(x, alpha):
return alpha * (4 * np.pi / 3 / volume) * x**3
sind = np.argsort(r)
R, int_den = (r[sind], np.cumsum(density[sind]))
uppers = np.linspace(1., limit, 500)
alphas = np.array([
curve_fit(f, R[(R >= 0.) & (R <= u)],
int_den[(R >= 0.) & (R <= u)])[0][0]
for u in uppers
])
# find possible plateaus and return earliest one
zeros = np.where(np.abs( | np.gradient(alphas, uppers) | numpy.gradient |
"""
This module handles experimental data, by fitting a growth and death rate for each condition separately.
"""
from os.path import join, dirname, abspath
import pandas
import numpy as np
import pymc3 as pm
import theano.tensor as T
fitKwargs = {"tune": 3000, "progressbar": False, "target_accept": 0.9}
def theanoCore(timeV, div, deathRate, apopfrac, d):
""" Assemble the core growth model. """
# Make a vector of time and one for time-constant values
timeV = T._shared(timeV)
constV = T.ones_like(timeV) # pylint: disable=no-member
# Calculate the growth rate
GR = T.outer(div - deathRate, constV)
# cGDd is used later
cGRd = T.outer(deathRate * apopfrac, constV) / (GR + d)
# b is the rate straight to death
b = T.outer(deathRate * (1 - apopfrac), constV)
lnum = T.exp(GR * timeV)
# Number of early apoptosis cells at start is 0.0
eap = cGRd * (lnum - T.exp(-d * timeV))
# Calculate dead cells via apoptosis and via necrosis
deadnec = b * (lnum - 1) / GR
deadapop = d * cGRd * (lnum - 1) / GR + cGRd * (T.exp(-d * timeV) - 1)
return (lnum, eap, deadapop, deadnec)
def convSignal(lnum, eap, deadapop, deadnec, conversions):
""" Sums up the cell populations to link number of cells to image area. """
conv, offset = conversions
confl_exp = (lnum + eap + deadapop + deadnec) * conv[0]
apop_exp = (eap + deadapop) * conv[1] + offset[0]
dna_exp = (deadapop + deadnec) * conv[2] + offset[1]
return (confl_exp, apop_exp, dna_exp)
def conversionPriors(conv0):
""" Sets the various fluorescence conversion priors. """
# Set up conversion rates
confl_conv = pm.Lognormal("confl_conv", np.log(conv0), 0.1)
apop_conv = pm.Lognormal("apop_conv", np.log(conv0) - 2.06, 0.1)
dna_conv = pm.Lognormal("dna_conv", np.log(conv0) - 1.85, 0.1)
# Priors on conv factors
pm.Lognormal("confl_apop", -2.06, 0.0647, observed=apop_conv / confl_conv)
pm.Lognormal("confl_dna", -1.85, 0.125, observed=dna_conv / confl_conv)
pm.Lognormal("apop_dna", 0.222, 0.141, observed=dna_conv / apop_conv)
# Offset values for apop and dna
apop_offset = pm.Lognormal("apop_offset", | np.log(0.1) | numpy.log |
from numpy import (
logspace, linspace, geomspace, dtype, array, sctypes, arange, isnan,
ndarray, sqrt, nextafter, stack, errstate
)
from numpy.testing import (
assert_, assert_equal, assert_raises, assert_array_equal, assert_allclose,
)
class PhysicalQuantity(float):
def __new__(cls, value):
return float.__new__(cls, value)
def __add__(self, x):
assert_(isinstance(x, PhysicalQuantity))
return PhysicalQuantity(float(x) + float(self))
__radd__ = __add__
def __sub__(self, x):
assert_(isinstance(x, PhysicalQuantity))
return PhysicalQuantity(float(self) - float(x))
def __rsub__(self, x):
assert_(isinstance(x, PhysicalQuantity))
return PhysicalQuantity(float(x) - float(self))
def __mul__(self, x):
return PhysicalQuantity(float(x) * float(self))
__rmul__ = __mul__
def __div__(self, x):
return PhysicalQuantity(float(self) / float(x))
def __rdiv__(self, x):
return PhysicalQuantity(float(x) / float(self))
class PhysicalQuantity2(ndarray):
__array_priority__ = 10
class TestLogspace:
def test_basic(self):
y = logspace(0, 6)
assert_(len(y) == 50)
y = logspace(0, 6, num=100)
| assert_(y[-1] == 10 ** 6) | numpy.testing.assert_ |
import math
import re
import os
from sys import flags
import time
import numpy as np
import sympy as sp
import itertools
import json
import matplotlib.pyplot as plt
from scipy.linalg import sqrtm
def convert(o):
if isinstance(o, np.int64): return int(o)
raise TypeError
def fBose(x, pole, resi):
return 1 / x + 0.5 + sum(2.0 * resi[i] * x / (x**2 + pole[i]**2)
for i in range(len(pole)))
def tseig(D, E):
mat = np.diag(E, -1) + np.diag(D, 0) + np.diag(E, 1)
return -np.sort(-np.linalg.eigvalsh(mat))
def MSD(N, BoseFermi=1):
if BoseFermi == 1:
pole = np.array([2 * (i + 1) * np.pi for i in range(N)])
resi = np.ones(N, dtype=float)
return pole, resi
elif BoseFermi == 2:
pole = np.array([(2 * i + 1) * np.pi for i in range(N)])
resi = np.ones(N, dtype=float)
return pole, resi
def PSD(N, BoseFermi=1, pade=1):
if N < 0 or BoseFermi < 1 or BoseFermi > 2 or pade < 0 or pade > 3:
raise ValueError("N or BoseFermi or pade has wrong value!")
if pade == 0:
return MSD(N, BoseFermi)
elif pade == 1 or pade == 2:
pole, resi = [], []
if N > 0:
M = 2 * N + pade // 2
temp = 3.0 if BoseFermi == 1 else 1.0
diag = np.zeros(M, dtype=float)
doff = np.array([
1.0 / math.sqrt((temp + 2.0 * i) * (temp + 2.0 * (i + 1)))
for i in range(M - 1)
])
pole = 2.0 / tseig(diag, doff)[:N]
pol2 = np.array([x * x for x in pole])
M -= 1
temp = 5.0 if BoseFermi == 1 else 3.0
diag = np.zeros(M, dtype=float)
doff = np.array([
1.0 / math.sqrt((temp + 2.0 * i) * (temp + 2.0 * (i + 1)))
for i in range(M - 1)
])
M //= 2
eig2 = np.power(2.0 / tseig(diag, doff)[:M], 2)
scaling = 0.0
if BoseFermi == 1:
scaling = N*(2.0*N+3.0) if pade == 1 else 1.0 / \
(4.0*(N+1.0)*(2.0*N+3.0))
elif BoseFermi == 2:
scaling = N*(2.0*N+1.0) if pade == 1 else 1.0 / \
(4.0*(N+1.0)*(2.0*N+1.0))
resi = np.zeros(N, dtype=float)
for j in range(N):
if pade == 2:
temp = 0.5 * scaling * (eig2[j] - pol2[j])
elif pade == 1:
if j == N - 1:
temp = 0.5 * scaling
else:
temp = 0.5*scaling * \
(eig2[j]-pol2[j])/(pol2[N-1]-pol2[j])
for k in range(M):
temp *= (eig2[k]-pol2[j]) / \
(pol2[k]-pol2[j]) if k != j else 1.0
resi[j] = temp
rn, tn = 0.0, 0.0
if BoseFermi == 1 and pade == 2:
rn = 1.0 / (4.0 * (N + 1.0) * (2.0 * N + 3.0))
return pole, resi
elif pade == 3:
Np1 = N + 1
temp = 3.0 if BoseFermi == 1 else 1.0
d = np.empty(2 * Np1, dtype=float)
d[0] = 0.25 / temp
d[-1] = -4.0 * (N + 1.0) * (N + 1.0) * (temp + 2 * N) * (
temp + 2 * N) * (temp + 4 * N + 2.0)
for i in range(1, Np1):
d[2*i-1] = -4.0*i*i*(temp+2.0*i-2.0) * \
(temp+2.0*i-2.0)*(temp+4.0*i-2.0)
d[2 * i] = -0.25 * (temp + 4.0 * i) / i / (i + 1) / (
temp + 2.0 * i - 2.0) / (temp + 2.0 * i)
sumd2 = np.empty(Np1, dtype=float)
sumd2[0] = d[1]
for i in range(1, Np1):
sumd2[i] = sumd2[i - 1] + d[2 * i + 1]
tn = 0.25 / sumd2[-1]
rn = sum(d[2 * i] * (4.0 * tn *
(sumd2[-1] - sumd2[i - 1]))**2 if i > 0 else d[2 *
i]
for i in range(Np1))
M = 2 * N + 1
diag = np.zeros(M, dtype=float)
doff = np.array(
[1.0 / math.sqrt(d[i + 1] * d[i + 2]) for i in range(M - 1)])
pole = 2.0 / tseig(diag, doff)[:N]
resi = np.zeros(N, dtype=float)
for j in range(N):
scaling = pole[j] * pole[j]
r0, t1 = 0.0, 0.25 / d[1]
eta0, eta1, eta2 = 0.0, 0.5, 0.0
for i in range(Np1):
r1 = t1 if (i == j
or i == N) else t1 / (pole[i] * pole[i] - scaling)
r2 = 2.0*math.sqrt(abs(r1)) if r1 > 0 else - \
2.0*math.sqrt(abs(r1))
r1 = 2.0 * math.sqrt(abs(r1))
eta2 = d[2 * i] * r1 * eta1 - 0.25 * r1 * r0 * scaling * eta0
eta0 = eta1
eta1 = eta2
eta2 = d[2 * i +
1] * r2 * eta1 - 0.25 * r2 * r1 * scaling * eta0
eta0 = eta1
eta1 = eta2
r0 = r2
if i != N:
t1 = sumd2[i] / sumd2[i + 1]
resi[j] = eta2
return pole, resi
def arma_print(ndarray):
shape = ndarray.shape
dimen = len(shape)
if dimen == 1:
if issubclass(type(ndarray[0]), np.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], 1))
for row in ndarray:
print('%d' % row)
elif issubclass(type(ndarray[0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], 1))
for row in ndarray:
print('%.8e' % row)
elif issubclass(type(ndarray[0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], 1))
for row in ndarray:
print('(%.8e,%-.8e)' % (row.real, row.imag))
elif dimen == 2:
if issubclass(type(ndarray[0, 0]), np.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], shape[1]))
for row in ndarray:
print(' '.join('%d' % x for x in row))
elif issubclass(type(ndarray[0, 0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], shape[1]))
for row in ndarray:
print(' '.join('%.8e' % x for x in row))
elif issubclass(type(ndarray[0, 0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], shape[1]))
for row in ndarray:
print(' '.join('(%.8e,%-.8e)' % (x.real, x.imag) for x in row))
elif dimen == 3:
if issubclass(type(ndarray[0, 0, 0]), np.int_):
print('ARMA_CUB_TXT_IS004\n%d %d %d' %
(shape[1], shape[2], shape[0]))
for slc in ndarray:
for row in slc:
print(' '.join('%d' % x for x in row))
elif issubclass(type(ndarray[0, 0, 0]), float):
print('ARMA_CUB_TXT_FN008\n%d %d %d' %
(shape[1], shape[2], shape[0]))
for slc in ndarray:
for row in slc:
print(' '.join('%-.8e' % x for x in row))
elif issubclass(type(ndarray[0, 0, 0]), complex):
print('ARMA_CUB_TXT_FC016\n%d %d %d' %
(shape[1], shape[2], shape[0]))
for slc in ndarray:
for row in slc:
print(' '.join('(%.8e,%-.8e)' % (x.real, x.imag)
for x in row))
def arma_write(ndarray, filename):
shape = ndarray.shape
dimen = len(shape)
with open(filename, 'w') as f:
if dimen == 1:
if issubclass(type(ndarray[0]), np.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], 1), file=f)
for row in ndarray:
print('%d' % row, file=f)
elif issubclass(type(ndarray[0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], 1), file=f)
for row in ndarray:
print('%.8e' % row, file=f)
elif issubclass(type(ndarray[0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], 1), file=f)
for row in ndarray:
print('(%.8e,%-.8e)' % (row.real, row.imag), file=f)
elif dimen == 2:
if issubclass(type(ndarray[0, 0]), np.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], shape[1]),
file=f)
for row in ndarray:
print(' '.join('%d' % x for x in row), file=f)
elif issubclass(type(ndarray[0, 0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], shape[1]),
file=f)
for row in ndarray:
print(' '.join('%.8e' % x for x in row), file=f)
elif issubclass(type(ndarray[0, 0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], shape[1]),
file=f)
for row in ndarray:
print(' '.join('(%.8e,%-.8e)' % (x.real, x.imag)
for x in row),
file=f)
elif dimen == 3:
if issubclass(type(ndarray[0, 0, 0]), np.int_):
print('ARMA_CUB_TXT_IS004\n%d %d %d' %
(shape[1], shape[2], shape[0]),
file=f)
for slc in ndarray:
for row in slc:
print(' '.join('%d' % x for x in row))
elif issubclass(type(ndarray[0, 0, 0]), float):
print('ARMA_CUB_TXT_FN008\n%d %d %d' %
(shape[1], shape[2], shape[0]),
file=f)
for slc in ndarray:
for row in slc:
print(' '.join('%-.8e' % x for x in row), file=f)
elif issubclass(type(ndarray[0, 0, 0]), complex):
print('ARMA_CUB_TXT_FC016\n%d %d %d' %
(shape[1], shape[2], shape[0]),
file=f)
for slc in ndarray:
for row in slc:
print(' '.join('(%.8e,%-.8e)' % (x.real, x.imag)
for x in row),
file=f)
# in this script, we can decompose any given spectrum, but the sympy format is must been given
# do u like haskell?
# sympy[spe(def by sympy)], dict[sp_para_dict], dict[para_dict], dict[npsd],
# dict[pade] >> np.array[etal], np.array[etar],np.array[etaa], np.array[expn]
def decompose_spe(spe, sp_para_dict, para_dict, condition_dict, npsd, pade=1):
numer, denom = sp.cancel(sp.factor(sp.cancel(
spe.subs(condition_dict)))).as_numer_denom()
numer_get_para = (sp.factor(numer)).subs(sp_para_dict)
denom_get_para = (sp.factor(denom)).subs(sp_para_dict)
print(numer_get_para, "$$$$$$", denom_get_para)
poles = sp.nroots(denom_get_para)
float(sp.re(poles[0]))
print(poles)
expn = []
poles_allplane = np.array([])
for i in poles:
i = complex(i)
if i.imag < 0:
expn.append(i * 1.J)
poles_allplane = np.append(poles_allplane, i)
etal = []
etar = []
etaa = []
expn = np.array(expn)
expn_imag_sort = np.argsort(np.abs( | np.imag(expn) | numpy.imag |
import face_recognition
from PIL import Image, ImageDraw
import numpy as np
from sklearn.svm import LinearSVC
import glob
import os
import matplotlib.pyplot as plt
'''
Draw box on all face_locations of an image
'''
def draw_face_box(image, face_locations):
# Convert the image to a PIL-format image
pil_image = Image.fromarray(image)
# Create a Pillow ImageDraw Draw instance to draw with
draw = ImageDraw.Draw(pil_image)
# Loop through each face found in the unknown image
for (top, right, bottom, left) in face_locations:
# Draw a box around the face using the Pillow module
draw.rectangle(((left, top), (right, bottom)), outline=(0, 0, 255))
return draw, pil_image
'''
Get encodings and names of all images
'''
def get_encoding(path,jitters=10,det_model="hog"):
face_encodings = []
for i in [glob.glob(path+'*.%s' % ext) for ext in ["jpg","gif","png","tga","jpeg"]]:
for item in i:
image = face_recognition.load_image_file(item)
face_locations = face_recognition.face_locations(image, model=det_model)
face_encoding = face_recognition.face_encodings(image, face_locations, num_jitters=jitters)
if (face_encoding == [] or len(face_encoding) > 1):
print("image, face_encoding len: ", item, len(face_encoding))
draw, pil_image = draw_face_box(image, face_locations)
# Remove the drawing library from memory as per the Pillow docs
del draw
# Display the resulting image
pil_image.show()
if face_encoding != []:
face_encodings.append(face_encoding[0])
face_encodings = np.array(face_encodings)
return face_encodings
# Compute or load the known data
def load_data(image_path):
if not (os.path.exists(image_path+'encodings.npy')):
i = 0
for k_image_path in glob.glob(image_path+'*'):
print("image: ", k_image_path)
if k_image_path == []:
continue
k_encodings = get_encoding(k_image_path+'/',jitters,det_model=detection_model)
if k_encodings != []:
head, tail = os.path.split(k_image_path)
if i==0:
X = k_encodings
Y = np.repeat(i, len(k_encodings))
names = [tail]
else:
X = np.vstack((X,k_encodings))
Y = np.hstack((Y,np.repeat(i, len(k_encodings))))
names = np.hstack((names,tail))
i+=1
print("X.shape, Y.shape: ", X.shape, Y.shape)
print("names: ", names)
np.save(image_path+'encodings.npy', X)
np.save(image_path+'classes.npy', Y)
np.save(image_path+'names.npy', names)
else:
X = np.load(image_path+'encodings.npy')
Y = np.load(image_path+'classes.npy')
names = np.load(image_path+'names.npy')
return X, Y, names
def relative_euclidean_distance(face_encodings, face_to_compare):
"""
Given a list of face encodings, compare them to another face encoding and get a relative euclidean distance for each comparison face. The distance tells you how similar the faces are.
:param faces: List of face encodings to compare
:param face_to_compare: A face encoding to compare against
:return: A numpy ndarray with the distance for each face in the same order as the 'faces' array
"""
if len(face_encodings) == 0:
return np.empty((0))
return np.linalg.norm(face_encodings/np.sqrt(np.mean(face_encodings**2)) - face_to_compare/np.sqrt(np.mean(face_to_compare**2)), axis=1)
#return np.linalg.norm(face_encodings - face_to_compare, axis=1)
if __name__ == '__main__':
jitters = 10
tolerance = 0.5
threshold = 0
detection_model = "cnn"
image_path = "./data/"
neg_image_path = "./data/Negative/"
known_image_path = "./data/known_resized/"
test_image_path = "./data/test_resized/"
test_short_image_path = "./data/twin_test_resized/Side_By_Side/"
side_by_side = True
# load the sample and test data
X, Y, names = load_data(known_image_path)
X_t, Y_t, names_t = load_data(test_image_path)
# Names of twins and family members (incl. Unknown)
#family_names = ["Eman", "Eden", "Enoch", "Albert", "Sandy", "Unknown"]
all_family_names = ["Eden", "Eman", "Enoch", "Albert", "Sandy", "Hailey", "Ivy", "Ivan"]
twin_names = ["Eman", "Eden"]
family_sizes = | np.arange(2,9) | numpy.arange |
import numpy as np
import tensorflow as tf
import time
# build transformer (3D generator)
def fuse3D(opt,XYZ,maskLogit,fuseTrans): # [B,H,W,3V],[B,H,W,V]
with tf.name_scope("transform_fuse3D"):
XYZ = tf.transpose(XYZ,perm=[0,3,1,2]) # [B,3V,H,W]
maskLogit = tf.transpose(maskLogit,perm=[0,3,1,2]) # [B,V,H,W]
# 2D to 3D coordinate transformation
invKhom = | np.linalg.inv(opt.Khom2Dto3D) | numpy.linalg.inv |
from .range_based_navigation import LimitedRangeBasedPOMDPNavigation2DEnv, StateBasedMDPNavigation2DEnv
from .image_based_navigation import ImageBasedNavigation2DEnv
#
from gym.envs import register
import numpy as np
# (x,y)
idx_to_goal = [ (np.array([230.0, 430.0]), np.array([230.0, 130.0]), np.array([500.0, 430.0]) )] * 10
idx_to_goal[1] = (np.array([130.0, 370.0]), np.array([130.0, 110.0]), np.array([520.0, 250.0]) )
idx_to_goal[2] = (np.array([530.0, 110.0]), np.array([130.0, 310.0]), np.array([460.0, 330.0]) )
idx_to_goal[3] = (np.array([400.0, 50.0]), np.array([180.0, 320.0]), np.array([430.0, 310.0]) )
idx_to_goal[4] = (np.array([180.0, 380.0]), np.array([610.0, 120.0]), np.array([420.0, 330.0]) )
idx_to_goal[5] = (np.array([500.0, 90.0]), np.array([180.0, 390.0]), np.array([380.0, 320.0]) )
idx_to_goal[6] = (np.array([480.0, 150.0]), np.array([440.0, 380.0]), np.array([310.0, 220.0]) )
idx_to_goal[7] = (np.array([500.0, 380.0]), np.array([470.0, 280.0]), np.array([270.0, 280.0]) )
idx_to_goal[8] = (np.array([250.0, 440.0]), np.array([420.0, 200.0]), np.array([150.0, 180.0]) )
idx_to_goal[9] = ( | np.array([390.0, 110.0]) | numpy.array |
import sounddevice as sd
import soundfile as sf
import numpy as np
import matplotlib.pyplot as plt
def quantize_a_law(data, bits):
start = -1
end = 1
bit_n = 2**bits-1
data = (data-start)/(end-start)
data = np.round(data*bit_n)/bit_n
data = (data*2)-1
return data
def encode_a_law(data):
x_data = []
for i in data:
if np.abs(i) < 1 / 87.6:
x = | np.sign(i) | numpy.sign |
import numpy as np
from utils import C_bohr
__all__ = ['Grid']
class Grid:
def __init__(self, npoints, rgrid, solver='sinc', alpha=0.0, rbar=0.0):
self.ngrid = npoints
self.rmin = rgrid[0] / C_bohr
self.rmax = rgrid[1] / C_bohr
rbar = rbar / C_bohr
self.solver = solver.lower()
self.Gy = np.ones(self.ngrid)
self.Fy = np.zeros(self.ngrid)
if self.solver == 'sinc':
self.rgrid, self.rstep = self.generate_sinc_uniform_grid()
else:
self.rgrid, self.rstep = self.generate_fourier_uniform_grid()
if alpha > 0.0:
# mapping is allowed with sinc method only
self.solver = 'sinc'
self.rmin = self.get_grid_bounding_values(self.rmin, rbar, alpha)
self.rmax = self.get_grid_bounding_values(self.rmax, rbar, alpha)
self.rgrid, ygrid = self.generate_nonuniform_grid(alpha, rbar)
gy_power1 = np.power(1.0+ygrid, (1.0/alpha)-1.0)
gy_power2 = np.power(1.0-ygrid, (1.0/alpha)+1.0)
self.Gy = (2.0*rbar/alpha) * gy_power1 / gy_power2
fy_power = (np.power((1.0 - np.power(ygrid, 2)), 2))
self.Fy = (1.0 - (1.0/(alpha**2))) / fy_power
def get_grid_points(self):
return self.rgrid * C_bohr
def get_grid_bounding_values(self, rlimit, rbar, alpha):
return ((rlimit/rbar)**alpha - 1.0) / ((rlimit/rbar)**alpha + 1.0)
def generate_fourier_uniform_grid(self):
return np.linspace(
self.rmin, self.rmax, num=self.ngrid, endpoint=False, retstep=True
)
def generate_sinc_uniform_grid(self):
return np.linspace(
self.rmin, self.rmax, num=self.ngrid, endpoint=True, retstep=True
)
def calculate_sinc_basis_functions(self, r):
# numpy sinc function is defined as sin(pi*x)/(pi*x) where pi is
# used for normalization. Thus I do not need to multiply by pi
# for j in range(0, self.nch*self.ngrid):
for j in range(0, self.ngrid):
arg = (r - self.rgrid[j]) / self.rstep
# return one column from a matrix
return np.sinc(arg)
def generate_nonuniform_grid(self, alpha, rbar):
ystep = (self.rmax - self.rmin) / (self.ngrid - 1) # / ngrid - 1 ??
# ygrid = np.ogrid[self.rmin+ystep:self.rmax+ystep:ystep]
# ygrid = np.ogrid[self.rmin:self.rmax:ystep]
# ygrid = np.linspace(self.rmin, self.rmax, num=self.ngrid)
# ygrid = np.arange(self.rmin, self.rmax, step=ystep)
# ygrid = np.linspace(
# self.rmin, self.rmax, num=self.ngrid, endpoint=True
# )
ygrid = | np.empty(self.ngrid) | numpy.empty |
import unittest
import json
import pandas as pd
import numpy as np
from assistant_dialog_skill_analysis.utils import skills_util
from assistant_dialog_skill_analysis.data_analysis import divergence_analyzer
class TestDivergenceAnalyzer(unittest.TestCase):
"""Test for Divergence Analyzer module"""
def setUp(self):
unittest.TestCase.setUp(self)
with open("tests/resources/test_workspaces/skill-Customer-Care-Sample.json",
"r") as skill_file:
workspace_data, workspace_vocabulary = \
skills_util.extract_workspace_data(json.load(skill_file))
self.workspace_df = pd.DataFrame(workspace_data)
self.train_set_pd = pd.DataFrame({'utterance': ['boston is close to new york'],
'intent': ['Boston_New_York']})
self.test_set_pd = pd.DataFrame(
{'utterance': ['both boston and new york are on east coast',
'boston is close to new york'],
'intent': ['Boston_New_York', 'Boston_New_York']})
def test_label_percentage(self):
label_percentage_dict = divergence_analyzer._label_percentage(self.workspace_df)
label_percentage_vec = np.array(list(label_percentage_dict.values()))
self.assertEqual(np.all(label_percentage_vec > 0), True, "label percentage test fail")
self.assertEqual( | np.sum(label_percentage_vec) | numpy.sum |
import numpy as np
import os
from sklearn.preprocessing import normalize
#pos_categories = ["airplane", "buildings", "denseresidential", "freeway",
# "harbor", "intersection", "mediumresidential", "mobilehomepark",
# "overpass", "parkinglot", "runway", "sparseresidential", "storagetanks"]
#pos_categories = ["freeway", "intersection", "overpass", "runway"]
#pos_categories = ["mobilehomepark"]
pos_categories = ["denseresidential", "mediumresidential", "sparseresidential"]
def load_ucmerced(filelist="filepaths.txt", featfile="ucmerced_feature_vectors.numpy",
feat_dims=[-1,6,6,1024]):
img_files = [x.strip() for x in open(filelist).readlines()]
img_files = [x.split("data/")[-1] for x in img_files]
feature_vectors = np.fromfile(featfile).reshape(-1,feat_dims[-1])
feature_vectors = normalize(feature_vectors).reshape(*feat_dims)
labels = np.zeros(len(img_files))
for i in range(len(img_files)):
for p in pos_categories:
if p in img_files[i]:
labels[i] = 1
test_split = (np.arange(len(img_files)) % 10) == 0
train_x = feature_vectors[~test_split]
train_y = labels[~test_split]
train_files = np.array(img_files)[~test_split]
test_x = feature_vectors[test_split]
test_y = labels[test_split]
test_files = | np.array(img_files) | numpy.array |
import time, sys, os
import dill as pickle
import numpy as np
import scipy.constants as constants
import scipy.interpolate as interp
import scipy.optimize as opti
import scipy.signal as signal
import numdifftools as ndt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import grav_util_3 as gu
import bead_util as bu
import configuration as config
import warnings
warnings.filterwarnings("ignore")
theory_data_dir = '/data/grav_sim_data/2um_spacing_data/'
patches_base_path = '/processed_data/comsol_data/patch_potentials/'
patches_name = 'patch_pot_2um_0Vrms_bias-1Vdc'
# Include some legacy grav data to compare to later
data_dirs = [#'/data/20180625/bead1/grav_data/shield/X50-75um_Z15-25um_17Hz', \
#\
#'/data/20180704/bead1/grav_data/shield', \
#\
#'/data/20180808/bead4/grav_data/shield1' \
#\
'/data/20180827/bead2/500e_data/dipole_v_height_ac' \
#'/data/20180904/bead1/cant_force/ac_cant_elec_force_10s', \
#'/data/20180904/bead1/recharged_20180909/cant_force/acgrid_3freqs_10s'
]
load_files = False
p0_bead_dict = {'20180625': [19.0, 40.0, 20.0], \
'20180704': [18.7, 40.0, 20.0], \
'20180808': [18.0, 40.0, 20.0], \
'20180827': [35.0 ,40.0, 15.0]
}
p0_bead_dict = {'20180827': [0.0 ,0.0, 0.0], \
'20180904': [0.0 ,0.0, 0.0]
}
opt_ext = '_electrostatics'
harms = [1]
#harms = [1,2,3,4,5]
charge = 430 * constants.elementary_charge * (-1.0)
plot_field_test = False
plot_cost_function = False
plot_keyscale = 1.0e-13
maxfreq = 200
dim3 = False
unity_errors = False
init = [15.0, 0.0, 28.0, -50]
init_rot = [15.0, 0.0, 28.0, -50, 0.0, 0.0, 0.0]
############################################################
############################################################
xx = np.load(open(patches_base_path + patches_name + '.xx', 'rb'))
yy = np.load(open(patches_base_path + patches_name + '.yy', 'rb'))
zz = np.load(open(patches_base_path + patches_name + '.zz', 'rb'))
dx = xx[1] - xx[0]
dy = yy[1] - yy[0]
dz = zz[1] - zz[0]
field = np.load(open(patches_base_path + patches_name + '.field', 'rb'))
potential = np.load(open(patches_base_path + patches_name + '.potential', 'rb'))
print(field[0].shape)
gradE = []
gradE_func = []
for resp in [0,1,2]:
gradE.append( np.gradient(field[resp], dx, dy, dz)[resp] )
gradE_func.append( interp.RegularGridInterpolator((xx, yy, zz), gradE[resp], \
bounds_error=False, \
fill_value=None) )
pot_func = interp.RegularGridInterpolator((xx, yy, zz), potential, \
bounds_error=False, fill_value=None)
field_func = []
for resp in [0,1,2]:
field_func.append( interp.RegularGridInterpolator((xx, yy, zz), field[resp], \
bounds_error=False, fill_value=None) )
if plot_field_test:
posvec = np.linspace(-20e-6, 20e-6, 101)
posvec = np.linspace(-5e-6, 100e-6, 106)
ones = np.ones_like(posvec)
xval = 20.0e-6
yval = 0.0e-6
zval = 0.0e-6
eval_pts = np.stack((posvec, yval*ones, zval*ones), axis=-1)
#eval_pts = np.stack((xval*ones, posvec, zval*ones), axis=-1)
#eval_pts = np.stack((xval*ones, yval*ones, posvec), axis=-1)
ann_str = 'Sep: %0.2f um, Height: %0.2f um' % (xval*1e6, zval*1e6)
plt.figure()
plt.plot(posvec*1e6, pot_func(eval_pts))
plt.figure(figsize=(7,5))
#plt.title(name)
plt.plot(posvec*1e6, field_func[0](eval_pts)*charge, label='fx')
plt.plot(posvec*1e6, field_func[1](eval_pts)*charge, label='fy')
plt.plot(posvec*1e6, field_func[2](eval_pts)*charge, label='fz')
plt.legend()
plt.xlabel('Displacement Along Attractor [um]')
plt.ylabel('Force on 500e$^-$ [N]')
plt.annotate(ann_str, xy=(0.2, 0.9), xycoords='axes fraction')
plt.tight_layout()
plt.grid()
plt.show()
############################################################
############################################################
############################################################
############################################################
for ddir in data_dirs:
paths = gu.build_paths(ddir, opt_ext=opt_ext)
datafiles = bu.find_all_fnames(ddir)
p0_bead = p0_bead_dict[paths['date']]
if load_files:
agg_dat = gu.AggregateData(datafiles, p0_bead=p0_bead, harms=harms, \
elec_drive=True, elec_ind=0, maxfreq=maxfreq, \
plot_harm_extraction=False, dim3=dim3)
agg_dat.save(paths['agg_path'])
else:
agg_dat = gu.AggregateData([], p0_bead=p0_bead, harms=harms, dim3=dim3)
agg_dat.load(paths['agg_path'])
agg_dat.bin_rough_stage_positions(ax_disc=1.0, dim3=dim3)
agg_dat.handle_sparse_binning(dim3=dim3, verbose=False)
#print 'Testing sparse handling...',
#agg_dat.handle_sparse_binning(dim3=dim3, verbose=True)
#print 'Done!'
#raw_input()
#print agg_dat.ax0vec
#print agg_dat.ax1vec
#print agg_dat.ax2vec
#print len(agg_dat.file_data_objs)
force_plane_dict = agg_dat.get_vector_force_plane(plot_resp=(0,2), fig_ind=1, \
plot=True, show=False, \
sign=[1.0, 1.0, 1.0], dim3=dim3, \
keyscale=plot_keyscale)
force_plane_dict_2 = agg_dat.get_vector_force_plane(plot_resp=(1,2), fig_ind=2, \
plot=True, show=True, \
sign=[1.0, 1.0, 1.0], dim3=dim3, \
keyscale=plot_keyscale)
err_dict = {0: 'xerr', 1: 'yerr', 2: 'zerr'}
dat = [[], [], []]
err = [[], [], []]
for resp in [0,1,2]:
dat[resp] = force_plane_dict[resp]
err[resp] = force_plane_dict[err_dict[resp]]
dat = | np.array(dat) | numpy.array |
"""For calculating sub-observer and sub-stellar locations.
Defines the method :func:`sub_observerstellar`.
Thanks to <NAME> for preliminary work on this script.
"""
import numpy as np
pi = np.pi
def sub_observerstellar(times,worb,wrot,inc,obl,sol,longzero=0):
"""Calculates an exoplanet's sub-observer and -stellar locations over time.
Calculates time-dependent, trigonometric values of an exoplanet's sub-
observer and sub-stellar locations when on a circular orbit. Planet
coordinates are colatitude (theta) and longitude (phi). Orbital phase
is zero when planet is opposite star from observer (superior conjunction)
and increases CCW when system is viewed above star's North pole. See
Appendix A of `Schwartz et al. (2016) <https://arxiv.org/abs/1511.05152>`_.
Args:
times (1d array, int, or float):
Discrete time values in any unit, with total number *n_time*.
At t=0 planet is at superior conjunction.
worb (int or float):
Orbital angular frequency in radians per unit time. Positive
values are prograde orbits (CCW), negative are retrograde (CW).
wrot (int or float):
Rotational angular frequency in radians per unit time.
For prograde orbits, positive values are prograde rotation,
negative are retrograde (vice versa for retrograde orbits).
inc (int or float):
Inclination of orbital plane to the observer, in radians.
Zero is face-on, pi/2 is edge-on.
obl (int or float):
Obliquity relative to the ``worb`` vector, in radians.
This is the tilt of the planet's spin axis. Zero is North
pole up, pi/2 is maximal tilt, pi is North pole down.
sol (int or float):
The orbital phase of Northern Summer solstice, in radians.
If the ``wrot`` vector is projected into the orbital plane,
then this phase is where that projection points at the star.
longzero (int or float):
Longitude of the sub-observer point when t=0, in radians.
Default is zero.
Returns:
trigvals (ndarray):
Array of trigonometric values with shape (8, *n_time*). First
dimension is organized as:
- sin theta_obs
- cos theta_obs
- sin phi_obs
- cos phi_obs
- sin theta_st
- cos theta_st
- sin phi_st
- cos phi_st
"""
if isinstance(times,np.ndarray) and (times.size == times.shape[0]):
timeA = times
N_time = timeA.size # Number of time steps from input array
elif isinstance(times,(int,float)):
timeA = np.array([times])
N_time = 1
else:
print('sub_observerstellar aborted: input times should be ndarray (1D), int, or float.')
return
phaseA = worb*timeA # Orbital phases
phiGen = wrot*timeA - longzero # General expression for PhiObs (without overall negative sign)
cThObs = (np.cos(inc)*np.cos(obl)) + (np.sin(inc)*np.sin(obl)*np.cos(sol))
cThObsfull = np.repeat(cThObs,N_time)
sThObs = (1.0 - (cThObs**2.0))**0.5
sThObsfull = np.repeat(sThObs,N_time)
cThSt = np.sin(obl)*np.cos(phaseA - sol)
sThSt = (1.0 - (cThSt**2.0))**0.5
sol_md = (sol % (2.0*pi))
inc_rd = round(inc,4) # Rounded inclination, for better comparison
p_obl_rd = round((pi - obl),4) # Rounded 180 degrees - obliquity, for better comparison
cond_face = (((inc == 0) or (inc == pi)) and ((obl == 0) or (obl == pi))) # Pole-observer 1: face-on inclination
cond_north = ((sol_md == 0) and ((inc == obl) or (inc_rd == -p_obl_rd))) # Ditto 2: North pole view
cond_south = ((sol == pi) and ((inc_rd == p_obl_rd) or (inc == -obl))) # Ditto 3: South pole view
if cond_face or cond_north or cond_south:
if (obl == (pi/2.0)):
aII = np.sin(phaseA)*np.cos(sol) # Special "double-over-pole" time-dependent factor
cPhiSt = np.ones(N_time)
sPhiSt = np.zeros(N_time)
g_i = (sThSt != 0) # Excluding "star-over-pole" situations (g_i are "good indicies")
cPhiSt[g_i] = (-np.sin(phiGen[g_i])*aII[g_i])/sThSt[g_i]
sPhiSt[g_i] = (-np.cos(phiGen[g_i])*aII[g_i])/sThSt[g_i]
else:
aI = np.cos(phaseA)*np.cos(obl) # Alternate "observer-over-pole" time-dependent factor
bI = | np.sin(phaseA) | numpy.sin |
import numpy as np
from argoverse.utils.mesh_grid import get_mesh_grid_as_point_cloud
def test_get_mesh_grid_as_point_cloud_3x3square():
"""
Sample a regular grid and return the (x,y) coordinates
of the sampled points.
"""
min_x = -3 # integer, minimum x-coordinate of 2D grid
max_x = -1 # integer, maximum x-coordinate of 2D grid
min_y = 2 # integer, minimum y-coordinate of 2D grid
max_y = 4 # integer, maximum y-coordinate of 2D grid
# return pts, a Numpy array of shape (N,2)
pts = get_mesh_grid_as_point_cloud(min_x, max_x, min_y, max_y, downsample_factor=1.0)
assert pts.shape == (9, 2)
gt_pts = np.array(
[
[-3.0, 2.0],
[-2.0, 2.0],
[-1.0, 2.0],
[-3.0, 3.0],
[-2.0, 3.0],
[-1.0, 3.0],
[-3.0, 4.0],
[-2.0, 4.0],
[-1.0, 4.0],
]
)
assert np.allclose(gt_pts, pts)
def test_get_mesh_grid_as_point_cloud_3x2rect():
"""
Sample a regular grid and return the (x,y) coordinates
of the sampled points.
"""
min_x = -3 # integer, minimum x-coordinate of 2D grid
max_x = -1 # integer, maximum x-coordinate of 2D grid
min_y = 2 # integer, minimum y-coordinate of 2D grid
max_y = 3 # integer, maximum y-coordinate of 2D grid
# return pts, a Numpy array of shape (N,2)
pts = get_mesh_grid_as_point_cloud(min_x, max_x, min_y, max_y, downsample_factor=1.0)
assert pts.shape == (6, 2)
gt_pts = np.array([[-3.0, 2.0], [-2.0, 2.0], [-1.0, 2.0], [-3.0, 3.0], [-2.0, 3.0], [-1.0, 3.0]])
assert | np.allclose(gt_pts, pts) | numpy.allclose |
"""
With thanks to 2019 SF2 Group 7 (<NAME> - <EMAIL>, <NAME> -
<EMAIL>), who did the bulk of the porting from matlab to Python.
"""
import warnings
import numpy as np
from .laplacian_pyramid import quant1, quant2
from .dct import dct_ii, colxfm, regroup
from .lbt import pot_ii
from cued_sf2_lab.dwt import idwt
from cued_sf2_lab.dwt import dwt
def nlevdwt(X, n):
# your code here
m = X.shape[0]
Q = X.copy()
for i in range(n):
Q[:m,:m]=dwt(Q[:m,:m])
m=m//2
return Q
def nlevidwt(Y, n):
m = Y.shape[0]//(2**(n-1))
Q = Y.copy()
for i in range(n):
Q[:m,:m] = idwt(Q[:m,:m])
m*=2
return Q
def quantdwt(Y, dwtstep,rise_ratio = None):
"""
Parameters:
Y: the output of `dwt(X, n)`
dwtstep: an array of shape `(3, n+1)`
Returns:
Yq: the quantized version of `Y`
dwtenc: an array of shape `(3, n+1)` containing the entropies
"""
n = dwtstep.shape[1]-1
m = Y.shape[0]
dwtent = np.zeros((3, n+1));
Q = Y.copy()
if rise_ratio is None:
rise_ratio = 0.5*np.ones(dwtstep.shape)
# print(rise_ratio)
for i in range(n):
m=m//2
Q[:m,m:2*m] = quantise(Y[:m,m:2*m], dwtstep[0,i],rise_ratio[0,i]*dwtstep[0,i])
dwtent[0,i]=bpp(Q[:m,m:2*m])
Q[m:2*m,:m] = quantise(Y[m:2*m,:m], dwtstep[1,i],rise_ratio[1,i]*dwtstep[1,i])
dwtent[1,i]=bpp(Q[m:2*m,:m])
Q[m:2*m,m:2*m] = quantise(Y[m:2*m,m:2*m], dwtstep[2,i],rise_ratio[2,i]*dwtstep[2,i])
dwtent[2,i]=bpp(Q[m:2*m,m:2*m])
Q[:m,:m] = quantise(Y[:m,:m], dwtstep[0,n],rise_ratio[0,n]*dwtstep[0,n])
dwtent[0,n] = bpp(Q[:m,:m])
return Q, dwtent
def get_quantisation_step_ratio(n):
''' Returns the quantisation ratios between successive images in the pyramid needed to
ensure equal MSE contribution'''
test_image = np.zeros((256,256))
Y = nlevdwt(test_image,n)
energies = np.zeros((3,n+1))
dwtstep = np.zeros((3,n+1))
m,x = Y.shape[0],Y.shape[1]
for i in range(n):
Y = nlevdwt(test_image,n)
# top right -> k = 0
# print(np.nonzero(Y))
Y[:m//2,x//2:x][Y[:m//2,x//2:x].shape[0]//2-1,Y[:m//2,x//2:x].shape[1]//2-1] = 100
Z = nlevidwt(Y,n)
energy_tr = np.sum(Z**2)
energies[0,i] = energy_tr
Y[:m//2,x//2:x][Y[:m//2,x//2:x].shape[0]//2-1,Y[:m//2,x//2:x].shape[1]//2-1] = 0
# bottom right -> k = 1
Y = nlevdwt(test_image,n)
# Ybr = Y[m//2:m,x//2:x]
# Ybr[Ybr.shape[0]//2-1,Ybr.shape[1]//2-1] = 100
# Y[m//2:m,x//2:x] = Ybr
Y[m//2:m,x//2:x][Y[m//2:m,x//2:x].shape[0]//2-1,Y[m//2:m,x//2:x].shape[1]//2-1] = 100
Z = nlevidwt(Y,n)
energy_br = np.sum(Z**2)
energies[1,i] = energy_br
# Ybr[Ybr.shape[0]//2-1,Ybr.shape[1]//2-1] = 0
# Y[m//2:m,x//2:x] = Ybr
Y[m//2:m,x//2:x][Y[m//2:m,x//2:x].shape[0]//2-1,Y[m//2:m,x//2:x].shape[1]//2-1] = 0
# bottom left -> k = 2
Y = nlevdwt(test_image,n)
Y[m//2:m,:x//2][Y[m//2:m,:x//2].shape[0]//2-1,Y[m//2:m,:x//2].shape[1]//2-1] = 100
# Ybr = Y[m//2:m,:x//2]
# Y[m//2:m,:x//2]
# Ybr[Ybr.shape[0]//2-1,Ybr.shape[1]//2-1] = 100
# Y[m//2:m,:x//2] = Ybr
Z = nlevidwt(Y,n)
energy_br = np.sum(Z**2)
energies[2,i] = energy_br
# Ybr[Ybr.shape[0]//2-1,Ybr.shape[1]//2-1] = 0
# Y[m//2:m,:x//2] = Ybr
Y[m//2:m,:x//2][Y[m//2:m,:x//2].shape[0]//2-1,Y[m//2:m,:x//2].shape[1]//2-1] = 0
m //= 2
x //= 2
Y = nlevdwt(test_image,n)
Y[:m,:x][Y[:m,:x].shape[0]//2-1,Y[:m,:x].shape[1]//2-1] = 100
Z = nlevidwt(Y,n)
energy_tr = np.sum(Z**2)
energies[0,n] = energy_tr
ratios = []
ratios = np.sqrt(energies[0,0]/energies)
Y[:m,:x][Y[:m,:x].shape[0]//2-1,Y[:m,:x].shape[1]//2-1] = 0
# for i in range(1,n):
# ratios.append([np.sqrt(energies[0,i-1]/energies[0,i]),np.sqrt(energies[1,i-1]/energies[1,i]),np.sqrt(energies[2,i-1]/energies[2,i])])
# ratios.append([np.sqrt(energies[0,n-1]/energies[0,n]),1,1])
return ratios
def diagscan(N):
'''
Generate diagonal scanning pattern
Return: scan: a diagonal scanning index for
an NxN matrix
The first entry in the matrix is assumed to be the DC coefficient
and is therefore not included in the scan
'''
# Copied from matlab without accounting for indexing.
slast = N + 1
scan = [slast]
while slast != N * N:
while slast > N and slast % N != 0:
slast = slast - (N - 1)
scan.append(slast)
if slast < N:
slast = slast + 1
else:
slast = slast + N
scan.append(slast)
if slast == N * N:
break
while slast < (N * N - N + 1) and slast % N != 1:
slast = slast + (N - 1)
scan.append(slast)
if slast == N * N:
break
if slast < (N * N - N + 1):
slast = slast + N
else:
slast = slast + 1
scan.append(slast)
# Python indexing
return np.array(scan) - 1
def runampl(a):
'''
RUNAMPL Create a run-amplitude encoding from input stream
[ra] = RUNAMPL(a) Converts the stream of integers in 'a' to a
run-amplltude encoding in 'ra'
Column 1 of ra gives the runs of zeros between each non-zero value.
Column 2 gives the JPEG sizes of the non-zero values (no of
bits excluding leading zeros).
Column 3 of ra gives the values of the JPEG remainder, which
is normally coded in offset binary.
Parameters:
a: is a integer stream (array)
Returns:
ra: (,3) nparray
'''
# Check for non integer values in a
if sum(abs(np.remainder(a, 1))):
raise ValueError("Warning! RUNAMPL.M: Attempting to create" +
" run-amplitude from non-integer values")
b = np.where(a != 0)[0]
if len(b) == 0:
ra = np.array([[0, 0, 0]])
return ra
# List non-zero elements as a column vector
c = np.reshape(a[b], (b.shape[0], 1)).astype('int')
# Generate JPEG size vector ca = floor(log2(abs(c)) + 1)
ca = np.zeros(c.shape).astype('int')
k = 1
cb = np.abs(c)
maxc = np.max(cb)
ka = np.array([[1]])
while k <= maxc:
ca = ca + (cb >= k)
k = k * 2
ka = np.concatenate((ka, np.array([[k]])))
cneg = np.where(c < 0)[0]
# Changes expression for python indexing
c[cneg] = c[cneg] + ka[ca[cneg].flatten()] - 1
bcol = np.reshape(b, (len(b), 1))
# appended -1 instead of 0.
col1 = np.diff(np.concatenate((np.array([[-1]]), bcol)).flatten()) - 1
col1 = np.reshape(col1, (col1.shape[0], 1))
ra = np.concatenate((col1, ca, c), axis=1)
ra = np.concatenate((ra, np.array([[0, 0, 0]])))
return ra
def huffdflt(typ):
"""
HUFFDFLT Generates default JPEG huffman table
[bits, huffval] = HUFFDFLT(type) Produces the luminance (type=1) or
chrominance (type=2) tables.
The number of values per bit level is stored in 'bits', with the
corresponding codes in 'huffval'.
Parameters:
typ: Integer
Returns:
bits: (16, ) nparray
huffval: (162, ) nparray
"""
if typ == 1:
bits = np.array([0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125])
huffval = np.concatenate((
[], # 1-bit
[1, 2], # 2-bit
[3], # 3-bit
[0, 4, 17], # 4-bit
[5, 18, 33], # 5-bit
[49, 65], # 6-bit
[6, 19, 81, 97], # 7-bit
[7, 34, 113], # 8-bit
[20, 50, 129, 145, 161], # 9-bit
[8, 35, 66, 177, 193], # 10-bit
[21, 82, 209, 240], # 11-bit
[36, 51, 98, 114], # 12-bit
[], # 13-bit
[], # 14-bit
[130], # 15-bit
[9, 10, 22, 23, 24, 25, 26, 37, 38, 39,
40, 41, 42, 52, 53, 54, 55], # 16-bit
[56, 57, 58, 67, 68, 69, 70, 71, 72,
73, 74, 83, 84, 85, 86, 87, 88, 89],
[90, 99, 100, 101, 102, 103, 104, 105, 106,
115, 116, 117, 118, 119, 120, 121, 122, 131],
[132, 133, 134, 135, 136, 137, 138, 146, 147,
148, 149, 150, 151, 152, 153, 154, 162, 163],
[164, 165, 166, 167, 168, 169, 170, 178, 179,
180, 181, 182, 183, 184, 185, 186, 194, 195],
[196, 197, 198, 199, 200, 201, 202, 210, 211,
212, 213, 214, 215, 216, 217, 218, 225, 226],
[227, 228, 229, 230, 231, 232, 233, 234, 241,
242, 243, 244, 245, 246, 247, 248, 249, 250]
)).astype('int')
else:
bits = np.array([0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119])
huffval = np.concatenate((
[], # 1-bit
[0, 1], # 2-bit
[2], # 3-bit
[3, 17], # 4-bit
[4, 5, 33, 49], # 5-bit
[6, 18, 65, 81], # 6-bit
[7, 97, 113], # 7-bit
[19, 34, 50, 129], # 8-bit
[8, 20, 66, 145, 161, 177, 193], # 9-bit
[9, 35, 51, 82, 240], # 10-bit
[21, 98, 114, 209], # 11-bit
[10, 22, 36, 52], # 12-bit
[], # 13-bit
[225], # 14-bit
[37, 241], # 15-bit
[23, 24, 25, 26, 38, 39, 40, 41, 42, 53, 54], # 16-bit
[55, 56, 57, 58, 67, 68, 69, 70, 71,
72, 73, 74, 83, 84, 85, 86, 87, 88],
[89, 90, 99, 100, 101, 102, 103, 104, 105,
106, 115, 116, 117, 118, 119, 120, 121, 122],
[130, 131, 132, 133, 134, 135, 136, 137, 138,
146, 147, 148, 149, 150, 151, 152, 153, 154],
[162, 163, 164, 165, 166, 167, 168, 169, 170,
178, 179, 180, 181, 182, 183, 184, 185, 186],
[194, 195, 196, 197, 198, 199, 200, 201, 202,
210, 211, 212, 213, 214, 215, 216, 217, 218],
[226, 227, 228, 229, 230, 231, 232, 233, 234,
242, 243, 244, 245, 246, 247, 248, 249, 250]
)).astype('int')
return [bits, huffval]
def huffgen(bits, huffval):
"""
HUFFGEN Generate huffman codes
[huffcode, ehuf] = HUFFGEN(bits, huffval) Translates the number
of codes at each bit (in bits) and the valid values (in huffval).
huffcode lists the valid codes in ascending order. ehuf is a
two-column vector, with one entry per possible 8-bit value. The
first column lists the code for that value, and the second lists
the length in bits.
Parameters:
bits: 1D Numpy array.
huffval: 1D Numpy array.
Returns:
huffcode: nparray (ncodes, 1)
ehuf: nparray (256, 2)
"""
# Generate huffman size table (JPEG fig C1, p78):
nb = bits.shape[0]
k = 1 # Max value of k is 162
j = 1
# sum on nparray sums columns.
ncodes = sum(bits)
# Check every where 1_D array of zeros/ones defined like this.
huffsize = np.zeros((ncodes, 1), dtype=int)
for i in range(nb):
while j <= bits[i]:
huffsize[k - 1, 0] = i + 1
k += 1
j += 1
j = 1
huffcode = np.zeros((ncodes, 1), dtype=int)
code = 0
si = huffsize[0, 0]
# Generate huffman code table (JPEG fig C2, p79)
for k in range(ncodes):
while huffsize[k, 0] > si:
code = code * 2
si += 1
huffcode[k, 0] = code
code += 1
# Reorder the code tables according to the data in
# huffval to yield the encoder look-up tables.
ehuf = np.zeros((256, 2), dtype=int)
ehuf[huffval, :] = np.concatenate((huffcode, huffsize), axis=1)
return [huffcode, ehuf]
def huffdes(huffhist):
"""
HUFFDES Design Huffman table
** WARNING THIS CODE IS CURRENTLY KNOWN TO PRODUCE RESULTS DIFFERENT TO THE MATLAB ON WHICH IT IS BASED **
[bits, huffval] = huffdes(huffhist) Generates the JPEG table
bits and huffval from the 256-point histogram of values huffhist.
This is based on the algorithms in the JPEG Book Appendix K.2.
Returns:
bits = (16, ) nparray
huffval = (162, ) nparray
"""
warnings.warn("""The huffdes function produces different results to the matlab code it is based on.
Use at your own risk!""")
# Scale huffhist to sum just less than 32K, allowing for
# the 162 ones we are about to add.
huffhist = huffhist * (127 * 256)/np.sum(huffhist)
# Add 1 to all valid points so they are given a code word.
# With the scaling, this should ensure that all probabilities exceed
# 1 in 2^16 so that no code words exceed 16 bits in length.
# This is probably a better method with poor statistics
# than the JPEG method of fig K.3.
# Every 16 values made column.
freq = np.reshape(huffhist, (16, 16), 'F')
freq[1:10, :] = freq[1:10, :] + 1.1
freq[0, [0, 15]] = freq[0, [0, 15]] + 1.1
# Reshape to a vector and add a 257th point to reserve the FFFF codeword.
# Also add a small negative ramp so that min() always picks the
# larger index when 2 points have the same probability.
freq = (np.append(freq.flatten('F'), 1) -
np.arange(0, 257, 1) * (10 ** -6))
codesize = np.zeros(257, dtype=int)
others = -np.ones(257, dtype=int)
# Find Huffman code sizes: JPEG fig K.1, procedure Code_size
# Find non-zero entries in freq and loop until 1 entry left.
nz = np.where(freq > 0)[0] # np.where output is 2 element tuple.
while len(nz) > 1:
# Find v1 for least value of freq(v1) > 0.
# min in each column
i = np.argmin(freq[nz]) # freq[nz] and nz index
v1 = nz[i]
# Find v2 for next least value of freq(v2) > 0.
nz = np.delete(nz, i) # Remove v1 from nz.
i = np.argmin(freq[nz]) # freq[nz] and nz index
v2 = nz[i]
# Combine frequency values to gradually reduce the code table size.
freq[v1] = freq[v1] + freq[v2]
freq[v2] = 0
# Increment the codeword lengths for all codes in the two combined sets.
# Set 1 is v1 and all its members, stored as a linked list using
# non-negative entries in vector others(). The members of set 1 are the
# frequencies that have already been combined into freq(v1).
codesize[v1] += 1
while others[v1] > -1:
v1 = others[v1]
codesize[v1] += 1
others[v1] = v2 # Link set 1 with set 2.
# Set 2 is v2 and all its members, stored as a linked list using
# non-negative entries in vector others(). The members of set 2 are the
# frequencies that have already been combined into freq(v2).
codesize[v2] = codesize[v2] + 1
while others[v2] > -1:
v2 = others[v2]
codesize[v2] = codesize[v2] + 1
nz = np.where(freq > 0)[0]
# Find no. of codes of each size: JPEG fig K.2, procedure Count_BITS
bits = np.zeros(max(16, max(codesize)))
for i in range(256):
if codesize[i] > 0:
bits[codesize[i]] = bits[codesize[i]] + 1
# Code length limiting not needed since 1's added earlier to all valid
# codes.
if max(codesize) > 16:
# This should not happen.
raise ValueError('Warning! HUFFDES.M: max(codesize) > 16')
# Sort codesize values into ascending order and generate huffval:
# JPEG fig K.4, procedure Sort_input.
huffval = np.array([], dtype=int)
t = np.arange(0, 256, 1)
for i in range(16):
ii = np.where(codesize[t] == i)[0]
huffval = np.concatenate((huffval, ii))
if len(huffval) != sum(bits):
# This should not happen.
raise ValueError(
'Warning! HUFFDES.M: length of huffval ~= sum(bits)')
return [bits, huffval]
def huffenc(huffhist, rsa, ehuf):
"""
HUFFENC Convert a run-length encoded stream to huffman
coding.
[vlc] = HUFFENC(rsa) Performs Huffman encoding on the
run-length information in rsa, as produced by RUNAMPL.
THe codewords are variable length integers in vlc(:, 0)
whose lengths are in vlc(:, 1). ehuf contains the huffman
codes and their lengths. The array huffhist is
updated in-place for use in HUFFGEN.
"""
if max(rsa[:, 1]) > 10:
print("Warning: Size of value in run-amplitude " +
"code is too large for Huffman table")
rsa[np.where(rsa[:, 1] > 10), 2] = (2 ** 10) - 1
rsa[np.where(rsa[:, 1] > 10), 1] = 10
r, c = rsa.shape
vlc = None
for i in range(r):
run = rsa[i, 0]
# If run > 15, use repeated codes for 16 zeros.
while run > 15:
# Got rid off + 1 to suit python indexing.
code = 15 * 16
huffhist[code] = huffhist[code] + 1
if vlc is None:
vlc = np.array([ehuf[code, :]])
else:
vlc = np.append(vlc, np.array([ehuf[code, :]]), axis=0)
run = run - 16
# Code the run and size.
# Got rid off + 1 to suit python indexing.
code = run * 16 + rsa[i, 1]
huffhist[code] = huffhist[code] + 1
if vlc is None:
vlc = np.array([ehuf[code, :]])
else:
vlc = np.append(vlc, np.array([ehuf[code, :]]), axis=0)
# If size > 0, add in the remainder (which is not coded).
if rsa[i, 1] > 0:
if vlc is None:
vlc = np.array([rsa[i, [2, 1]]])
else:
vlc = np.append(vlc, np.array([rsa[i, [2, 1]]]), axis=0)
return vlc
def dwtgroup(X, n):
'''
dwtgroup Change ordering of elements in a matrix
Y = dwtgroup(X,n) Regroups the rows and columns of X, such that an
n-level DWT image composed of separate subimages is regrouped into 2^n x
2^n blocks of coefs from the same spatial region (like the DCT).
If n is negative the process is reversed.
'''
Y = X.copy()
if n == 0:
return Y
elif n < 0:
n = -n
invert = 1
else:
invert = 0
sx = X.shape
N = np.round(2**n)
if sx[0] % N != 0 or sx[1] % N != 0:
raise ValueError(
'Error in dwtgroup: X dimensions are not multiples of 2^n')
if invert == 0:
# Determine size of smallest sub-image.
sx = sx // N
# Regroup the 4 subimages at each level, starting with the smallest
# subimages in the top left corner of Y.
k = 1 # Size of blocks of pels at each level.
# tm = 1:sx[0];
# tn = 1:sx[1];
tm = np.arange(sx[0])
tn = np.arange(sx[1])
# Loop for each level.
for _ in range(n):
tm2 = np.block([
[np.reshape(tm, (k, sx[0]//k), order='F')],
[np.reshape(tm+sx[0], (k, sx[0]//k), order='F')]
])
tn2 = np.block([
[np.reshape(tn, (k, sx[1]//k), order='F')],
[np.reshape(tn+sx[1], (k, sx[1]//k), order='F')]
])
sx = sx * 2
k = k * 2
tm = np.arange(sx[0])
tn = np.arange(sx[1])
Y[np.ix_(tm, tn)] = Y[np.ix_(
tm2.flatten('F'), tn2.flatten('F'))]
else:
# Invert the grouping:
# Determine size of largest sub-image.
sx = np.array(X.shape) // 2
# Regroup the 4 subimages at each level, starting with the largest
# subimages in Y.
k = N // 2 # Size of blocks of pels at each level.
# Loop for each level.
for _ in np.arange(n):
tm = np.arange(sx[0])
tn = np.arange(sx[1])
tm2 = np.block([
[np.reshape(tm, (k, sx[0]//k), order='F')],
[np.reshape(tm+sx[0], (k, sx[0]//k), order='F')]
])
tn2 = np.block([
[np.reshape(tn, (k, sx[1]//k), order='F')],
[np.reshape(tn+sx[1], (k, sx[1]//k), order='F')]
])
Y[np.ix_(tm2.flatten('F'), tn2.flatten('F'))] = Y[np.ix_(
np.arange(sx[0]*2), np.arange(sx[1]*2))]
sx = sx // 2
k = k // 2
return Y
def custom_quant1(x, N, step,quantisation_matrix, rise_ratio=None):
"""
Custom Quantisation with a defined N*N matrix
For a given value of step, we quantise in terms of step*quantisation matrix
rise_ratio should be given in terms of the ratio between the absolute rise and step size. The final absolute
rise values will be rise = rise_ratio*step*quantisation_matrix
"""
if rise_ratio is None:
rise_ratio = 1
step *= quantisation_matrix
rise = rise_ratio*step
out = np.zeros(x.shape)
indices = np.arange(0,x.shape[0])
indices = np.reshape(np.reshape(indices,(x.shape[0]//N,N)).T,x.shape[0])
for i in range(N):
k = indices[i*(x.shape[0]//N):(i+1)*(x.shape[0]//N)]
for j in range(N):
l = indices[j*(x.shape[1]//N):(j+1)*(x.shape[1]//N)]
u,v = np.meshgrid(k,l) # Relevant indices (0,8,16,.....)
temp = np.ceil((np.abs(x[u,v]) - rise[i,j])/step[i,j])
q = temp*(temp > 0)*np.sign(x[u,v])
out[u,v] = q
return out
def custom_quant2(q, N, step,quantisation_matrix, rise_ratio=None):
"""
Custom Quantisation with a defined N*N matrix
For a given value of step, we quantise in terms of step*quantisation matrix
rise_ratio should be given in terms of the ratio between the absolute rise and step size. It can be a matrix of size N*N or a float
The final absolute rise values will be rise = rise_ratio*step*quantisation_matrix
"""
if rise_ratio is None:
rise_ratio = 1
step *= quantisation_matrix
rise = rise_ratio*step
out = np.zeros(q.shape)
indices = np.arange(0,q.shape[0])
indices = np.reshape(np.reshape(indices,(q.shape[0]//N,N)).T,q.shape[0])
for i in range(N):
k = indices[i*(q.shape[0]//N):(i+1)*(q.shape[0]//N)]
for j in range(N):
l = indices[j*(q.shape[1]//N):(j+1)*(q.shape[1]//N)]
u,v = np.meshgrid(k,l) # Relevant indices (0,8,16,.....)
y = q[u,v] * step[i,j] + np.sign(q[u,v]) * (rise[i,j] - step[i,j]/2.0)
out[u,v] = y
return out
def lbt_enc(X,N,s=None):
if s:
Pf,Pr = pot_ii(N,s)
else:
Pf,Pr = pot_ii(N)
C = dct_ii(N)
t = np.s_[N//2:-N//2] # N is the DCT size, I is the image size
Xp = X.copy() # copy the non-transformed edges directly from X
Xp[t,:] = colxfm(Xp[t,:], Pf)
Xp[:,t] = colxfm(Xp[:,t].T, Pf).T
Y = colxfm(colxfm(Xp, C).T, C).T
return Y
def lbt_dec(Y,N,s=None):
if s:
Pf,Pr = pot_ii(N,s)
else:
Pf,Pr = pot_ii(N)
C = dct_ii(N)
t = np.s_[N//2:-N//2]
Z = colxfm(colxfm(Y.T, C.T).T, C.T)
Zp = Z.copy()
Zp[:,t] = colxfm(Zp[:,t].T, Pr.T).T
Zp[t,:] = colxfm(Zp[t,:], Pr.T)
return Zp
def dct_enc(X, N):
C = dct_ii(N)
Y = colxfm(colxfm(X, C).T, C).T
return Y
def dct_dec(Y,N):
C = dct_ii(N)
Z = colxfm(colxfm(Y.T, C.T).T, C.T)
return Z
def jpegenc(X, qstep, N=8, M=8, opthuff=False, dcbits=8, log=True,s = 1.33,quantisation_matrix = None, frequency_quant = False,enc_type = 'dct'):
'''
Image in X to generate the variable length bit stream in vlc.
X is the input greyscale image
qstep is the quantisation step to use in encoding
N is the width of the DCT block (defaults to 8)
M is the width of each block to be coded (defaults to N). Must be an
integer multiple of N - if it is larger, individual blocks are
regrouped.
if opthuff is true (defaults to false), the Huffman table is optimised
based on the data in X
determines how many bits are used to encode the DC coefficients
of the DCT (defaults to 8)
Return: vlc, bits, huffval
vlc is the variable length output code, where vlc[:,0] are the codes, and
vlc[:,1] the number of corresponding valid bits, so that sum(vlc[:,1])
gives the total number of bits in the image
bits and huffval are optional outputs which return the Huffman encoding
used in compression
'''
if opthuff:
warnings.warn("""The opthuff argument to jpegenc calls the huffdes function.
The huffdes code produces different results to the matlab code it is based on.
Use at your own risk!""")
if M % N != 0:
raise ValueError('M must be an integer multiple of N!')
# DCT on input image X.
if log:
print('Forward {} x {} DCT'.format(N, N))
if enc_type == 'dct':
C8 = dct_ii(N)
Y = colxfm(colxfm(X, C8).T, C8).T
elif enc_type == 'lbt':
Y = lbt_enc(X,N,s)
elif enc_type == 'dwt':
Y = dwtgroup(nlevdwt(X,N),N)
# Quantise to integers.
if log:
print('Quantising to step size of {}'.format(qstep))
if not frequency_quant:
Yq = quant1(Y, qstep, qstep).astype('int')
else:
Yq = custom_quant1(Y, N, qstep, quantisation_matrix,1).astype('int')
# Generate zig-zag scan of AC coefs.
scan = diagscan(M)
# On the first pass use default huffman tables.
if log:
print('Generating huffcode and ehuf using default tables')
dbits, dhuffval = huffdflt(1) # Default tables.
huffcode, ehuf = huffgen(dbits, dhuffval)
# Generate run/ampl values and code them into vlc(:,1:2).
# Also generate a histogram of code symbols.
if log:
print('Coding rows')
sy = Yq.shape
t = np.arange(M)
huffhist = np.zeros(16 ** 2)
vlc = None
for r in range(0, sy[0], M):
vlc1 = None
for c in range(0, sy[1], M):
yq = Yq[np.ix_(r+t, c+t)]
# Possibly regroup
if M > N:
yq = regroup(yq, N)
yqflat = yq.flatten('F')
# Encode DC coefficient first
yqflat[0] += 2 ** (dcbits-1)
if yqflat[0] < 0 or yqflat[0] > (2**dcbits) - 1:
raise ValueError(
'DC coefficients too large for desired number of bits')
dccoef = np.array([[yqflat[0], dcbits]])
# Encode the other AC coefficients in scan order
ra1 = runampl(yqflat[scan])
# huffenc() also updates huffhist.
if vlc1 is None:
vlc1 = np.block([[dccoef], [huffenc(huffhist, ra1, ehuf)]])
else:
vlc1 = np.block(
[[vlc1], [dccoef], [huffenc(huffhist, ra1, ehuf)]])
if vlc is None:
vlc = vlc1
else:
vlc = np.block([[vlc], [vlc1]])
# Return here if the default tables are sufficient, otherwise repeat the
# encoding process using the custom designed huffman tables.
if not opthuff:
bits = dbits
huffval = dhuffval
if log:
print('Bits for coded image = {}'.format(sum(vlc[:, 1])))
return vlc.astype('int'), bits, huffval
# Design custom huffman tables.
if log:
print('Generating huffcode and ehuf using custom tables')
dbits, dhuffval = huffdes(huffhist)
huffcode, ehuf = huffgen(dbits, dhuffval)
# Generate run/ampl values and code them into vlc(:,1:2).
# Also generate a histogram of code symbols.
if log:
print('Coding rows (second pass)')
t = | np.arange(M) | numpy.arange |
#------------------------------------------------------------------------------
# Copyright (C) 1996-2010 Power System Engineering Research Center (PSERC)
# Copyright (C) 2007-2010 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#------------------------------------------------------------------------------
""" Defines a DC OPF solver and an AC OPF solver.
Based on dcopf_solver.m and mipsopf_solver.m from MATPOWER by <NAME>,
developed at Cornell. See U{http://www.pserc.cornell.edu/matpower/} for more
information.
"""
#------------------------------------------------------------------------------
# Imports:
#------------------------------------------------------------------------------
import logging
from numpy import \
array, pi, polyder, polyval, exp, conj, Inf, ones, r_, zeros, asarray
from scipy.sparse import lil_matrix, csr_matrix, hstack, vstack
from case import REFERENCE
from generator import POLYNOMIAL, PW_LINEAR
#from pdipm import pdipm, pdipm_qp
from pips import pips, qps_pips
#------------------------------------------------------------------------------
# Constants:
#------------------------------------------------------------------------------
SFLOW = "Sflow"
PFLOW = "Pflow"
IFLOW = "Iflow"
#------------------------------------------------------------------------------
# Logging:
#------------------------------------------------------------------------------
logger = logging.getLogger(__name__)
#------------------------------------------------------------------------------
# "_Solver" class:
#------------------------------------------------------------------------------
class _Solver(object):
""" Defines a base class for many solvers.
"""
def __init__(self, om):
#: Optimal power flow model.
self.om = om
#: Number of equality constraints.
self._nieq = 0
def solve(self):
""" Solves optimal power flow and returns a results dict.
"""
raise NotImplementedError
def _unpack_model(self, om):
""" Returns data from the OPF model.
"""
buses = om.case.connected_buses
branches = om.case.online_branches
gens = om.case.online_generators
cp = om.get_cost_params()
# Bf = om._Bf
# Pfinj = om._Pfinj
return buses, branches, gens, cp
def _dimension_data(self, buses, branches, generators):
""" Returns the problem dimensions.
"""
ipol = [i for i, g in enumerate(generators)
if g.pcost_model == POLYNOMIAL]
ipwl = [i for i, g in enumerate(generators)
if g.pcost_model == PW_LINEAR]
nb = len(buses)
nl = len(branches)
# Number of general cost vars, w.
nw = self.om.cost_N
# Number of piece-wise linear costs.
if "y" in [v.name for v in self.om.vars]:
ny = self.om.get_var_N("y")
else:
ny = 0
# Total number of control variables of all types.
nxyz = self.om.var_N
return ipol, ipwl, nb, nl, nw, ny, nxyz
def _linear_constraints(self, om):
""" Returns the linear problem constraints.
"""
A, l, u = om.linear_constraints() # l <= A*x <= u
# Indexes for equality, greater than (unbounded above), less than
# (unbounded below) and doubly-bounded box constraints.
# ieq = flatnonzero( abs(u - l) <= EPS )
# igt = flatnonzero( (u >= 1e10) & (l > -1e10) )
# ilt = flatnonzero( (l <= -1e10) & (u < 1e10) )
# ibx = flatnonzero( (abs(u - l) > EPS) & (u < 1e10) & (l > -1e10) )
# Zero-sized sparse matrices not supported. Assume equality
# constraints exist.
## AA = A[ieq, :]
## if len(ilt) > 0:
## AA = vstack([AA, A[ilt, :]], "csr")
## if len(igt) > 0:
## AA = vstack([AA, -A[igt, :]], "csr")
## if len(ibx) > 0:
## AA = vstack([AA, A[ibx, :], -A[ibx, :]], "csr")
#
# if len(ieq) or len(igt) or len(ilt) or len(ibx):
# sig_idx = [(1, ieq), (1, ilt), (-1, igt), (1, ibx), (-1, ibx)]
# AA = vstack([sig * A[idx, :] for sig, idx in sig_idx if len(idx)])
# else:
# AA = None
#
# bb = r_[u[ieq, :], u[ilt], -l[igt], u[ibx], -l[ibx]]
#
# self._nieq = ieq.shape[0]
#
# return AA, bb
return A, l, u
def _var_bounds(self):
""" Returns bounds on the optimisation variables.
"""
x0 = array([])
xmin = array([])
xmax = array([])
for var in self.om.vars:
x0 = r_[x0, var.v0]
xmin = r_[xmin, var.vl]
xmax = r_[xmax, var.vu]
return x0, xmin, xmax
def _initial_interior_point(self, buses, generators, xmin, xmax, ny):
""" Selects an interior initial point for interior point solver.
"""
Va = self.om.get_var("Va")
va_refs = [b.v_angle * pi / 180.0 for b in buses
if b.type == REFERENCE]
x0 = (xmin + xmax) / 2.0
x0[Va.i1:Va.iN + 1] = va_refs[0] # Angles set to first reference angle.
if ny > 0:
yvar = self.om.get_var("y")
# Largest y-value in CCV data
c = []
for g in generators:
if g.pcost_model == PW_LINEAR:
for _, y in g.p_cost:
c.append(y)
x0[yvar.i1:yvar.iN + 1] = max(c) * 1.1
return x0
#------------------------------------------------------------------------------
# "DCOPFSolver" class:
#------------------------------------------------------------------------------
class DCOPFSolver(_Solver):
""" Defines a solver for DC optimal power flow [3].
Based on dcopf_solver.m from MATPOWER by <NAME>, developed at PSERC
Cornell. See U{http://www.pserc.cornell.edu/matpower/} for more info.
"""
def __init__(self, om, opt=None):
""" Initialises a new DCOPFSolver instance.
"""
super(DCOPFSolver, self).__init__(om)
# TODO: Implement user-defined costs.
self.N = None
self.H = None
self.Cw = zeros((0, 0))
self.fparm = zeros((0, 0))
#: Solver options (See pips.py for futher details).
self.opt = {} if opt is None else opt
def solve(self):
""" Solves DC optimal power flow and returns a results dict.
"""
base_mva = self.om.case.base_mva
Bf = self.om._Bf
Pfinj = self.om._Pfinj
# Unpack the OPF model.
bs, ln, gn, cp = self._unpack_model(self.om)
# Compute problem dimensions.
ipol, ipwl, nb, nl, nw, ny, nxyz = self._dimension_data(bs, ln, gn)
# Split the constraints in equality and inequality.
AA, ll, uu = self._linear_constraints(self.om)
# Piece-wise linear components of the objective function.
Npwl, Hpwl, Cpwl, fparm_pwl, any_pwl = self._pwl_costs(ny, nxyz, ipwl)
# Quadratic components of the objective function.
Npol, Hpol, Cpol, fparm_pol, polycf, npol = \
self._quadratic_costs(gn, ipol, nxyz, base_mva)
# Combine pwl, poly and user costs.
NN, HHw, CCw, ffparm = \
self._combine_costs(Npwl, Hpwl, Cpwl, fparm_pwl, any_pwl,
Npol, Hpol, Cpol, fparm_pol, npol, nw)
# Transform quadratic coefficients for w into coefficients for X.
HH, CC, C0 = self._transform_coefficients(NN, HHw, CCw, ffparm, polycf,
any_pwl, npol, nw)
# Bounds on the optimisation variables.
_, xmin, xmax = self._var_bounds()
# Select an interior initial point for interior point solver.
x0 = self._initial_interior_point(bs, gn, xmin, xmax, ny)
# Call the quadratic/linear solver.
s = self._run_opf(HH, CC, AA, ll, uu, xmin, xmax, x0, self.opt)
# Compute the objective function value.
Va, Pg = self._update_solution_data(s, HH, CC, C0)
# Set case result attributes.
self._update_case(bs, ln, gn, base_mva, Bf, Pfinj, Va, Pg, s["lmbda"])
return s
def _pwl_costs(self, ny, nxyz, ipwl):
""" Returns the piece-wise linear components of the objective function.
"""
any_pwl = int(ny > 0)
if any_pwl:
y = self.om.get_var("y")
# Sum of y vars.
Npwl = csr_matrix((ones(ny), (zeros(ny), array(ipwl) + y.i1)))
Hpwl = csr_matrix((1, 1))
Cpwl = array([1])
fparm_pwl = array([[1., 0., 0., 1.]])
else:
Npwl = None#zeros((0, nxyz))
Hpwl = None#array([])
Cpwl = array([])
fparm_pwl = zeros((0, 4))
return Npwl, Hpwl, Cpwl, fparm_pwl, any_pwl
def _quadratic_costs(self, generators, ipol, nxyz, base_mva):
""" Returns the quadratic cost components of the objective function.
"""
npol = len(ipol)
rnpol = range(npol)
gpol = [g for g in generators if g.pcost_model == POLYNOMIAL]
if [g for g in gpol if len(g.p_cost) > 3]:
logger.error("Order of polynomial cost greater than quadratic.")
iqdr = [i for i, g in enumerate(generators)
if g.pcost_model == POLYNOMIAL and len(g.p_cost) == 3]
ilin = [i for i, g in enumerate(generators)
if g.pcost_model == POLYNOMIAL and len(g.p_cost) == 2]
polycf = | zeros((npol, 3)) | numpy.zeros |
import pandas as pd
import numpy as np
import pvlib
import trimesh
import meshio
from ..client.client import Client
from copy import copy
import pickle
from pathlib import Path
import os
def generate_irradiation_vector(time, north_angle=0):
data, metadata = pvlib.iotools.read_epw(r'resources/AUT_Vienna.Schwechat.110360_IWEC.epw')
location = pvlib.location.Location.from_epw(metadata)
solar_position = location.get_solarposition(time)
phi = np.deg2rad(- (solar_position.azimuth.values + north_angle))
theta = np.deg2rad(solar_position.elevation.values)
cos_theta = np.cos(theta)
irradiation_vector = np.zeros([time.shape[0], 3], dtype=np.float32)
irradiation_vector[:, 0] = - cos_theta * np.cos(phi)
irradiation_vector[:, 1] = - cos_theta * np.sin(phi)
irradiation_vector[:, 2] = - np.sin(theta)
df = pd.DataFrame(index=time,
columns=['irradiation_vector'])
df['irradiation_vector'] = [x for x in irradiation_vector]
return df
def create_sun_window(mesh, irradiation_vector):
n = irradiation_vector.shape[0]
u, v = two_orthogonal_vectors(irradiation_vector)
sun_cs = np.empty((n, 3, 3))
sun_cs[:, 0, :] = u
sun_cs[:, 1, :] = v
sun_cs[:, 2, :] = irradiation_vector
rectangles = np.empty((n, 4, 3))
oriented_mesh_corners = trimesh.bounds.corners(mesh.bounding_box_oriented.bounds).T
for i in range(n):
rot = sun_cs[i, :, :]
rectangle = calc_local_rect(rot, oriented_mesh_corners)
rectangles[i, :, :] = np.linalg.inv(rot).dot(rectangle.T).T
return rectangles
def two_orthogonal_vectors(vector):
if isinstance(vector, pd.DataFrame):
vector = vector.values
if vector.shape.__len__() == 1:
vector = np.array([vector])
x, y = generate_basis_vectorized(vector)
return x, y
def generate_basis_vectorized(z):
"""
from: trimesh.util.generate_basis
Generate an arbitrary basis (also known as a coordinate frame)
from a given z-axis vector.
Parameters
------------
z : (3,) float
A vector along the positive z-axis.
epsilon : float
Numbers smaller than this considered zero.
Returns
---------
x : (3,) float
Vector along x axis.
y : (3,) float
Vector along y axis.
z : (3,) float
Vector along z axis.
"""
epsilon = 1e-12
# X as arbitrary perpendicular vector
x = np.zeros((z.shape[0], 3))
x[:, 0] = -z[:, 1]
x[:, 1] = z[:, 0]
# avoid degenerate case
x_norm = trimesh.util.row_norm(x)
ind1 = x_norm < epsilon
x[ind1, 0] = -z[ind1, 2]
x[ind1, 1] = z[ind1, 1]
x[ind1, 2] = z[ind1, 0]
x[ind1, :] /= trimesh.util.row_norm(x[ind1, :])[:, None]
x[np.logical_not(ind1), :] /= trimesh.util.row_norm(x[np.logical_not(ind1), :])[:, None]
# get perpendicular Y with cross product
y = np.cross(z, x)
return x, y
def calc_local_rect(rot_mat, oriented_mesh_corners):
import cv2
local_oriented_corners = rot_mat.dot(oriented_mesh_corners).T
z_translation = -abs(min(local_oriented_corners[:, 2]) * 1.1)
rec = np.zeros((4, 3))
local_points = local_oriented_corners[:, 0:2]
c_hull = cv2.convexHull(local_points.astype('float32'))
local_rectangle = cv2.boxPoints(cv2.minAreaRect(c_hull))
rec[:, 0:2] = local_rectangle
rec[:, 2] = z_translation
return rec
def sample_rectangle(rect, n, scale=1.01, method='length_dependent'):
"""
create equally distant points in rectangle
:param rect: edge points of the rectangle (4 * 3)
:param n: number of points
:param scale: scale rectangle
:param method: how to sample points:
constant: n points along x' and y';
constant_adapted: n^2 = n1 * n2 points in total. n1 and n2 according to length of x' and y'; l
length_dependent: number of points = (x' / n) * (y' / n) ; n is distance between points
:return: sampled points (n * 3)
"""
# scale rectangle
if scale != 1:
center = rect[0, :] + (rect[2, :] - rect[0, :]) * 0.5
rect = (rect - center) * scale + center
origin = (rect[0, :]).astype(np.float32)
vec0 = (rect[1, :] - origin).astype(np.float32)
vec1 = (rect[-1, :] - origin).astype(np.float32)
area = np.linalg.norm(vec0) * np.linalg.norm(vec1)
if method == 'constant':
spaces = np.linspace(0, 1, n, dtype=np.float32)
n_spaces = spaces.shape[0]
points = ((np.transpose(np.broadcast_to(vec1 * spaces[:, None], (n_spaces, n_spaces, 3)), axes=(1, 0, 2)) + \
np.broadcast_to(vec0 * spaces[:, None], (n_spaces, n_spaces, 3)) + \
origin[None, None, :])).reshape(n_spaces**2, 3)
else:
if method == 'constant_adapted':
frac = np.linalg.norm(vec0) / np.linalg.norm(vec1)
n1 = (n * np.sqrt(frac)).astype(int)
n2 = (n / np.sqrt(frac)).astype(int)
elif method == 'length_dependent':
n1 = np.ceil(np.linalg.norm(vec0) / n).astype(int)
n2 = np.ceil(np.linalg.norm(vec1) / n).astype(int)
if n1 < 20:
n1 = 20
if n2 < 20:
n2 = 20
spaces0 = np.linspace(0, 1, n1, endpoint=False, dtype=np.float32)[1:]
spaces1 = np.linspace(0, 1, n2, endpoint=False, dtype=np.float32)[1:]
# x, y = np.meshgrid(spaces0, spaces1, copy=False, dtype=np.float32)
# points = (x[:, :, None] * vec0 + y[:, :, None] * vec1).reshape(spaces0.shape[0] * spaces1.shape[0], 3) + origin
points = (np.transpose(np.broadcast_to(vec0 * spaces0[:, None],
(spaces1.shape[0], spaces0.shape[0], 3)),
axes=(1, 0, 2)) + \
np.broadcast_to(vec1 * spaces1[:, None],
(spaces0.shape[0], spaces1.shape[0], 3)
)).reshape(spaces0.shape[0] * spaces1.shape[0], 3) + origin
return points, area
def export_rays_vtk(orig, norm, filename='rays.vtk'):
pt1 = orig
pt2 = orig + norm
points = np.concatenate((pt1, pt2), axis=0)
pt_range = np.arange(0, pt1.shape[0], 1)
lines = np.vstack((pt_range, pt_range[-1] + pt_range + 1)).T
cells = [
("line", lines)
]
mesh = meshio.Mesh(
points,
cells,
)
mesh.write(
filename, # str, os.PathLike, or buffer/open file
# file_format="vtk", # optional if first argument is a path; inferred from extension
)
def export_vtk(mesh, count, filename):
cells = [
("triangle", mesh.faces)
]
cell_data = np.zeros(mesh.faces.shape[0])
cell_data[0:count.shape[0]] = count
mesh = meshio.Mesh(
mesh.vertices,
cells,
# Optionally provide extra data on points, cells, etc.
# Each item in cell data must match the cells array
cell_data={"count": [cell_data]},
)
mesh.write(
filename, # str, os.PathLike, or buffer/open file
# file_format="vtk", # optional if first argument is a path; inferred from extension
)
def export_sun_window_vtk(window, filename):
cells = [
("quad", np.array([[0, 1, 2, 3]])),
]
mesh = meshio.Mesh(
window,
cells,
)
mesh.write(
filename, # str, os.PathLike, or buffer/open file
# file_format="vtk", # optional if first argument is a path; inferred from extension
)
def export_points_vtk(points, filename):
from pyntcloud import PyntCloud
cloud = PyntCloud(pd.DataFrame(
# same arguments that you are passing to visualize_pcl
data=points,
columns=["x", "y", "z"]))
cloud.to_file(filename)
class npyAppendableFile():
"""
https://stackoverflow.com/questions/30376581/save-numpy-array-in-append-mode
:param
"""
def __init__(self, fname, newfile=True):
'''
Creates a new instance of the appendable filetype
If newfile is True, recreate the file even if already exists
'''
self.fname = Path(fname)
if newfile:
with open(self.fname, "wb") as fh:
fh.close()
def write(self, data):
'''
append a new array to the file
note that this will not change the header
'''
with open(self.fname, "ab") as fh:
np.save(fh, data)
def load(self, axis=2):
'''
Load the whole file, returning all the arrays that were consecutively
saved on top of each other
axis defines how the arrays should be concatenated
'''
with open(self.fname, "rb") as fh:
fsz = os.fstat(fh.fileno()).st_size
out = np.load(fh)
while fh.tell() < fsz:
out = np.concatenate((out, np.load(fh)), axis=axis)
return out
def update_content(self):
'''
'''
content = self.load()
with open(self.fname, "wb") as fh:
np.save(fh, content)
@property
def _dtype(self):
return self.load().dtype
@property
def _actual_shape(self):
return self.load().shape
@property
def header(self):
'''
Reads the header of the npy file
'''
with open(self.fname, "rb") as fh:
version = | np.lib.format.read_magic(fh) | numpy.lib.format.read_magic |
# *****************************************************************************
# Copyright (c) 2020, Intel Corporation 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.
#
# 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.
# *****************************************************************************
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
import sdc
import unittest
from itertools import product
from sdc.str_arr_ext import StringArray
from sdc.str_ext import std_str_to_unicode, unicode_to_std_str
from sdc.tests.test_base import TestCase
from sdc.tests.test_utils import skip_numba_jit
from sdc.functions import numpy_like
from sdc.functions import sort
class TestArrays(TestCase):
def test_astype_to_num(self):
def ref_impl(a, t):
return a.astype(t)
def sdc_impl(a, t):
return numpy_like.astype(a, t)
sdc_func = self.jit(sdc_impl)
cases = [[5, 2, 0, 333, -4], [3.3, 5.4, np.nan]]
cases_type = [np.float64, np.int64, 'float64', 'int64']
for case in cases:
a = np.array(case)
for type_ in cases_type:
with self.subTest(data=case, type=type_):
np.testing.assert_array_equal(sdc_func(a, type_), ref_impl(a, type_))
def test_astype_to_float(self):
def ref_impl(a):
return a.astype('float64')
def sdc_impl(a):
return numpy_like.astype(a, 'float64')
sdc_func = self.jit(sdc_impl)
cases = [[2, 3, 0], [4., 5.6, np.nan]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_astype_to_int(self):
def ref_impl(a):
return a.astype(np.int64)
def sdc_impl(a):
return numpy_like.astype(a, np.int64)
sdc_func = self.jit(sdc_impl)
cases = [[2, 3, 0], [4., 5.6, np.nan]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_astype_int_to_str(self):
def ref_impl(a):
return a.astype(str)
def sdc_impl(a):
return numpy_like.astype(a, str)
sdc_func = self.jit(sdc_impl)
a = np.array([2, 3, 0])
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
@unittest.skip('Numba converts float to string with incorrect precision')
def test_astype_float_to_str(self):
def ref_impl(a):
return a.astype(str)
def sdc_impl(a):
return numpy_like.astype(a, str)
sdc_func = self.jit(sdc_impl)
a = np.array([4., 5.6, np.nan])
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_astype_num_to_str(self):
def ref_impl(a):
return a.astype('str')
def sdc_impl(a):
return numpy_like.astype(a, 'str')
sdc_func = self.jit(sdc_impl)
a = np.array([5, 2, 0, 333, -4])
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
@unittest.skip('Needs Numba astype impl support converting unicode_type to other type')
def test_astype_str_to_num(self):
def ref_impl(a, t):
return a.astype(t)
def sdc_impl(a, t):
return numpy_like.astype(a, t)
sdc_func = self.jit(sdc_impl)
cases = [['a', 'cc', 'd'], ['3.3', '5', '.4'], ['¡Y', 'tú quién ', 'te crees']]
cases_type = [np.float64, np.int64]
for case in cases:
a = np.array(case)
for type_ in cases_type:
with self.subTest(data=case, type=type_):
np.testing.assert_array_equal(sdc_func(a, type_), ref_impl(a, type_))
def test_isnan(self):
def ref_impl(a):
return np.isnan(a)
def sdc_impl(a):
return numpy_like.isnan(a)
sdc_func = self.jit(sdc_impl)
cases = [[5, 2, 0, 333, -4], [3.3, 5.4, np.nan, 7.9, np.nan]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
@unittest.skip('Needs provide String Array boxing')
def test_isnan_str(self):
def ref_impl(a):
return np.isnan(a)
def sdc_impl(a):
return numpy_like.isnan(a)
sdc_func = self.jit(sdc_impl)
cases = [['a', 'cc', np.nan], ['se', None, 'vvv']]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_notnan(self):
def ref_impl(a):
return np.invert(np.isnan(a))
def sdc_impl(a):
return numpy_like.notnan(a)
sdc_func = self.jit(sdc_impl)
cases = [[5, 2, 0, 333, -4], [3.3, 5.4, np.nan, 7.9, np.nan]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_copy(self):
from sdc.str_arr_ext import StringArray
def ref_impl(a):
return np.copy(a)
@self.jit
def sdc_func(a):
_a = StringArray(a) if as_str_arr == True else a # noqa
return numpy_like.copy(_a)
cases = {
'int': [5, 2, 0, 333, -4],
'float': [3.3, 5.4, np.nan, 7.9, np.nan],
'bool': [True, False, True],
'str': ['a', 'vv', 'o12oo']
}
for dtype, data in cases.items():
a = data if dtype == 'str' else np.asarray(data)
as_str_arr = True if dtype == 'str' else False
with self.subTest(case=data):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_copy_int(self):
def ref_impl():
a = np.array([5, 2, 0, 333, -4])
return np.copy(a)
def sdc_impl():
a = np.array([5, 2, 0, 333, -4])
return numpy_like.copy(a)
sdc_func = self.jit(sdc_impl)
np.testing.assert_array_equal(sdc_func(), ref_impl())
def test_copy_bool(self):
def ref_impl():
a = np.array([True, False, True])
return np.copy(a)
def sdc_impl():
a = np.array([True, False, True])
return numpy_like.copy(a)
sdc_func = self.jit(sdc_impl)
np.testing.assert_array_equal(sdc_func(), ref_impl())
@unittest.skip("Numba doesn't have string array")
def test_copy_str(self):
def ref_impl():
a = np.array(['a', 'vv', 'o12oo'])
return np.copy(a)
def sdc_impl():
a = np.array(['a', 'vv', 'o12oo'])
return numpy_like.copy(a)
sdc_func = self.jit(sdc_impl)
np.testing.assert_array_equal(sdc_func(), ref_impl())
def test_argmin(self):
def ref_impl(a):
return np.argmin(a)
def sdc_impl(a):
return numpy_like.argmin(a)
sdc_func = self.jit(sdc_impl)
cases = [[5, 2, 0, 333, -4], [3.3, 5.4, np.nan, 7.9, np.nan]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_argmax(self):
def ref_impl(a):
return np.argmax(a)
def sdc_impl(a):
return numpy_like.argmax(a)
sdc_func = self.jit(sdc_impl)
cases = [[np.nan, np.nan, np.inf, np.nan], [5, 2, 0, 333, -4], [3.3, 5.4, np.nan, 7.9, np.nan]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_nanargmin(self):
def ref_impl(a):
return np.nanargmin(a)
def sdc_impl(a):
return numpy_like.nanargmin(a)
sdc_func = self.jit(sdc_impl)
cases = [[5, 2, 0, 333, -4], [3.3, 5.4, np.nan, 7.9, np.nan]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_nanargmax(self):
def ref_impl(a):
return np.nanargmax(a)
def sdc_impl(a):
return numpy_like.nanargmax(a)
sdc_func = self.jit(sdc_impl)
cases = [[np.nan, np.nan, np.inf, np.nan], [5, 2, -9, 333, -4], [3.3, 5.4, np.nan, 7.9]]
for case in cases:
a = np.array(case)
with self.subTest(data=case):
np.testing.assert_array_equal(sdc_func(a), ref_impl(a))
def test_sort(self):
np.random.seed(0)
def ref_impl(a):
return np.sort(a)
def sdc_impl(a):
sort.parallel_sort(a)
return a
sdc_func = self.jit(sdc_impl)
float_array = np.random.ranf(10**2)
int_arryay = np.random.randint(0, 127, 10**2)
float_cases = ['float32', 'float64']
for case in float_cases:
array0 = float_array.astype(case)
array1 = np.copy(array0)
with self.subTest(data=case):
np.testing.assert_array_equal(ref_impl(array0), sdc_func(array1))
int_cases = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64']
for case in int_cases:
array0 = int_arryay.astype(case)
array1 = np.copy(array0)
with self.subTest(data=case):
np.testing.assert_array_equal(ref_impl(array0), sdc_func(array1))
def test_stable_sort(self):
np.random.seed(0)
def ref_impl(a):
return np.sort(a)
def sdc_impl(a):
sort.parallel_stable_sort(a)
return a
sdc_func = self.jit(sdc_impl)
float_array = np.random.ranf(10**2)
int_arryay = np.random.randint(0, 127, 10**2)
float_cases = ['float32', 'float64']
for case in float_cases:
array0 = float_array.astype(case)
array1 = | np.copy(array0) | numpy.copy |
#Standard python libraries
import os
import warnings
import copy
import time
import itertools
import functools
#Dependencies - numpy, scipy, matplotlib, pyfftw
import numpy as np
import matplotlib.pyplot as plt
import pyfftw
from pyfftw.interfaces.numpy_fft import fft, fftshift, ifft, ifftshift, fftfreq
from scipy.interpolate import interp1d as sinterp1d
import scipy
from ufss import DiagramGenerator
from ufss.UF2.heaviside_convolve import HeavisideConvolve
def set_identical_efields(obj):
"""This should contain more"""
obj.efields = []
class psi_container:
def __init__(self,t,psi,bool_mask,pulse_number,manifold_key,*,interp_kind='linear',
interp_left_fill=0):
self.bool_mask = bool_mask
self.pulse_number = pulse_number
self.manifold_key = manifold_key
if t.size == 1:
n, M = psi.shape
self.M = M+2
self.n = n
self.t = np.array([-1,0,1],dtype='float') * np.spacing(t[0]) + t[0]
psi_new = np.zeros((n,3),dtype='complex')
psi_new[:,0] = interp_left_fill
psi_new[:,1] = (1 + interp_left_fill)/2 * psi[:,0]
psi_new[:,2] = psi[:,0]
self.asymptote = psi[:,-1]
self.psi = psi_new
self._psi = psi_new
self.psi_fun = self.impulsive_psifun(self.asymptote,left_fill = interp_left_fill)
else:
self.t = t
self.psi = psi
self._psi = self.extend(psi,left_fill = interp_left_fill)
self.psi_fun = self.make_interpolant(kind=interp_kind,
left_fill=interp_left_fill)
def extend(self,psi,*,left_fill = 0):
n, M = psi.shape
self.M = M
self.n = n
new_psi = np.zeros((n,3*M),dtype='complex')
new_psi[:,0:M] = left_fill
new_psi[:,M:2*M] = psi
asymptote = psi[:,-1]
self.asymptote = asymptote
new_psi[:,2*M:] = asymptote[:,np.newaxis]
return new_psi
def make_interpolant(self,*, kind='cubic', left_fill=0):
"""Interpolates density matrix and pads using 0 to the left
and psi[-1] to the right
"""
left_fill = np.ones(self.n,dtype='complex')*left_fill
right_fill = self.psi[:,-1]
return sinterp1d(self.t,self.psi,fill_value = (left_fill,right_fill),
assume_sorted=True,bounds_error=False,kind=kind)
def impulsive_psifun(self,asymptote,left_fill=0):
if left_fill == 0:
def f(t):
return asymptote[:,np.newaxis] * np.heaviside(t-self.t[1],0.5)[np.newaxis,:]
else:
def f(t):
try:
return asymptote[:,np.newaxis] * np.ones(len(t))[np.newaxis,:]
except:
return asymptote[:,np.newaxis]
return f
def __call__(self,t):
if type(t) is np.ndarray:
if t[0] > self.t[-1]:
if t.size <= self.M:
ans = self._psi[:,-t.size:].copy()
else:
ans = np.ones(t.size,dtype='complex')[np.newaxis,:] * self.asymptote[:,np.newaxis]
elif t[-1] < self.t[0]:
if t.size <= self.M:
ans = self._psi[:,:t.size].copy()
else:
ans = np.zeros((self.n,t.size),dtype='complex')
elif t.size == self.M:
if np.allclose(t,self.t):
ans = self.psi.copy()
else:
ans = self.psi_fun(t)
else:
ans = self.psi_fun(t)
else:
ans = self.psi_fun(t)
return ans
def __getitem__(self,inds):
return self._psi[:,inds].copy()
class Wavepackets(DiagramGenerator):
"""This class is designed to calculate perturbative wavepackets in the
light-matter interaction given the eigenvalues of the unperturbed
hamiltonian and the material dipole operator evaluated in the
eigenbasis of the unperturbed hamiltonian.
Args:
file_path (string): path to folder containing eigenvalues and the
dipole operator for the system Hamiltonian
num_conv_points (int): number of desired points for linear
convolution. Also number of points used to resolve all optical
pulse shapes
dt (float): time spacing used to resolve the shape of all optical
pulses
initial_state (int): index of initial state for psi^0
"""
def __init__(self,file_path,*, num_conv_points=41,
initial_state=0, total_num_time_points = None,
detection_type = 'polarization'):
self.slicing_time = 0
self.interpolation_time = 0
self.expectation_time = 0
self.next_order_expectation_time = 0
self.convolution_time = 0
self.extend_time = 0
self.mask_time = 0
self.dipole_time = 0
self.automation_time = 0
self.diagram_to_signal_time = 0
self.base_path = file_path
self.undersample_factor = 1
self.gamma_res = 6.91
self.initial_state = initial_state
self.load_eigensystem()
self.load_mu()
if detection_type == 'polarization':
self.psi_to_signal = self.polarization_detection_signal
self.return_complex_signal = False
elif detection_type == 'complex_polarization':
self.psi_to_signal = self.polarization_detection_signal
self.return_complex_signal = True
detection_type = 'polarization'
elif detection_type == 'integrated_polarization':
self.psi_to_signal = self.integrated_polarization_detection_signal
elif detection_type == 'fluorescence':
self.psi_to_signal = self.fluorescence_detection_signal
self.f_yield = f_yield #quantum yield of doubly excited manifold relative to singly excited manifold
DiagramGenerator.__init__(self,detection_type=detection_type)
self.K_dict = {'u':self.up,'d':self.down}
# Code will not actually function until the following empty lists are set by the user
self.efields = [] #initialize empty list of electric field shapes
self.efield_times = [] #initialize empty list of times assoicated with each electric field shape
self.dts = [] #initialize empty list of time spacings associated with each electric field shape
self.polarization_sequence = [] #initialize empty polarization sequence
self.pulse_times = [] #initialize empty list of pulse arrival times
self.centers = [] #initialize empty list of pulse center frequencies
self.efield_wavevectors = []
self.heaviside_convolve_list = []
self.psis = dict()
def set_pulse_delays(self,all_delays):
"""Must be a list of numpy arrays, where each array is a
list of delay times between pulses
"""
self.all_pulse_delays = all_delays
num_delays = len(self.all_pulse_delays)
num_pulses = len(self.efields)
if num_delays == num_pulses - 1:
pass
elif num_delays == num_pulses - 2 and self.detection_type == 'polarization':
# If there is a local oscillator, it arrives simultaneously with the last pulse
self.all_pulse_delays.append(np.array([0]))
elif num_delays <= num_pulses -2:
raise Exception('There are not enough delay times')
elif num_delays >= num_pulses:
raise Exception('There are too many delay times')
def calculate_diagrams_all_delays(self,diagrams):
t0 = time.time()
num_delays = len(self.all_pulse_delays)
num_pulses = len(self.efields)
all_delay_combinations = list(itertools.product(*self.all_pulse_delays))
signal_shape = [delays.size for delays in self.all_pulse_delays]
if self.detection_type == 'polarization':
signal = np.zeros((len(all_delay_combinations),self.w.size),dtype='complex')
if len(signal_shape) == self.pdc.shape[0]:
# get rid of the "delay" between the last pulse and the local oscillator
signal_shape[-1] = self.w.size
elif len(signal_shape) == self.pdc.shape[0] - 1:
# append the shape of the polariation-detection axis
signal_shape.append(self.w.size)
else:
raise Exception('Cannot automatically determine final signal shape')
else:
signal = np.zeros((len(all_delay_combinations)),dtype='complex')
counter = 0
for delays in all_delay_combinations:
arrival_times = [0]
for delay in delays:
arrival_times.append(arrival_times[-1]+delay)
if self.detection_type == 'polarization':
signal[counter,:] = self.calculate_diagrams(diagrams,arrival_times)
else:
signal[counter] = self.calculate_diagrams(diagrams,arrival_times)
counter += 1
self.signal = signal.reshape(signal_shape)
self.calculation_time = time.time() - t0
return self.signal
def calculate_signal_all_delays(self):
t0 = time.time()
num_delays = len(self.all_pulse_delays)
num_pulses = len(self.efields)
all_delay_combinations = list(itertools.product(*self.all_pulse_delays))
signal_shape = [delays.size for delays in self.all_pulse_delays]
if self.detection_type == 'polarization':
signal = np.zeros((len(all_delay_combinations),self.w.size),dtype='complex')
if len(signal_shape) == self.pdc.shape[0]:
# get rid of the "delay" between the last pulse and the local oscillator
signal_shape[-1] = self.w.size
elif len(signal_shape) == self.pdc.shape[0] - 1:
# append the shape of the polariation-detection axis
signal_shape.append(self.w.size)
else:
raise Exception('Cannot automatically determine final signal shape')
else:
signal = np.zeros((len(all_delay_combinations)),dtype='complex')
counter = 0
for delays in all_delay_combinations:
arrival_times = [0]
for delay in delays:
arrival_times.append(arrival_times[-1]+delay)
if self.detection_type == 'polarization':
signal[counter,:] = self.calculate_signal(arrival_times)
else:
signal[counter] = self.calculate_signal(arrival_times)
counter += 1
self.signal = signal.reshape(signal_shape)
self.calculation_time = time.time() - t0
return self.signal
def set_t(self,optical_dephasing_rate,*,dt='auto'):
"""Sets the time grid upon which all frequency-detected signals will
be calculated on
"""
max_pos_t = int(self.gamma_res/optical_dephasing_rate)
max_efield_t = max([np.max(u) for u in self.efield_times]) * 1.05
max_pos_t = max(max_pos_t,max_efield_t)
if dt == 'auto':
dt = self.dts[-1] # signal detection bandwidth determined by local oscillator
n = int(max_pos_t/dt)
self.t = np.arange(-n,n+1,1)*dt
self.w = fftshift(fftfreq(self.t.size,d=dt)*2*np.pi)
def execute_diagram(self,instructions):
num_instructions = len(instructions['ket']) + len(instructions['bra'])
ket = self.psi0
bra = self.psi0
ketname = ''
braname = ''
ket_instructions = instructions['ket']
bra_instructions = instructions['bra']
for i in range(len(ket_instructions)):
key, num = ket_instructions[i]
ketname += key+str(num)
# Try to re-use previous calculations, if they exist
try:
new_ket = self.psis[ketname]
except KeyError:
new_ket = self.K_dict[key](ket,pulse_number=num)
self.psis[ketname] = new_ket
ket = new_ket
for i in range(len(bra_instructions)):
key, num = bra_instructions[i]
braname += key+str(num)
# Try to re-use previous calculations, if they exist
try:
new_bra = self.psis[braname]
except KeyError:
new_bra = self.K_dict[key](bra,pulse_number=num)
self.psis[braname] = new_bra
bra = new_bra
sig = self.psi_to_signal(bra,ket)
return sig
def remove_psis_by_pulse_number(self,pulse_number):
num = str(pulse_number)
keys = self.psis.keys()
keys_to_remove = []
for key in keys:
flag = key.find(num)
if flag >= 0:
keys_to_remove.append(key)
for key in keys_to_remove:
self.psis.pop(key)
def set_identical_gaussians(self,sigma_t,c,phase_discrimination):
"""
"""
L = len(phase_discrimination) # number of pulses
# Delta = 10 and M = 41 hard-coded in
efield_t = np.linspace(-5,5,num=41)
times = [efield_t] * L
self.set_polarization_sequence(['x'] * L)
centers = [c] * L
ef = np.exp(-efield_t**2/(2*sigma_t**2))
efields = [ef for i in L]
self.set_efields(times,efields,centers,phase_discrimination,
reset_psis = True,plot_fields = False)
def set_current_diagram_instructions(self,arrival_times):
self.current_instructions = self.get_wavefunction_diagrams(arrival_times)
def calculate_signal(self,arrival_times):
t0 = time.time()
try:
old_pulse_times = self.pulse_times
for i in range(len(old_pulse_times)):
if old_pulse_times[i] != arrival_times[i]:
self.remove_psis_by_pulse_number(i)
except AttributeError:
pass
self.pulse_times = arrival_times
self.set_current_diagram_instructions(arrival_times)
diagram_instructions = self.current_instructions
if len(diagram_instructions) == 0:
print(arrival_times)
t1 = time.time()
try:
instructions = diagram_instructions[0]
signal = self.execute_diagram(instructions)
for instructions in diagram_instructions[1:]:
signal += self.execute_diagram(instructions)
except IndexError:
signal = 0
t2 = time.time()
self.automation_time += t1-t0
self.diagram_to_signal_time += t2-t1
return signal
def calculate_diagrams(self,diagram_instructions,arrival_times):
try:
old_pulse_times = self.pulse_times
for i in range(len(old_pulse_times)):
if old_pulse_times[i] != arrival_times[i]:
self.remove_psis_by_pulse_number(i)
except AttributeError:
pass
self.pulse_times = arrival_times
self.current_instructions = diagram_instructions
instructions = diagram_instructions[0]
signal = self.execute_diagram(instructions)
for instructions in diagram_instructions[1:]:
signal += self.execute_diagram(instructions)
return signal
def polarization_detection_signal(self,bra_dict,ket_dict):
p_of_t = self.dipole_expectation(bra_dict,ket_dict,pulse_number = -1)
return self.polarization_to_signal(p_of_t,local_oscillator_number=-1)
def integrated_polarization_detection_signal(self,bra_dict,ket_dict):
p = self.integrated_dipole_expectation(bra_dict,ket_dict,pulse_number=-1)
return self.integrated_polarization_to_signal(p,local_oscillator_number=-1)
def fluorescence_detection_signal(self,bra_dict,ket_dict,*,time_index = -1):
"""Calculate inner product given an input bra and ket dictionary
at a time given by the time index argument. Default is -1, since
2DFS is concerned with the amplitude of arriving in the given manifold
after the pulse has finished interacting with the system."""
bra = np.conjugate(bra_dict['psi'][:,-1])
ket = ket_dict['psi'][:,-1]
return np.dot(bra,ket)
def reset(self):
self.psis = dict()
def set_efields(self,times_list,efields_list,centers_list,phase_discrimination,*,reset = True,
plot_fields = False):
self.efield_times = times_list
self.efields = efields_list
self.centers = centers_list
self.set_phase_discrimination(phase_discrimination)
self.dts = []
self.efield_frequencies = []
if reset:
self.reset()
for t in times_list:
if t.size == 1:
dt = 1
w = np.array([0])
else:
dt = t[1] - t[0]
w = fftshift(fftfreq(t.size,d=dt))*2*np.pi
self.dts.append(dt)
self.efield_frequencies.append(w)
self.heaviside_convolve_list.append(HeavisideConvolve(t.size))
self.dt = self.dts[0]
# Initialize unperturbed wavefunction
self.set_psi0(self.initial_state)
if self.detection_type == 'polarization' or 'integrated_polarization':
try:
self.local_oscillator = self.efields[-1].copy()
except:
self.local_oscillator = copy.deepcopy(self.efields[-1])
# for field in self.efields:
# if len(field) == 1:
# # M = 1 is the impulsive limit
# pass
# else:
# self.check_efield_resolution(field,plot_fields = plot_fields)
def check_efield_resolution(self,efield,*,plot_fields = False):
efield_tail = np.max(np.abs([efield[0],efield[-1]]))
if efield_tail > np.max(np.abs(efield))/100:
warnings.warn('Consider using larger time interval, pulse does not decay to less than 1% of maximum value in time domain')
efield_fft = fftshift(fft(ifftshift(efield)))*self.dt
efield_fft_tail = np.max(np.abs([efield_fft[0],efield_fft[-1]]))
if efield_fft_tail > np.max(np.abs(efield_fft))/100:
warnings.warn('''Consider using smaller value of dt, pulse does not decay to less than 1% of maximum value in frequency domain''')
if plot_fields:
fig, axes = plt.subplots(1,2)
l1,l2, = axes[0].plot(self.efield_t,np.real(efield),self.efield_t,np.imag(efield))
plt.legend([l1,l2],['Real','Imag'])
axes[1].plot(self.efield_w,np.real(efield_fft),self.efield_w,np.imag(efield_fft))
axes[0].set_ylabel('Electric field Amp')
axes[0].set_xlabel('Time ($\omega_0^{-1})$')
axes[1].set_xlabel('Frequency ($\omega_0$)')
fig.suptitle('Check that efield is well-resolved in time and frequency')
plt.show()
def set_local_oscillator_phase(self,phase):
self.efields[-1] = np.exp(1j*phase) * self.local_oscillator
def get_psi_eigen_basis(self,t,key):
psi_obj = self.psis[key]
mask = psi_obj.bool_mask
all_e = self.eigenvalues[psi_obj.manifold_key]
e = all_e[mask]
psi = psi_obj(t)*np.exp(-1j*e[:,np.newaxis]*t[np.newaxis,:])
full_size = all_e.size
total_psi = np.zeros(full_size,t.size)
total_psi[mask,:] = psi
return total_psi
def get_psi_site_basis(self,t,key):
psi_obj = self.psis[key]
mask = psi_obj.bool_mask
manifold_num = self.manifold_key_to_number(psi_obj.manifold_key)
e = self.eigenvalues[manifold_num][mask]
psi = psi_obj(t)*np.exp(-1j*e[:,np.newaxis]*t[np.newaxis,:])
ev = self.eigenvectors[manifold_num][:,mask]
new_psi = ev.dot(psi)
full_size = 0
manifold_sizes = []
for i in range(len(self.eigenvalues)):
manifold_sizes.append(self.eigenvectors[manifold_num].shape[0])
full_size += manifold_sizes[-1]
total_psi = np.zeros(full_size,t.size)
start = 0
for i in range(len(self.eigenvalues)):
if i == manifold_num:
end = start + manifold_sizes[i]
total_psi[start:end,:] = new_psi
else:
start += manifold_sizes[i]
return total_psi
def get_psi_site_basis_by_order(self,t,order):
keys = self.psis.keys()
order_keys = []
for key in keys:
if len(key) == 2*order:
order_keys.append(key)
psi_total = self.get_psi_site_basis(t,order_keys.pop(0))
for key in order_keys:
psi_total += self.get_psi_site_basis(t,key)
return psi_total
def set_psi0(self,initial_state):
"""Creates the unperturbed wavefunction. This code does not
support initial states that are coherent super-positions of
eigenstates. To perform thermal averaging, recalculate spectra
for each initial state that contributes to the thermal ensemble.
Args:
initial_state (int): index for initial eigenstate in GSM
"""
# initial state must be interpreted given the fact that masking may have been done
try:
trimmed_indices = np.where(self.trimming_masks[0])[0]
initial_state = np.where(trimmed_indices == initial_state)[0]
except AttributeError:
pass
t = self.efield_times[0] # can be anything of the correct length
key = self.ordered_manifolds[0]
psi0 = np.ones((1,t.size),dtype=complex)
bool_mask = np.zeros(self.eigenvalues[key].size,dtype='bool')
bool_mask[initial_state] = True
self.psi0 = psi_container(t,psi0,bool_mask,None,key,interp_kind='zero',
interp_left_fill=1)
def get_closest_index_and_value(self,value,array):
"""Given an array and a desired value, finds the closest actual value
stored in that array, and returns that value, along with its corresponding
array index
"""
index = np.argmin(np.abs(array - value))
value = array[index]
return index, value
def load_eigensystem(self):
"""Load in known eigenvalues. Must be stored as a numpy archive file,
with keys: GSM, SEM, and optionally DEM. The eigenvalues for each manifold
must be 1d arrays, and are assumed to be ordered by increasing energy. The
energy difference between the lowest energy ground state and the lowest
energy singly-excited state should be set to 0
"""
eigval_save_name = os.path.join(self.base_path,'eigenvalues.npz')
eigvec_save_name = os.path.join(self.base_path,'eigenvectors.npz')
with np.load(eigval_save_name) as eigval_archive:
self.manifolds = list(eigval_archive.keys())
self.eigenvalues = {key:eigval_archive[key] for key in self.manifolds}
with np.load(eigvec_save_name) as eigvec_archive:
self.eigenvectors = {key:eigvec_archive[key] for key in self.manifolds}
if '0' in self.manifolds:
self.ordered_manifolds = [str(i) for i in range(len(self.manifolds))]
else:
self.ordered_manifolds = ['GSM','SEM','DEM','TEM','QEM']
### store original eigenvalues for recentering purposes
self.original_eigenvalues = copy.deepcopy(self.eigenvalues)
def load_mu(self):
"""Load the precalculated dipole overlaps. The dipole operator must
be stored as a .npz file, and must contain at least one array, each with three
indices: (upper manifold eigenfunction, lower manifold eigenfunction,
cartesian coordinate). So far this code supports up to three manifolds, and
therefore up to two dipole operators (connecting between manifolds)"""
file_name = os.path.join(self.base_path,'mu.npz')
file_name_pruned = os.path.join(self.base_path,'mu_pruned.npz')
file_name_bool = os.path.join(self.base_path,'mu_boolean.npz')
try:
mu_boolean_archive = np.load(file_name_bool)
# self.mu_boolean = {'ket':mu_boolean_archive['ket'],'bra':mu_boolean_archive['bra']}
with np.load(file_name_bool) as mu_boolean_archive:
self.mu_boolean = {key:mu_boolean_archive[key] for key in mu_boolean_archive.keys()}
pruned = True
file_name = file_name_pruned
except FileNotFoundError:
pruned = False
with np.load(file_name) as mu_archive:
self.mu = {key:mu_archive[key] for key in mu_archive.keys()}
if pruned == False:
self.mu_boolean = dict()
for key in self.mu.keys():
self.mu_boolean[key] = np.ones(self.mu[key].shape[:2],dtype='bool')
### Setting the electric field to be used
def set_polarization_sequence(self,polarization_list,*,reset_psis=True):
"""Sets the sequences used for either parallel or crossed pump and probe
Args:
polarization_list (list): list of four strings, can be 'x','y' or 'z'
Returns:
None: sets the attribute polarization sequence
"""
x = np.array([1,0,0])
y = np.array([0,1,0])
z = np.array([0,0,1])
pol_options = {'x':x,'y':y,'z':z}
self.polarization_sequence = [pol_options[pol] for pol in polarization_list]
if reset_psis:
self.psis = dict()
### Tools for recursively calculating perturbed wavepackets using TDPT
def dipole_matrix(self,pulse_number,key,ket_flag=True,up_flag=True):
"""Calculates the dipole matrix given the electric field polarization vector,
if ket_flag = False then uses the bra-interaction"""
t0 = time.time()
pol = self.polarization_sequence[pulse_number]
x = np.array([1,0,0])
y = np.array([0,1,0])
z = np.array([0,0,1])
try:
mu = self.mu[key]
boolean_matrix = self.mu_boolean[key]
except KeyError:
try:
key = 'up'
mu = self.mu[key]
boolean_matrix = self.mu_boolean[key]
except KeyError:
key = 'ket_up'
mu = self.mu[key]
boolean_matrix = self.mu_boolean[key]
if np.all(pol == x):
overlap_matrix = mu[:,:,0].copy()
elif np.all(pol == y):
overlap_matrix = mu[:,:,1].copy()
elif np.all(pol == z):
overlap_matrix = mu[:,:,2].copy()
else:
overlap_matrix = np.tensordot(mu,pol,axes=(-1,0))
if not up_flag:
overlap_matrix = overlap_matrix.T
boolean_matrix = boolean_matrix.T
t1 = time.time()
self.dipole_time += t1-t0
return boolean_matrix, overlap_matrix
def electric_field_mask(self,pulse_number,key,conjugate_flag=False):
"""This method determines which molecular transitions will be
supported by the electric field. We assume that the electric field has
0 amplitude outside the minimum and maximum frequency immplied by the
choice of dt and num_conv_points. Otherwise we will inadvertently
alias transitions onto nonzero electric field amplitudes.
"""
if conjugate_flag:
ending_key, starting_key = key.split('_to_')
else:
starting_key, ending_key = key.split('_to_')
efield_t = self.efield_times[pulse_number]
efield_w = self.efield_frequencies[pulse_number]
if conjugate_flag:
center = -self.centers[pulse_number]
else:
center = self.centers[pulse_number]
try:
eig_starting = self.eigenvalues['all_manifolds']
eig_ending = self.eigenvalues['all_manifolds']
except KeyError:
eig_starting = self.eigenvalues[starting_key]
eig_ending = self.eigenvalues[ending_key]
diff = eig_ending[:,np.newaxis] - eig_starting[np.newaxis,:]
if efield_t.size == 1:
mask = np.ones(diff.shape,dtype='bool')
else:
# The only transitions allowed by the electric field shape are
inds_allowed = np.where((diff - center > efield_w[0]) & (diff - center < efield_w[-1]))
mask = np.zeros(diff.shape,dtype='bool')
mask[inds_allowed] = 1
return mask
def mask_dipole_matrix(self,boolean_matrix,overlap_matrix,
starting_manifold_mask,*,next_manifold_mask = None):
"""Takes as input the boolean_matrix and the overlap matrix that it
corresponds to. Also requires the starting manifold mask, which specifies
which states have non-zero amplitude, given the signal tolerance requested.
Trims off unnecessary starting elements, and ending elements. If
next_manifold_mask is None, then the masking is done automatically
based upon which overlap elements are nonzero. If next_manifold_mask is
a 1D numpy boolean array, it is used as the mask for next manifold."""
t0 = time.time()
if np.all(starting_manifold_mask == True):
pass
else:
boolean_matrix = boolean_matrix[:,starting_manifold_mask]
overlap_matrix = overlap_matrix[:,starting_manifold_mask]
#Determine the nonzero elements of the new psi, in the
#eigenenergy basis, n_nonzero
if type(next_manifold_mask) is np.ndarray:
n_nonzero = next_manifold_mask
else:
n_nonzero = np.any(boolean_matrix,axis=1)
if np.all(n_nonzero == True):
pass
else:
overlap_matrix = overlap_matrix[n_nonzero,:]
t1 = time.time()
self.mask_time += t1-t0
return overlap_matrix, n_nonzero
def manifold_key_to_number(self,key):
num = self.ordered_manifolds.index(key)
return num
def manifold_number_to_key(self,num):
key = self.ordered_manifolds[num]
return key
def next_order(self,psi_in,*,up_flag=True,
new_manifold_mask = None,pulse_number = 0):
"""This function connects psi_p to psi_pj^(*) using a DFT convolution algorithm.
Args:
psi_in (psi_container): input density matrix
pulse_number (int): index of optical pulse (0,1,2,...) can also be set to
'impulsive'
new_manifold_mask (np.ndarray): optional - define the states to be considered
in the next manifold
Return:
psi_dict (psi_container): next-order wavefunction
"""
pulse_time = self.pulse_times[pulse_number]
t = self.efield_times[pulse_number] + pulse_time
old_manifold_key = psi_in.manifold_key
if up_flag:
change = 1
conjugate_flag = False
else:
change = -1
conjugate_flag = True
old_manifold = self.manifold_key_to_number(old_manifold_key)
new_manifold = old_manifold + change
new_manifold_key = self.manifold_number_to_key(new_manifold)
if up_flag:
mu_key = old_manifold_key + '_to_' + new_manifold_key
else:
mu_key = new_manifold_key + '_to_' + old_manifold_key
if conjugate_flag:
center = - self.centers[pulse_number]
else:
center = self.centers[pulse_number]
m_nonzero = psi_in.bool_mask
try:
ev1 = self.eigenvalues['all_manifolds']
ev2 = self.eigenvalues['all_manifolds']
except KeyError:
ev1 = self.eigenvalues[old_manifold_key]
ev2 = self.eigenvalues[new_manifold_key]
exp_factor_starting = np.exp( -1j*(ev1[m_nonzero,np.newaxis])*t[np.newaxis,:])
psi = psi_in(t) * exp_factor_starting
boolean_matrix, overlap_matrix = self.dipole_matrix(pulse_number,mu_key,up_flag=up_flag)
e_mask = self.electric_field_mask(pulse_number,mu_key,conjugate_flag=conjugate_flag)
boolean_matrix = boolean_matrix * e_mask
overlap_matrix = overlap_matrix * e_mask
overlap_matrix, n_nonzero = self.mask_dipole_matrix(boolean_matrix,overlap_matrix,m_nonzero,
next_manifold_mask = new_manifold_mask)
t0 = time.time()
psi = overlap_matrix.dot(psi)
t1 = time.time()
self.next_order_expectation_time += t1-t0
exp_factor_ending = np.exp(1j*ev2[n_nonzero,np.newaxis]*t[np.newaxis,:])
psi = psi*exp_factor_ending
psi = psi * np.exp(-1j*center*t)
t0 = time.time()
M = self.efield_times[pulse_number].size
fft_convolve_fun = self.heaviside_convolve_list[pulse_number].fft_convolve2
if M == 1:
psi = psi * self.efields[pulse_number]
else:
if conjugate_flag:
efield = | np.conjugate(self.efields[pulse_number]) | numpy.conjugate |
from ball import Ball, Cup
from ballstring import String
import pygame
import gym
from gym import error, spaces, utils
import numpy as np
from math import sqrt, cos
from cmath import phase
WIDTH = 1200
HEIGHT = 700
pygame.init()
pygame.font.init()
pygame.display.set_mode((WIDTH, HEIGHT))
class GameAI(gym.Env):
def __init__(self, scale=0.53/HEIGHT, string_length=200, cup_size=30, amplitude=20, continuous=True):
self.ball = Ball(0, 0)
self.ball.fall()
self.cup = Cup(0, 0, cup_size)
self.string = String(self.cup, self.ball, string_length)
self.scale = scale
self.timestep = 0.01
pygame.init()
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
self.clock = pygame.time.Clock()
self.last_points = []
self.myfont = pygame.font.SysFont('FUTURA', 100)
self.myfont2 = pygame.font.SysFont('FUTURA', 20)
self.textwin = self.myfont.render('WIN', False, (255, 255, 255))
self.textlose = self.myfont.render('LOSE', False, (255, 255, 255))
self.state = None
self.score = None
self.amplitude = amplitude
self.continuous = continuous
if continuous:
self.action_space = spaces.Box(-1, 1, (2,), dtype=np.float32)
else:
self.action_space = spaces.Discrete(3)
self.observation_space = spaces.Box(-1, 1, (4,), dtype=np.float32)
def reset(self, rand=False, pos=(300, 300)):
self.cup.set_pos(pos)
self.ball.set_pos(pos)
bl = complex(np.random.random(), | np.random.random() | numpy.random.random |
from pyrep import PyRep
from pyrep.objects import VisionSensor
from pyrep.const import Verbosity
import multiprocessing as mp
import os
from pathlib import Path
from collections import defaultdict
from custom_shapes import TapShape, ButtonShape, LeverShape, Kuka
import numpy as np
from contextlib import contextmanager
from traceback import format_exc
import time
from scipy.interpolate import CubicHermiteSpline
import logging
import sys
MODEL_PATH = os.environ["COPPELIASIM_MODEL_PATH"]
class SimulationConsumerFailed(Exception):
def __init__(self, consumer_exception, consumer_traceback):
self.consumer_exception = consumer_exception
self.consumer_traceback = consumer_traceback
def __str__(self):
return '\n\nFROM CONSUMER:\n\n{}'.format(self.consumer_traceback)
def communicate_return_value(method):
"""method from the SimulationConsumer class decorated with this function
will send there return value to the SimulationProducer class"""
method._communicate_return_value = True
return method
def default_dont_communicate_return(cls):
"""Class decorator for the SimulationConsumers meaning that by default, all
methods don't communicate their return value to the Producer class"""
for attribute_name, attribute in cls.__dict__.items():
if callable(attribute):
communicate = hasattr(attribute, '_communicate_return_value')
attribute._communicate_return_value = communicate
return cls
def c2p_convertion_function(cls, method):
"""Function that transform a Consumer method into a Producer method.
It add a blocking flag that determines whether the call is blocking or not.
If you call a `Producer.mothod(blocking=False)`, you then must
`Producer._wait_for_answer()`"""
def new_method(self, *args, blocking=True, **kwargs):
cls._send_command(self, method, *args, **kwargs)
if method._communicate_return_value and blocking:
return cls._wait_for_answer(self)
new_method._communicate_return_value = method._communicate_return_value
return new_method
def consumer_to_producer_method_conversion(cls):
"""Class decorator that transforms all methods from the Consumer to the
Producer, except for methods starting with an '_', and for the
multiprocessing.Process methods"""
proc_methods = [
"run", "is_alive", "join", "kill", "start", "terminate", "close"
]
method_dict = {
**SimulationConsumerAbstract.__dict__,
**SimulationConsumer.__dict__,
}
convertables = {
method_name: method \
for method_name, method in method_dict.items()\
if callable(method) and\
method_name not in proc_methods and\
not method_name.startswith("_")
}
for method_name, method in convertables.items():
new_method = c2p_convertion_function(cls, method)
setattr(cls, method_name, new_method)
return cls
def p2p_convertion_function(name):
"""This function transforms a producer method into a Pool method"""
def new_method(self, *args, **kwargs):
if self._distribute_args_mode:
# all args are iterables that must be distributed to each producer
for i, producer in enumerate(self._active_producers):
getattr(producer, name)(
*[arg[i] for arg in args],
blocking=False,
**{key: value[i] for key, value in kwargs.items()}
)
else:
for producer in self._active_producers:
getattr(producer, name)(*args, blocking=False, **kwargs)
if getattr(SimulationProducer, name)._communicate_return_value:
return [
producer._wait_for_answer() for producer in self._active_producers
]
return new_method
def producer_to_pool_method_convertion(cls):
"""This class decorator transforms all Producer methods (besides close and
methods starting with '_') to the Pool object."""
convertables = {
method_name: method \
for method_name, method in SimulationProducer.__dict__.items()\
if callable(method) and not method_name.startswith("_")\
and not method_name == 'close'
}
for method_name, method in convertables.items():
new_method = p2p_convertion_function(method_name)
setattr(cls, method_name, new_method)
return cls
@default_dont_communicate_return
class SimulationConsumerAbstract(mp.Process):
_id = 0
"""This class sole purpose is to better 'hide' all interprocess related code
from the user."""
def __init__(self, process_io, scene="", gui=False):
super().__init__(
name="simulation_consumer_{}".format(SimulationConsumerAbstract._id)
)
self._id = SimulationConsumerAbstract._id
SimulationConsumerAbstract._id += 1
self._scene = scene
self._gui = gui
self._process_io = process_io
np.random.seed()
def run(self):
self._pyrep = PyRep()
self._pyrep.launch(
self._scene,
headless=not self._gui,
verbosity=Verbosity.NONE,
# verbosity=Verbosity.SCRIPT_ERRORS,
# verbosity=Verbosity.SCRIPT_INFOS,
# verbosity=Verbosity.TYRACE_ALL,
# verbosity=Verbosity.TRACE_LUA,
# write_coppeliasim_stdout_to_file=True
)
self._process_io["simulaton_ready"].set()
self._main_loop()
def _close_pipes(self):
self._process_io["command_pipe_out"].close()
self._process_io["return_value_pipe_in"].close()
# self._process_io["exception_pipe_in"].close() # let this one open
def _main_loop(self):
success = True
while success and not self._process_io["must_quit"].is_set():
success = self._consume_command()
self._pyrep.shutdown()
self._close_pipes()
def _consume_command(self):
try: # to execute the command and send result
success = True
command = self._process_io["command_pipe_out"].recv()
self._process_io["slot_in_command_queue"].release()
ret = command[0](self, *command[1], **command[2])
if command[0]._communicate_return_value:
self._communicate_return_value(ret)
except Exception as e: # print traceback, dont raise
traceback = format_exc()
success = False # return False: quit the main loop
self._process_io["exception_pipe_in"].send((e, traceback))
finally:
return success
def _communicate_return_value(self, value):
self._process_io["return_value_pipe_in"].send(value)
def signal_command_pipe_empty(self):
self._process_io["command_pipe_empty"].set()
while self._process_io["command_pipe_empty"].is_set():
time.sleep(0.1)
def good_bye(self):
pass
@default_dont_communicate_return
class SimulationConsumer(SimulationConsumerAbstract):
def __init__(self, process_io, scene="", gui=False):
super().__init__(process_io, scene, gui)
self._shapes = defaultdict(list)
self._stateful_shape_list = []
self._arm_list = []
self._state_buffer = None
self._cams = {}
def set_reset_poses(self):
self._reset_configuration_trees = [
arm.get_configuration_tree() for arm in self._arm_list
]
@communicate_return_value
def reset_pose(self, register_states, register_goals):
self._previous_hermite_speeds[:] = 0
self._previous_hermite_accelerations[:] = 0
for tree in self._reset_configuration_trees:
self._pyrep.set_configuration_tree(tree)
self.set_stateful_objects_states(register_states)
self.set_stateful_objects_goals(register_goals)
@communicate_return_value
def reset(self, register_states, register_goals, actions):
self._previous_hermite_speeds[:] = 0
self._previous_hermite_accelerations[:] = 0
for tree in self._reset_configuration_trees:
self._pyrep.set_configuration_tree(tree)
self.set_stateful_objects_states(register_states)
self.set_stateful_objects_goals(register_goals)
velocities = actions * self._upper_velocity_limits
self.set_joint_target_velocities(velocities)
self.step_sim() # three steps with a random velocity for randomization
self.step_sim()
self.step_sim()
return self.get_data()
@communicate_return_value
def get_stateful_objects_states(self):
for i, shape in enumerate(self._stateful_shape_list):
self._stateful_shape_state_buffer[i] = shape.get_state()
return self._stateful_shape_state_buffer
def set_stateful_objects_states(self, states):
if len(states) != len(self._stateful_shape_list):
raise ValueError(
"Can not set the object states, wrong length ({} for {})".format(
len(states), len(self._stateful_shape_list))
)
for shape, state in zip(self._stateful_shape_list, states):
shape.set_state(state)
def set_stateful_objects_goals(self, goals):
if len(goals) != len(self._stateful_shape_list):
raise ValueError(
"Can not set the object goals, wrong length ({} for {})".format(
len(goals), len(self._stateful_shape_list))
)
for shape, goal in zip(self._stateful_shape_list, goals):
shape.set_goal(goal)
def _add_stateful_object(self, model):
self._stateful_shape_list.append(model)
self._stateful_shape_state_buffer = np.zeros(
len(self._stateful_shape_list),
dtype=np.uint8
)
@communicate_return_value
def get_state(self):
n = self._n_joints
if self._state_buffer is None:
n_reg = self.get_n_registers()
size = 3 * n + n_reg
self._state_buffer = np.zeros(shape=size, dtype=np.float32)
self._state_mean = np.zeros(shape=size, dtype=np.float32)
self._state_std = np.zeros(shape=size, dtype=np.float32)
self._state_mean[3 * n:] = 0.5
# scaling with values measured from random movements
pos_std = [1.6, 1.3, 1.6, 1.3, 2.2, 1.7, 2.3]
spe_std = [1.1, 1.2, 1.4, 1.3, 2.4, 1.7, 2.1]
for_std = [91, 94, 43, 67, 12, 8.7, 2.3]
reg_std = [0.5 for i in range(n_reg)]
self._state_std[0 * n:1 * n] = np.tile(pos_std, n // 7)
self._state_std[1 * n:2 * n] = np.tile(spe_std, n // 7)
self._state_std[2 * n:3 * n] = np.tile(for_std, n // 7)
self._state_std[3 * n:] = reg_std
self._state_buffer[0 * n:1 * n] = self.get_joint_positions()
self._state_buffer[1 * n:2 * n] = self.get_joint_velocities()
try:
self._state_buffer[2 * n:3 * n] = self.get_joint_forces()
except RuntimeError:
self._state_buffer[2 * n:3 * n] = 0
self._state_buffer[3 * n:] = self.get_stateful_objects_states()
# STATE NORMALIZATION:
self._state_buffer -= self._state_mean
self._state_buffer /= self._state_std
return self._state_buffer
@communicate_return_value
def get_data(self):
return self.get_state(), self.get_stateful_objects_states()
@communicate_return_value
def get_n_registers(self):
return len(self._stateful_shape_list)
def add_tap(self, position=None, orientation=None):
model = self._pyrep.import_model(MODEL_PATH + "/tap_damping_0_spring_20.ttm")
model = TapShape(model.get_handle(), self._pyrep)
if position is not None:
model.set_position(position)
if orientation is not None:
model.set_orientation(orientation)
self._shapes["tap"].append(model)
self._add_stateful_object(model)
def add_button(self, position=None, orientation=None):
model = self._pyrep.import_model(MODEL_PATH + "/button.ttm")
model = ButtonShape(model.get_handle(), self._pyrep)
if position is not None:
model.set_position(position)
if orientation is not None:
model.set_orientation(orientation)
self._shapes["button"].append(model)
self._add_stateful_object(model)
def add_lever(self, position=None, orientation=None):
model = self._pyrep.import_model(MODEL_PATH + "/lever_45.ttm")
model = LeverShape(model.get_handle(), self._pyrep)
if position is not None:
model.set_position(position)
if orientation is not None:
model.set_orientation(orientation)
self._shapes["lever"].append(model)
self._add_stateful_object(model)
def add_arm(self, position=None, orientation=None, from_tech_sheet=False):
if from_tech_sheet:
model_file = MODEL_PATH + "/kuka_from_tech_sheet.ttm"
else:
model_file = MODEL_PATH + "/kuka_default.ttm"
model = self._pyrep.import_model(model_file)
model = Kuka(model.get_handle())
if position is not None:
model.set_position(position)
if orientation is not None:
model.set_orientation(orientation)
self._shapes["arm"].append(model)
self._arm_list.append(model)
self._arm_joints_count = [arm.get_joint_count() for arm in self._arm_list]
self._n_joints = sum(self._arm_joints_count)
self._arm_joints_positions_buffer = np.zeros(
self._n_joints,
dtype=np.float32
)
self._arm_joints_velocities_buffer = np.zeros(
self._n_joints,
dtype=np.float32
)
self._arm_joints_torques_buffer = np.zeros(
self._n_joints,
dtype=np.float32
)
self._previous_hermite_speeds = np.zeros(self._n_joints)
self._previous_hermite_accelerations = np.zeros(self._n_joints)
self.get_joint_upper_velocity_limits()
@communicate_return_value
def add_camera(self, position=None, orientation=None, resolution=[320, 240]):
vision_sensor = VisionSensor.create(
resolution=resolution,
position=position,
orientation=orientation,
)
cam_id = vision_sensor.get_handle()
self._cams[cam_id] = vision_sensor
return cam_id
@communicate_return_value
def get_frame(self, cam_id):
return self._cams[cam_id].capture_rgb()
def delete_camera(self, cam_id):
self._cams[cam_id].remove()
self._cams.pop(cam_id)
@communicate_return_value
def get_joint_positions(self):
last = 0
next = 0
for arm, joint_count in zip(self._arm_list, self._arm_joints_count):
next += joint_count
self._arm_joints_positions_buffer[last:next] = \
arm.get_joint_positions()
last = next
return self._arm_joints_positions_buffer
@communicate_return_value
def get_joint_velocities(self):
last = 0
next = 0
for arm, joint_count in zip(self._arm_list, self._arm_joints_count):
next += joint_count
self._arm_joints_velocities_buffer[last:next] = \
arm.get_joint_velocities()
last = next
return self._arm_joints_velocities_buffer
def set_joint_target_velocities(self, velocities):
last = 0
next = 0
for arm, joint_count in zip(self._arm_list, self._arm_joints_count):
next += joint_count
arm.set_joint_target_velocities(velocities[last:next])
last = next
def set_joint_positions(self, positions):
last = 0
next = 0
for arm, joint_count in zip(self._arm_list, self._arm_joints_count):
next += joint_count
arm.set_joint_positions(positions[last:next], disable_dynamics=True)
last = next
def set_joint_mode(self, mode):
for arm in self._arm_list:
arm.set_joint_mode(mode)
@communicate_return_value
def get_joint_mode(self):
ret = []
for arm in self._arm_list:
ret += arm.get_joint_mode(mode)
return ret
def set_joint_target_positions(self, positions):
last = 0
next = 0
for arm, joint_count in zip(self._arm_list, self._arm_joints_count):
next += joint_count
arm.set_joint_target_positions(positions[last:next])
last = next
@communicate_return_value
def apply_action(self, actions):
velocities = actions * self._upper_velocity_limits
self.set_joint_target_velocities(velocities)
self.step_sim()
return self.get_data()
def get_movement_velocities(self, actions, mode='minimalist', span=10):
if mode == 'minimalist':
ramp = 0.5 - 0.5 * np.cos(np.linspace(0, 2 * np.pi, span))
velocities = actions * ramp[:, np.newaxis] * self._upper_velocity_limits[np.newaxis]
velocities = velocities[np.newaxis] # shape [1, span, 7]
elif mode == "cubic_hermite":
shape_factor = 0.2
x = [0, 0.5, 1]
actions_speeds = actions[:, :2 * self._n_joints]
actions_speeds = actions_speeds.reshape(
(2, self._n_joints))
actions_accelerations = actions[:, 2 * self._n_joints:]
actions_accelerations = actions_accelerations.reshape(
(2, self._n_joints))
speeds = np.vstack([self._previous_hermite_speeds, actions_speeds])
accelerations = np.vstack([self._previous_hermite_accelerations, actions_accelerations])
speeds[-1] *= shape_factor
accelerations[-1] *= shape_factor
eval = np.linspace(0, 1, span)
poly = CubicHermiteSpline(x, speeds, accelerations)
velocities = poly(eval) * self._upper_velocity_limits[np.newaxis]
velocities = velocities[np.newaxis] # shape [1, span, 7]
self._previous_hermite_speeds = speeds[-1]
self._previous_hermite_accelerations = accelerations[-1]
elif mode == "full_raw":
velocities = actions * self._upper_velocity_limits[np.newaxis]
velocities = velocities[:, np.newaxis] # shape [span, 1, 7]
elif mode == "one_raw":
velocities = actions * self._upper_velocity_limits[np.newaxis]
velocities = velocities[np.newaxis] # shape [1, 1, 7]
else:
raise ValueError("Unrecognized movement mode ({})".format(mode))
return velocities
@communicate_return_value
def apply_movement(self, actions, mode='minimalist', span=10):
velocities = self.get_movement_velocities(actions, mode=mode, span=span) # shape [n_states_to_be_returned, mini_sequence_length, n_joints]
normalized_velocities = velocities / self._upper_velocity_limits[np.newaxis]
metabolic_costs = np.sum(normalized_velocities ** 2, axis=(1, 2)) # shape [n_states_to_be_returned]
states_sequence = []
stateful_objects_states_sequence = []
for mini_sequence in velocities:
state, stateful_objects_state = self.get_data()
states_sequence.append(np.copy(state))
stateful_objects_states_sequence.append(np.copy(stateful_objects_state))
for velocity in mini_sequence:
self.set_joint_target_velocities(velocity)
self.step_sim()
return np.vstack(states_sequence), np.vstack(stateful_objects_states_sequence), metabolic_costs
@communicate_return_value
def apply_movement_get_frames(self, actions, cam_id, mode='minimalist', span=10):
velocities = self.get_movement_velocities(actions, mode=mode, span=span)
normalized_velocities = velocities / self._upper_velocity_limits[np.newaxis]
metabolic_costs = np.sum(normalized_velocities ** 2, axis=(1, 2)) # shape [n_states_to_be_returned]
states_sequence = []
stateful_objects_states_sequence = []
frames = []
for mini_sequence in velocities:
state, stateful_objects_state = self.get_data()
states_sequence.append(np.copy(state))
stateful_objects_states_sequence.append( | np.copy(stateful_objects_state) | numpy.copy |
import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import pathlib
import pandas as pd
from PIL import Image
from PIL.ImageDraw import Draw
# Create training data
training_image_records = pd.read_csv("training.csv")
train_image_path = os.path.join(os.getcwd(), "training")
train_images = []
train_targets = []
for index, row in training_image_records.iterrows():
(filename, xmin, ymin, xmax, ymax) = row
train_image_fullpath = os.path.join(train_image_path, filename)
train_img_arr = keras.preprocessing.image.img_to_array(keras.preprocessing.image.load_img(train_image_fullpath, target_size=(255, 255), color_mode="grayscale"))
xmin = round(xmin/ 255, 2)
ymin = round(ymin/ 255, 2)
xmax = round(xmax/ 255, 2)
ymax = round(ymax/ 255, 2)
train_images.append(train_img_arr)
train_targets.append((xmin, ymin, xmax, ymax))
validation_image_records = pd.read_csv("validation.csv")
validation_image_path = os.path.join(os.getcwd(), "validation")
validation_images = []
validation_targets = []
for index, row in validation_image_records.iterrows():
(filename, xmin, ymin, xmax, ymax) = row
validation_image_fullpath = os.path.join(validation_image_path, filename)
validation_img_arr = keras.preprocessing.image.img_to_array(keras.preprocessing.image.load_img(validation_image_fullpath, target_size=(255, 255), color_mode="grayscale"))
xmin = round(xmin/ 255, 2)
ymin = round(ymin/ 255, 2)
xmax = round(xmax/ 255, 2)
ymax = round(ymax/ 255, 2)
validation_images.append(validation_img_arr)
validation_targets.append((xmin, ymin, xmax, ymax))
train_images = | np.array(train_images) | numpy.array |
''' Skeleton-based Abnormal Gait Detection (Sensors, MDPI 2016)
BSD 2-Clause "Simplified" License
Author: <NAME>'''
from __future__ import division
import numpy as np
from utils import *
from func_HMM import *
import argparse, sys
def HMMgait3_fullsequence(skel_dataset, test_subjects, n_subjects = 9, n_gaits = 9, window = 5, state_num = 24, obs_num = 43, save_result = False):
if isinstance(test_subjects, int):
test_subjects = [test_subjects]
print('test subject(s): ' + str(test_subjects))
'''define variables'''
train_vectors = np.array([]).reshape((0,8))
train_files = np.array([]).reshape((1,0))
file_id = 0
'''load data for training'''
print('Load normal gaits of ' + str(n_subjects - len(test_subjects)) + ' subjects for training...')
for i in range(n_subjects):
if i in test_subjects:
continue
file_id += 1
print('processing normal skel. of subject ' + str(i))
tmp_skels = skel_dataset[i, 0]
tmp = np.array([feature_extract(skel) for skel in tmp_skels])
train_vectors = np.concatenate((train_vectors, tmp), axis = 0)
train_files = np.concatenate((train_files, file_id*np.ones((1, tmp.shape[0]))), axis = 1)
'''load test data'''
print('Load test data...')
abnormal_test_vectors = []
normal_test_vectors = []
n_abnormal_test_sequence = len(test_subjects) * (n_gaits - 1)
n_normal_test_sequence = len(test_subjects)
for i in range(n_subjects):
if i in test_subjects:
print('processing skel. of subject ' + str(i))
for j in range(n_gaits):
tmp_skels = skel_dataset[i, j]
tmp = np.array([feature_extract(skel) for skel in tmp_skels])
if j != 0:
abnormal_test_vectors.append(tmp)
else:
normal_test_vectors.append(tmp)
'''k-means'''
print('window width = ' + str(window) + ', states = ' + str(state_num) + ', observations = ' + str(obs_num))
centroids, train_labels, kmeans = KMeans_postures(train_vectors, obs_num)
'''Training cycles'''
train_cycle_vectors = []
cycles_id = get_cycles(train_vectors, train_files, window)
cycles_idx = np.where(cycles_id != -1)[0]
for i in range(len(cycles_idx)-1):
if cycles_id[cycles_idx[i]] == cycles_id[cycles_idx[i+1]]:
train_cycle_vectors.append(train_labels[cycles_idx[i]:cycles_idx[i+1]+1])
'''Train HMM'''
hmm_model = train_hmm(train_cycle_vectors, state_num, obs_num)
'''Testing abnormal cycles'''
scores_abnormal = np.array([])
groundtruth_cycle_abnormal = np.array([])
scores_cycle_abnormal = np.array([])
for f in range(n_abnormal_test_sequence):
tmp_result = np.array([])
test_labels = KMeans_test(kmeans, np.concatenate(abnormal_test_vectors, axis = 0))
cycles_id = get_cycles(abnormal_test_vectors[f], f*np.ones(abnormal_test_vectors[f].shape[0]), window)
cycles_idx = np.where(cycles_id != -1)[0]
for i in range(len(cycles_idx)-1):
if cycles_id[cycles_idx[i]] == cycles_id[cycles_idx[i+1]]:
tmp_vt = test_labels[cycles_idx[i]:cycles_idx[i+1]+1]
ll_val = hmm_model.score(tmp_vt.reshape((1,-1)))
tmp_result = np.append(tmp_result, ll_val)
scores_abnormal = np.append(scores_abnormal, -seq_likelihood(tmp_result,3))
tmp_result = tmp_result[abs(tmp_result)!=np.inf]
groundtruth_cycle_abnormal = np.concatenate((groundtruth_cycle_abnormal, np.ones(len(tmp_result))), axis = 0)
scores_cycle_abnormal = np.concatenate((scores_cycle_abnormal, -np.array(tmp_result)), axis = 0)
'''Testing normal cycles'''
scores_normal = np.array([])
groundtruth_cycle_normal = np.array([])
scores_cycle_normal = np.array([])
for f in range(n_normal_test_sequence):
tmp_result = | np.array([]) | numpy.array |
import os
import pickle
import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse
import numpy as np
import colorsys
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
number2name_ml10 = {
0: 'reach-v1',
1: 'push-v1',
2: 'pick-place-v1',
3: 'door-open-v1',
4: 'drawer-close-v1',
5: 'button-press-topdown-v1',
6: 'peg-insert-side-v1',
7: 'window-open-v1',
8: 'sweep-v1',
9: 'basketball-v1',
10: 'drawer-open-v1',
11: 'door-close-v1',
12: 'shelf-place-v1',
13: 'sweep-into-v1',
14: 'lever-pull-v1'}
number2name_cheetah_multi_task = {
1: 'velocity',
2: 'goal direction',
3: 'goal',
4: 'rollover',
5: 'stand-up'}
number2name = number2name_cheetah_multi_task
cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_encodings_split_with_rewards(epoch, exp_directory, save=False, normalize=False, legend=False):
encoding_storage = pickle.load(open(os.path.join(exp_directory, "encoding_" + str(epoch) + ".p"), "rb"))
base_tasks = list(encoding_storage.keys())
#rewards_per_base_task = [sum([encoding_storage[base][key]['reward_mean'] / len(list(encoding_storage[base].keys())) for key in encoding_storage[base].keys()]) for base in base_tasks]
if len(base_tasks) == 15:
figsize = (20, 5)
elif len(base_tasks) == 10:
figsize = (15, 5)
elif len(base_tasks) == 1:
figsize = (7, 5)
elif len(base_tasks) == 3:
figsize = (7, 5)
else:
figsize = None
fig, axes_tuple = plt.subplots(nrows=3, ncols=len(base_tasks), sharex='col', sharey='row', gridspec_kw={'height_ratios': [3, 1, 1]}, figsize=figsize)
if len(axes_tuple.shape) == 1:
axes_tuple = np.expand_dims(axes_tuple, 1)
latent_dim = encoding_storage[base_tasks[0]][next(iter(encoding_storage[base_tasks[0]]))]['mean'].shape[0]
# Normalization over base tasks of dim
if normalize:
normalizer = []
mean_std = ['mean', 'std']
for dim in range(latent_dim):
temp_dict = {}
for element in mean_std:
values = np.array([a[element][dim] for base in base_tasks for a in list(encoding_storage[base].values())])
temp_dict[element] = dict(mean=values.mean(), std=values.std())
normalizer.append(temp_dict)
for i, base in enumerate(base_tasks):
# encodings
#target_values = np.array([encoding_storage[base][key]['target'][2] for key in encoding_storage[base].keys()])
#sort_indices = np.argsort(target_values)
for dim in range(latent_dim):
x_values = np.array([a['mean'][dim] for a in list(encoding_storage[base].values())])#[sort_indices]
y_values = np.array([a['std'][dim] for a in list(encoding_storage[base].values())])#[sort_indices]
#Normalize
if normalize:
x_values = (x_values - normalizer[dim]['mean']['mean']) / (normalizer[dim]['mean']['std'] + 1e-9)
y_values = (y_values - normalizer[dim]['std']['mean']) / (normalizer[dim]['std']['std'] + 1e-9)
label_string = "Encoding $z_" + str(dim) + "$"
#axes_tuple[0][i].errorbar(target_values[sort_indices], x_values, yerr=y_values, fmt=".", label=label_string)
axes_tuple[0][i].errorbar(np.array(list(encoding_storage[base].keys())), x_values, yerr=y_values, fmt=".", label=label_string)#, capsize=2
if axes_tuple.shape[1] > 1:
#axes_tuple[0][i].set_title("Base Task " + str(i))
nameWithoutVersion = '-'.join(number2name[base].split('-')[:-1])
if len(nameWithoutVersion.split('-')) > 2:
split_name = '-'.join(nameWithoutVersion.split('-')[:2]) + " \n " + '-'.join(nameWithoutVersion.split('-')[2:])
else:
split_name = nameWithoutVersion
axes_tuple[0][i].set_title(split_name)
else:
axes_tuple[0][i].set_title("Epoch " + str(epoch), fontsize=14)
# rewards
#axes_tuple[2][i].plot(np.array(list(encoding_storage[base].keys())), [encoding_storage[base][i]['reward_mean'] for i in encoding_storage[base].keys()], 'x')
axes_tuple[2][i].bar(np.array(list(encoding_storage[base].keys())), [encoding_storage[base][i]['reward_mean'] for i in encoding_storage[base].keys()], width=0.01, align='center')
# base task encodings
#axes_tuple[1][i].plot(target_values[sort_indices], [np.argmax(a['base']) for a in list(encoding_storage[base].values())], 'x', label="Base encoding $\mathbf{y}$")
axes_tuple[1][i].plot(list(encoding_storage[base].keys()), [np.argmax(a['base']) for a in list(encoding_storage[base].values())], 'x', label="Base encoding $\mathbf{y}$")
axes_tuple[1][i].set_xlabel("Specification", fontsize=12)
axes_tuple[1][i].set_yticks(np.arange(-1, len(base_tasks), 1), minor=True)
axes_tuple[1][0].set_ylim(-1, 10) #len(base_tasks)
axes_tuple[0][i].grid()
axes_tuple[1][i].grid(which='minor')
axes_tuple[1][i].grid(which='major')
axes_tuple[2][i].grid()
axes_tuple[0][0].set_ylabel('Encoding $\mathbf{z}$', fontsize=12)
axes_tuple[1][0].set_ylabel('Base task \n encoding $\mathbf{y}$', fontsize=12)
axes_tuple[2][0].set_ylabel('Average \n reward $R$', fontsize=12)
if legend:
axes_tuple[0][-1].legend(loc='center left', bbox_to_anchor=(1, 0.5), fancybox=True, shadow=True)
axes_tuple[1][-1].legend(loc='center left', bbox_to_anchor=(1, 0.5), fancybox=True, shadow=True)
if save:
plt.tight_layout()
fig.savefig(exp_directory + "/encoding_epoch_" + str(epoch) + ("_normalized" if normalize else "") + "_with_rewards" + ".pdf", format="pdf")
fig.show()
# print("Here to create plot 1")
print("Created plot")
def plot_encodings_split_with_rewards_cheetah(epoch, exp_directory, save=False, normalize=False, legend=False):
encoding_storage = pickle.load(open(os.path.join(exp_directory, "encoding_" + str(epoch) + ".p"), "rb"))
base_tasks = list(encoding_storage.keys())
#rewards_per_base_task = [sum([encoding_storage[base][key]['reward_mean'] / len(list(encoding_storage[base].keys())) for key in encoding_storage[base].keys()]) for base in base_tasks]
if len(base_tasks) == 15:
figsize = (20, 5)
elif len(base_tasks) == 10:
figsize = (15, 5)
elif len(base_tasks) == 1:
figsize = (7, 5)
elif len(base_tasks) == 3:
figsize = (7, 5)
else:
figsize = None
fig, axes_tuple = plt.subplots(nrows=3, ncols=len(base_tasks), sharex='col', sharey='row', gridspec_kw={'height_ratios': [3, 1, 1]}, figsize=figsize)
if len(axes_tuple.shape) == 1:
axes_tuple = np.expand_dims(axes_tuple, 1)
latent_dim = encoding_storage[base_tasks[0]][next(iter(encoding_storage[base_tasks[0]]))]['mean'].shape[0]
# Normalization over base tasks of dim
if normalize:
normalizer = []
mean_std = ['mean', 'std']
for dim in range(latent_dim):
temp_dict = {}
for element in mean_std:
values = np.array([a[element][dim] for base in base_tasks for a in list(encoding_storage[base].values())])
temp_dict[element] = dict(mean=values.mean(), std=values.std())
normalizer.append(temp_dict)
for i, base in enumerate(base_tasks):
# encodings
#target_values = np.array([encoding_storage[base][key]['target'][2] for key in encoding_storage[base].keys()])
#sort_indices = np.argsort(target_values)
for dim in range(latent_dim):
x_values = np.array([a['mean'][dim] for a in list(encoding_storage[base].values())])#[sort_indices]
y_values = np.array([a['std'][dim] for a in list(encoding_storage[base].values())])#[sort_indices]
#Normalize
if normalize:
x_values = (x_values - normalizer[dim]['mean']['mean']) / (normalizer[dim]['mean']['std'] + 1e-9)
y_values = (y_values - normalizer[dim]['std']['mean']) / (normalizer[dim]['std']['std'] + 1e-9)
label_string = "Encoding $z_" + str(dim) + "$"
#axes_tuple[0][i].errorbar(target_values[sort_indices], x_values, yerr=y_values, fmt=".", label=label_string)
axes_tuple[0][i].errorbar(np.array(list(encoding_storage[base].keys())), x_values, yerr=y_values, fmt=".", label=label_string)#, capsize=2
if axes_tuple.shape[1] > 1:
#axes_tuple[0][i].set_title("Base Task " + str(i))
nameWithoutVersion = '-'.join(number2name[base].split('-')[:-1])
if len(nameWithoutVersion.split('-')) > 2:
split_name = '-'.join(nameWithoutVersion.split('-')[:2]) + " \n " + '-'.join(nameWithoutVersion.split('-')[2:])
else:
split_name = nameWithoutVersion
split_name = number2name[base]
axes_tuple[0][i].set_title(split_name)
else:
axes_tuple[0][i].set_title("Epoch " + str(epoch), fontsize=14)
# rewards
#axes_tuple[2][i].plot(np.array(list(encoding_storage[base].keys())), [encoding_storage[base][i]['reward_mean'] for i in encoding_storage[base].keys()], 'x')
axes_tuple[2][i].bar(np.array(list(encoding_storage[base].keys())), [encoding_storage[base][i]['reward_mean'] for i in encoding_storage[base].keys()], width=0.01, align='center')
# base task encodings
#axes_tuple[1][i].plot(target_values[sort_indices], [np.argmax(a['base']) for a in list(encoding_storage[base].values())], 'x', label="Base encoding $\mathbf{y}$")
axes_tuple[1][i].plot(list(encoding_storage[base].keys()), [np.argmax(a['base']) for a in list(encoding_storage[base].values())], 'x', label="Base encoding $\mathbf{y}$")
axes_tuple[1][i].set_xlabel("Specification", fontsize=12)
axes_tuple[1][i].set_yticks(np.arange(-1, len(base_tasks), 1), minor=True)
axes_tuple[1][0].set_ylim(-1, 10) #len(base_tasks)
axes_tuple[0][i].grid()
axes_tuple[1][i].grid(which='minor')
axes_tuple[1][i].grid(which='major')
axes_tuple[2][i].grid()
axes_tuple[0][0].set_ylabel('Encoding $\mathbf{z}$', fontsize=12)
axes_tuple[1][0].set_ylabel('Base task \n encoding $\mathbf{y}$', fontsize=12)
axes_tuple[2][0].set_ylabel('Average \n reward $R$', fontsize=12)
if legend:
axes_tuple[0][-1].legend(loc='center left', bbox_to_anchor=(1, 0.5), fancybox=True, shadow=True)
axes_tuple[1][-1].legend(loc='center left', bbox_to_anchor=(1, 0.5), fancybox=True, shadow=True)
if save:
plt.tight_layout()
fig.savefig(exp_directory + "/encoding_epoch_" + str(epoch) + ("_normalized" if normalize else "") + "_with_rewards" + ".pdf", format="pdf")
fig.show()
print("Created plot")
def plot_encodings_split(epoch, exp_directory, save=False, normalize=False, legend=False):
encoding_storage = pickle.load(open(os.path.join(exp_directory, "encoding_" + str(epoch) + ".p"), "rb"))
base_tasks = list(encoding_storage.keys())
if len(base_tasks) == 10:
figsize = (15, 5)
elif len(base_tasks) == 1:
figsize = (7, 5)
elif len(base_tasks) == 3:
figsize = (7, 5)
else:
figsize = None
fig, axes_tuple = plt.subplots(nrows=2, ncols=len(base_tasks), sharex='col', sharey='row', gridspec_kw={'height_ratios': [3, 1]}, figsize=figsize)
if len(axes_tuple.shape) == 1:
axes_tuple = np.expand_dims(axes_tuple, 1)
latent_dim = encoding_storage[base_tasks[0]][next(iter(encoding_storage[base_tasks[0]]))]['mean'].shape[0]
base_task_encodings = [np.argmax(a['base']) for base in base_tasks for a in list(encoding_storage[base].values())]
# Normalization over base tasks of dim
if normalize:
normalizer = []
mean_std = ['mean', 'std']
for dim in range(latent_dim):
temp_dict = {}
for element in mean_std:
values = np.array([a[element][dim] for base in base_tasks for a in list(encoding_storage[base].values())])
temp_dict[element] = dict(mean=values.mean(), std=values.std())
normalizer.append(temp_dict)
for i, base in enumerate(base_tasks):
fontsize=26
# encodings
#target_values = np.array([encoding_storage[base][key]['target'][2] for key in encoding_storage[base].keys()])
#sort_indices = np.argsort(target_values)
for dim in range(latent_dim):
x_values = np.array([a['mean'][dim] for a in list(encoding_storage[base].values())])#[sort_indices]
y_values = np.array([a['std'][dim] for a in list(encoding_storage[base].values())])#[sort_indices]
#Normalize
if normalize:
x_values = (x_values - normalizer[dim]['mean']['mean']) / (normalizer[dim]['mean']['std'] + 1e-9)
y_values = (y_values - normalizer[dim]['std']['mean']) / (normalizer[dim]['std']['std'] + 1e-9)
label_string = "Encoding $z_" + str(dim) + "$"
# 2 classes: capsize=3, elinewidth=3, capthick=3, markersize=9
# more classes: capsize=2, elinewidth=2, capthick=2, markersize=7
axes_tuple[0][i].errorbar(np.array(list(encoding_storage[base].keys())), x_values, yerr=y_values,
fmt="d", color='tab:green', label=label_string, capsize=2, elinewidth=2, capthick=2, markersize=7,
markerfacecolor='yellow', markeredgecolor='black')
if axes_tuple.shape[1] > 1:
#axes_tuple[0][i].set_title("Base Task " + str(i))
nameWithoutVersion = '-'.join(number2name[base].split('-')[:-1])
if len(nameWithoutVersion.split('-')) > 2:
split_name = '-'.join(nameWithoutVersion.split('-')[:2]) + " \n " + '-'.join(nameWithoutVersion.split('-')[2:])
else:
split_name = nameWithoutVersion
split_name = number2name[base]
axes_tuple[0][i].set_title(split_name, fontsize=fontsize)
else:
axes_tuple[0][i].set_title("Epoch " + str(epoch), fontsize=fontsize)
# base task encodings
axes_tuple[1][i].plot(list(encoding_storage[base].keys()), [np.argmax(task['base']) for task in list(encoding_storage[base].values())], 'd', color='yellow', markersize=7, markerfacecolor='yellow', markeredgecolor='black') # markersize=7 for multiple tasks, 9 for two
axes_tuple[1][i].set_xlabel("Specification", fontsize=fontsize)
axes_tuple[1][i].set_ylim(-1, np.max(base_task_encodings) + 1)
axes_tuple[0][i].tick_params(axis="x", labelsize=fontsize)
axes_tuple[0][i].tick_params(axis="y", labelsize=fontsize)
axes_tuple[1][i].tick_params(axis="x", labelsize=fontsize)
axes_tuple[1][i].tick_params(axis="y", labelsize=fontsize)
axes_tuple[1][i].set_yticks(np.arange(-1, np.max(base_task_encodings) + 2, 1))
axes_tuple[0][i].grid(b=True, which='major', alpha=1)
axes_tuple[1][i].grid(which='minor')
axes_tuple[1][i].grid(which='major')
axes_tuple[0][0].set_ylabel('Encoding $\mathbf{z}$', fontsize=fontsize)
axes_tuple[1][0].set_ylabel('Encoding $\mathbf{y}$', fontsize=fontsize)
plt.tight_layout()
if legend:
axes_tuple[0][-1].legend(loc='center left', bbox_to_anchor=(1, 0.5), fancybox=True, shadow=True, fontsize=fontsize)
axes_tuple[1][-1].legend(loc='center left', bbox_to_anchor=(1, 0.5), fancybox=True, shadow=True, fontsize=fontsize)
plt.subplots_adjust(wspace=0.15, hspace=0.15)
plt.grid(b=True, which='major', alpha=1)
if save:
fig.savefig(exp_directory + "/encoding_epoch_" + str(epoch) + ("_normalized" if normalize else "") + ".pdf", format="pdf", bbox_inches = "tight")
plt.show()
print(exp_directory)
print("Created plot")
def plot_encodings(epoch, exp_directory, save=False, normalize=False):
encoding_storage = pickle.load(open(os.path.join(exp_directory, "encoding_" + str(epoch) + ".p"), "rb"))
base_tasks = list(encoding_storage.keys())
fig, axes_tuple = plt.subplots(ncols=len(base_tasks), sharey='row')
#fig, axes_tuple = plt.subplots(ncols=len(base_tasks), sharey='row')
fig, axes_tuple = plt.subplots(ncols=len(base_tasks), sharey='row', figsize=(15, 3))
#fig.suptitle("Epoch " + str(epoch), fontsize="x-large")
if len(base_tasks) == 1: axes_tuple = [axes_tuple]
latent_dim = encoding_storage[base_tasks[0]][next(iter(encoding_storage[base_tasks[0]]))]['mean'].shape[0]
for i, base in enumerate(base_tasks):
for dim in range(latent_dim):
x_values = np.array([a['mean'][dim] for a in list(encoding_storage[base].values())])
y_values = np.array([a['std'][dim] for a in list(encoding_storage[base].values())])
#Normalize
if normalize:
mean = x_values.mean()
std = x_values.std()
x_values = (x_values - mean) / (std + 1e-9)
mean = y_values.mean()
std = y_values.std()
y_values = (y_values - mean) / (std + 1e-9)
axes_tuple[i].errorbar(list(encoding_storage[base].keys()), x_values, yerr=y_values, fmt=".", label="Encoding $\mathbf{z}$")
axes_tuple[i].plot(list(encoding_storage[base].keys()), [np.argmax(a['base']) for a in list(encoding_storage[base].values())], 'x', label="Class encoding $\mathbf{y}$")
#axes_tuple[i].set_title("Base Task " + str(i) + ", Epoch " + str(epoch))
axes_tuple[i].set_title("Base Task " + str(i))
#axes_tuple[i].set_title("Epoch " + str(epoch))
#axes_tuple[i].set_xlabel("Specification") #, fontsize=10
axes_tuple[i].grid()
#axes_tuple[i].set_ylim(-0.1, 0.1)
#axes_tuple[i].legend()
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), fancybox=True, shadow=True)
#fig.text(0.0, 0.5, 'Encoding $\mathbf{z}$', va='center', rotation='vertical')
#plt.subplots_adjust(wspace=0, hspace=0)
if save:
fig.savefig(exp_directory + "/encoding_epoch" + str(epoch) + ("_normalized" if normalize else "") +".pdf", dpi=300, format="pdf")
plt.show()
print("Created plot")
def plot_encodings_2D(epoch, exp_directory):
encoding_storage = pickle.load(open(os.path.join(exp_directory, "encoding_" + str(epoch) + ".p"), "rb"))
base_tasks = list(encoding_storage.keys())
fig, ax = plt.subplots()
for i, base in enumerate(base_tasks):
specification = np.array(list(encoding_storage[base].keys()))
spec_max = specification.max()
means1 = [a['mean'][0] for a in list(encoding_storage[base].values())]
means2 = [a['mean'][1] for a in list(encoding_storage[base].values())]
vars1 = [a['mean'][0] for a in list(encoding_storage[base].values())]
vars2 = [a['mean'][1] for a in list(encoding_storage[base].values())]
points = ax.scatter(means1, means2, c=specification, cmap='autumn', zorder=0)
ax.errorbar(means1, means2, xerr=np.array(vars1) / 2, yerr= | np.array(vars2) | numpy.array |
'''
metrics
Contact: <EMAIL>
'''
# imports
import numpy as np
def dice(vol1, vol2, labels=None, nargout=1):
'''
Dice [1] volume overlap metric
The default is to *not* return a measure for the background layer (label = 0)
[1] Dice, <NAME>. "Measures of the amount of ecologic association between species."
Ecology 26.3 (1945): 297-302.
Parameters
----------
vol1 : nd array. The first volume (e.g. predicted volume)
vol2 : nd array. The second volume (e.g. "true" volume)
labels : optional vector of labels on which to compute Dice.
If this is not provided, Dice is computed on all non-background (non-0) labels
nargout : optional control of output arguments. if 1, output Dice measure(s).
if 2, output tuple of (Dice, labels)
Output
------
if nargout == 1 : dice : vector of dice measures for each labels
if nargout == 2 : (dice, labels) : where labels is a vector of the labels on which
dice was computed
'''
if labels is None:
labels = np.unique(np.concatenate((vol1, vol2)))
labels = np.delete(labels, np.where(labels == 0)) # remove background
dicem = np.zeros(len(labels))
for idx, lab in enumerate(labels):
top = 2 * np.sum( | np.logical_and(vol1 == lab, vol2 == lab) | numpy.logical_and |
# coding=utf-8
# Copyright 2020 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Script for generating the binary classification datasets from CIFAR10/MNIST.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
from absl import app
from absl import flags
import numpy as np
import sklearn
import sklearn.datasets
import sklearn.metrics
import sklearn.model_selection
import sklearn.preprocessing
import tensorflow_datasets as tfds
import task_pb2
flags.DEFINE_string(
'data_dir', '/tmp/binary_cifar10_data/',
'Path of the folder to save the datasets.')
flags.DEFINE_string(
'tfds_data_dir', '/tmp/',
'Path for tensorflow_datasets to cache downloaded datasets, '
'only used in local runs.')
flags.DEFINE_integer('num_train_examples', 8000,
'Number of training examples in each dataset.')
flags.DEFINE_integer('num_valid_examples', 1000,
'Number of validation examples in each dataset.')
flags.DEFINE_integer('num_test_examples', 1000,
'Number of test examples in each dataset.')
flags.DEFINE_integer('projected_dim', 16,
'The dimensionality to project the data into.')
flags.DEFINE_string('dataset_name', 'cifar10',
'Name of the dataset to generatee '
'more binary classification datasets.')
flags.DEFINE_integer('min_data_seed', 0,
'Generate one dataset for each seed in '
'[min_data_seed, max_data_seed).')
flags.DEFINE_integer('max_data_seed', 100,
'Generate one dataset for each seed in '
'[min_data_seed, max_data_seed).')
flags.DEFINE_list('class_ids', '0,1,2,3,4,5,6,7,8,9',
'Classes included to generate binary'
' classification datasets.')
FLAGS = flags.FLAGS
def create_projected_binary_dataset(
dataset_name, positive_class, negative_class,
num_train_examples, num_valid_examples, num_test_examples,
projected_dim, seed, load_fn):
"""Create a projected binary dataset from the given spec and seed."""
num_samples = (
num_train_examples +
num_valid_examples +
num_test_examples)
pos = positive_class
neg = negative_class
# Only support training data from MNIST and CIFAR10 for experiments.
data, labels, _, _ = get_dataset(
dataset_name,
int(num_samples / 2), [pos, neg], load_fn=load_fn)
labels[np.where(labels == pos)] = -1
labels[np.where(labels == neg)] = 0
labels[np.where(labels == -1)] = 1
(train_data, train_labels, valid_data, valid_labels,
test_data, test_labels) = train_valid_test_split(
data, labels,
num_train_examples,
num_valid_examples,
num_test_examples,
seed)
np.random.seed(seed)
random_mat = np.random.randn(
train_data.shape[-1], projected_dim)
train_data = np.dot(train_data, random_mat)
valid_data = np.dot(valid_data, random_mat)
if test_data is not None:
test_data = np.dot(test_data, random_mat)
scaler = sklearn.preprocessing.StandardScaler()
scaler.fit(train_data)
train_data = scaler.transform(train_data)
valid_data = scaler.transform(valid_data)
if test_data is not None:
test_data = scaler.transform(test_data)
dataset = task_pb2.ScalarLabelDataset()
for i in range(train_data.shape[0]):
train_feature = dataset.train_features.add()
train_feature.features.extend(list(train_data[i]))
dataset.train_labels.append(train_labels[i])
for i in range(valid_data.shape[0]):
valid_feature = dataset.valid_features.add()
valid_feature.features.extend(list(valid_data[i]))
dataset.valid_labels.append(valid_labels[i])
if test_data is not None:
for i in range(test_data.shape[0]):
test_feature = dataset.test_features.add()
test_feature.features.extend(list(test_data[i]))
dataset.test_labels.append(test_labels[i])
return dataset
def load_projected_binary_dataset(saved_dataset):
"""Load the binary dataset saved in a ScalarLabelDataset proto."""
num_train = len(saved_dataset.train_labels)
assert len(saved_dataset.train_labels) == len(saved_dataset.train_features)
num_valid = len(saved_dataset.valid_labels)
assert len(saved_dataset.valid_labels) == len(saved_dataset.valid_features)
num_test = len(saved_dataset.test_labels)
assert len(saved_dataset.test_labels) == len(saved_dataset.test_features)
if num_train == 0 or num_valid == 0:
raise ValueError('Number of train/valid examples'
' must be more than zero.')
feature_size = len(saved_dataset.train_features[0].features)
train_data = np.zeros((num_train, feature_size))
train_labels = np.zeros(num_train)
for i in range(num_train):
train_labels[i] = saved_dataset.train_labels[i]
for j in range(feature_size):
train_data[i][j] = saved_dataset.train_features[i].features[j]
valid_data = np.zeros((num_valid, feature_size))
valid_labels = | np.zeros(num_valid) | numpy.zeros |
#!/usr/bin/env python #
# #
# Autor: <NAME>, GSFC/CRESST/UMBC . #
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 3 of the License, or #
# (at your option) any later version. #
# #
#------------------------------------------------------------------------------#
import os
import re
import numpy as np
import healpy as hp
from numba import jit
import astropy.io.fits as pf
from itertools import product
from scipy.special import factorial
from scipy.interpolate import griddata
import matplotlib.pyplot as plt
from Xgam import X_OUT
from Xgam.utils.logging_ import logger, startmsg
from Xgam.utils.spline_ import xInterpolatedUnivariateSplineLinear
FORE_EN = re.compile('\_\d+\.')
def get_fore_integral_flux_map(fore_files_list, e_min, e_max):
"""
A powerlaw is assumed for the foreground energy spectrum, hence
the interpolation between 2 given maps at given energies (given
by the model) is done in logarithmic scales.
Parameters
----------
fore_files_list: list of str
Ordered list of the foreground files (one for each energy)
e_min: float
the min of the energy bin
e_max: float
the max of the energy bin
Returns
-------
array
foreground map integrated between e_min and e_max
"""
fore_en = []
for ff in fore_files_list:
m = re.search(FORE_EN, ff)
en = int(m.group(0).replace('_', '').replace('.', ''))
fore_en.append(en)
fore_en = np.array(fore_en)
out_name = fore_files_list[0].replace('_%i.fits'%fore_en[0],
'_%d-%d.fits'%(e_min, e_max))
if os.path.exists(out_name):
logger.info('ATT: file %s already exists and returned...'%out_name)
fore_map = hp.read_map(out_name)
return fore_map
else:
logger.info('Computing the integral flux of the foreground model...')
logger.info('...between %.2f - %.2f'%(e_min, e_max))
fore_emin_sx, fore_emin_dx = find_outer_energies(e_min, fore_en)
fore_emax_sx, fore_emax_dx = find_outer_energies(e_max, fore_en)
fore_emin_sx_ind = np.where(fore_en == fore_emin_sx)[0][0]
fore_emin_dx_ind = np.where(fore_en == fore_emin_dx)[0][0]
fore_emax_sx_ind = np.where(fore_en == fore_emax_sx)[0][0]
fore_emax_dx_ind = np.where(fore_en == fore_emax_dx)[0][0]
fore_fmin_sx = hp.read_map(fore_files_list[fore_emin_sx_ind])
fore_fmin_dx = hp.read_map(fore_files_list[fore_emin_dx_ind])
fore_fmax_sx = hp.read_map(fore_files_list[fore_emax_sx_ind])
fore_fmax_dx = hp.read_map(fore_files_list[fore_emax_dx_ind])
m1 = (np.log10(fore_fmin_sx)-np.log10(fore_fmin_dx))/ \
(np.log10(fore_emin_sx)-np.log10(fore_emin_dx))
m2 = (np.log10(fore_fmax_sx)-np.log10(fore_fmax_dx))/ \
(np.log10(fore_emax_sx)-np.log10(fore_emax_dx))
logfore1 = m1*(np.log10(e_min)-np.log10(fore_emin_sx))+ \
np.log10(fore_fmin_sx)
logfore2 = m2*(np.log10(e_max)-np.log10(fore_emax_sx))+ \
np.log10(fore_fmax_sx)
fore1 = 10**(logfore1)
fore2 = 10**(logfore2)
fore_integ_map = np.sqrt(fore1*fore2)*(e_max - e_min)
hp.write_map(out_name, fore_integ_map)
logger.info('Created file %s'%out_name)
return fore_integ_map
def find_outer_energies(en_val, en_arr):
"""
Gives the first element on the right and the first on the left
of a given E value (en_val), among all values in an ordered array (en_arr).
These values are used to integrate the foreground model in the considered energy bin.
Parameters
----------
en_val : float
mean energy
en_arr : float
array of the energies at which the foreground model is given.
Returns
-------
float, float
first element on the right and the first on the left
"""
en_sx_arr = en_arr[en_arr < en_val]
en_dx_arr = en_arr[en_arr > en_val]
if en_sx_arr.size == 0:
en_sx = en_dx_arr[0]
en_dx = en_dx_arr[1]
logger.info('Considering model in the interval %.1f-%.1f MeV'
%(en_sx, en_dx))
elif en_dx_arr.size == 0:
en_sx = en_sx_arr[-2]
en_dx = en_sx_arr[-1]
logger.info('Considering model in the interval %.1f-%.1f MeV'
%(en_sx, en_dx))
else:
en_sx = en_sx_arr[-1]
en_dx = en_dx_arr[0]
return en_sx, en_dx
@jit
def myfactorial(_x):
_facx = []
for x in _x:
n = 1
for i in range(2, x+1):
n *= i
_facx.append(n)
return np.array(_facx)
@jit
def poisson_likelihood(norm_guess, const_guess, fore_map, data_map, exp=None, sr=None):
"""
Compute the log-likelihood as decribed here:
http://iopscience.iop.org/article/10.1088/0004-637X/750/1/3/pdf
where the model to fit to data is given by norm*fore_map+const.
Parameters
----------
norm_guess : float
initial guess for normalization parameter
const_guess : float
initial guess for constant parameter
fore_map : numpy array
helapix map of foreground model
data_map : numpy array
helapix map of data. It could be either a count map or a flux map.
If a counts map is given, an exposure map should be given too. See
next parameter.
exp : numpy array or None
helapix map of the exposure. Should be given if the data map is in
counts (beacause foreground map is in flux units by default and it
needs to be turned to counts to be fitted). While, If data map is
in flux units, do not declare this parameter, which is None by
default.
sr : float or None
pixel area -> 4*pi/Npix
Returns
-------
float
likelihood value.
"""
a = norm_guess
b = const_guess
factorial_data = factorial(data_map)
lh = 0
if exp is not None:
for i, f in enumerate(fore_map):
lh += (a*f+b)*exp[i]*sr+np.log(factorial_data[i])-data_map[i]*np.log((a*f+b)*exp[i]*sr)
else:
for i, f in enumerate(fore_map):
lh += np.sum(((a*f+b)+np.log(factorial_data[i])-data_map[i]*np.log((a*f+b))))
return lh
def get_2params_profile_likelihood(lh_matrix, param1_list, param2_list):
"""
Returns splines with profile likelihood for the two parameters of the fit.
NOTE: param1 is supposed to be the normalization, param2 the constant.
"""
n_lh = np.amin(lh_matrix, axis=1)
c_lh = np.amin(lh_matrix, axis=0)
fmt1 = dict(xname='N', xunits='', yname='Likelihood', yunits='')
spline1 = xInterpolatedUnivariateSplineLinear(param1_list, n_lh, **fmt1)
fmt2 = dict(xname='C', xunits='', yname='Likelihood', yunits='')
spline2 = xInterpolatedUnivariateSplineLinear(param2_list, c_lh, **fmt2)
return spline1, spline2
def get_param_error(profilelh_spline, param_array, lh_delta=2.3):
"""
"""
lh_array = profilelh_spline(param_array)
lh_min_idx = np.argmin(lh_array)
lherr = lh_array[lh_min_idx]+lh_delta
if lh_min_idx == 0:
logger.info('ATT: UPPER limit!')
sx_err = param_array[0]
dx_err = param_array[-1]
elif lh_min_idx == len(lh_array)-1:
logger.info('ATT: LOWER limit!')
sx_err = param_array[0]
dx_err = param_array[-1]
else:
sx_err = param_array[np.abs(lh_array[:lh_min_idx]-lherr).argmin()]
dx_err = param_array[lh_min_idx + np.abs(lh_array[lh_min_idx:]-lherr).argmin()]
return sx_err, dx_err
def fit_foreground_poisson(fore_map, data_map, mask_map=None, n_guess=1.,
c_guess=0.1,exp=None, smooth=False, show=False):
"""
Performs the poissonian fit, recursively computing the log likelihood
(using poisson_likelihood) for a grid of values of fit parameters around
the guess. Returns the values of parameters which minimize the log
likelihood, togather to the 1-sigma error
Parameters
----------
n_guess : float
initial guess for normalization parameter
c_guess : float
initial guess for constant parameter
fore_map : numpy array
helapix map of foreground model
data_map : numpy array
helapix map of data. It could be either a count map or a flux map.
If a counts map is given, an exposure map should be given too. See
next parameter.
exp : numpy array or None
helapix map of the exposure. Should be given if the data map is in
counts (beacause foreground map is in flux units by default and it
needs to be turned to counts to be fitted). While, If data map is
in flux units, do not declare this parameter, which is None by
default.
smooth : bool
not implemented yet...
show : bool
if true it shows some usefull plot to check if the fit is functioning
Returns
-------
float, float, float, float, float, float
In order: best fit N, best fit C, N's right error, N's left error,
C's right error, C's left error
"""
#show=True
#mask_map=None
logger.info('Performing poissonian fit...')
norm_guess = n_guess
igrb_guess = c_guess
nside_out = 64
mask = 0.
logger.info('N guess = %.2f - C guess = %.1e'%(norm_guess, igrb_guess))
if mask_map is None:
logger.info('fit outside default mask: 30deg gp, 2 deg srcs.')
mask_f = os.path.join(X_OUT, 'fits/Mask_hp64_src2_gp30.fits')
mask = hp.read_map(mask_f)
else:
logger.info('fit outside mask given in config file.')
mask = mask_map
mask = np.array(hp.ud_grade(mask, nside_out=nside_out,
power=-2))
mask[np.where(mask!=np.amax(mask))[0]] = 0
mask[np.where(mask==np.amax(mask))[0]] = 1
logger.info('down grade...')
fore_repix = np.array(hp.ud_grade(fore_map, nside_out=nside_out))
data_repix = np.array(hp.ud_grade(data_map, nside_out=nside_out, power=-2))
_unmask = np.where(mask > 1e-30)[0]
norm_list = np.linspace(norm_guess-0.8, norm_guess+0.8, 200)
igrb_list = np.logspace(np.log10(igrb_guess*0.01), np.log10(igrb_guess*10), 200)
logger.info('-------------------------------')
logger.info('Minimization likelihood run1...')
lh_list = []
combinations = list(product(norm_list, igrb_list))
if exp is not None:
exposure = exp
exposure = np.array(hp.ud_grade(exposure, nside_out=nside_out))
areapix = 4*np.pi/(len(data_repix))
for i,j in product(norm_list, igrb_list):
lh = poisson_likelihood(i, j, fore_repix[_unmask],
data_repix[_unmask],
exp=exposure[_unmask],
sr=areapix)
lh_list.append(lh)
else:
for i,j in product(norm_list, igrb_list):
lh = poisson_likelihood(i, j, fore_repix[_unmask], data_repix[_unmask])
lh_list.append(lh)
lh_list = | np.array(lh_list) | numpy.array |
#!/usr/bin/env python
# coding: utf-8
# <div class="alert alert-block alert-info">
# <b><h1>ENGR 1330 Computational Thinking with Data Science </h1></b>
# </div>
#
# Copyright © 2021 <NAME> and <NAME>
#
# Last GitHub Commit Date:
#
# # 9: Matrix Manipulation(s) using *NumPy*
# - How to install
# - conda
# - pip in JupyterHub/Lab (on Linux)
# - About NumPy
# - Arrays
# - Array Methods
# - Examples using NumPy to illustrate abstraction to maintainable scripts
#
# ---
# ## Objectives
# - To understand the representation of data in different structure using the NumPy library(module).
# - Access data within a NumPy array
# - Perform arithmetic/mathematical operations on the contents of NumPy arrays
#
# ---
#
# ### Numpy
# Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. The library’s name is short for “Numeric Python” or “Numerical Python”. If you are curious about NumPy, this cheat sheet is recommended:
# https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Numpy_Python_Cheat_Sheet.pdf
#
# NumPy library has two fundamental conceptualizations:
# - Data representation: Arrays
# - vectors
# - matrices
# - Data operations:
# - Element-by-element arithmetic, and mathematical operations;
# - Matrix/vector arithmetic
# - Indexing
# - Selection
# - Copying
# ---
#
# ## Computational Thinking Concepts
#
# The CT concepts expressed within NumPy include:
#
# - `Decomposition` : Break a problem down into smaller pieces; Data interpretation, manipulation, and analysis of NumPy arrays is an act of decomposition.
# - `Abstraction` : Pulling out specific differences to make one solution work for multiple problems; The array is a data representation abstraction that allows for placeholder operations, later substituted with specific contents for a problem; enhances reuse and readability. Generally we leverage the principle of algebraic replacement using these abstractions.
# - `Algorithms` : A list of steps that you can follow to finish a task; Data interpretation, manipulation, and analysis of NumPy arrays is generally implemented as part of a supervisory algorithm.
# ---
#
# ## Module Set-Up
#
# In principle, NumPy should be available in a default Anaconda install
# - You should not have to do any extra installation steps to install the library in Python
# - You do have to **import** the library in your scripts
#
# How to check
# - Simply open a code cell and run `import numpy` if the notebook does not protest (i.e. pink block of error), you is good to go.
# In[1]:
import numpy
# If you do get an error, that means that you will probably have to install using `conda` or `pip`; generally this process of installation is only needed occassionally, you are installing into your kernel the needed funcrtionality.
#
# :::{note}
# On the **content server** the process is:
#
# 1. Open a new terminal from the launcher
# 2. Change to root user `su` then enter the root password
# 3. `sudo -H /opt/jupyterhib/bin/python3 -m pip install numpy`
# 4. Wait until the install is complete; for security, user `compthink` is not in the `sudo` group
# 5. Verify the install by trying to execute `import numpy` as above.
#
# The process will be similar on a Macintosh, or Windows. Best is to hope you have a sucessful anaconda install.
# :::
#
# If you have to do this kind of install, you will have to do some reading, some references I find useful are:
# 1. https://jupyterlab.readthedocs.io/en/stable/user/extensions.html
# 2. https://www.pugetsystems.com/labs/hpc/Note-How-To-Install-JupyterHub-on-a-Local-Server-1673/#InstallJupyterHub
# 3. https://jupyterhub.readthedocs.io/en/stable/installation-guide-hard.html (This is the approach on the content server which has a functioning JupyterHub)
#
# :::{note}
# The conda installer is accessed using the conda powershell prompt, accessed from Anaconda Navigator.
#
# Here are some useful videos:
#
# - [Conda and Pip Installer(s)](https://www.youtube.com/watch?v=Z_Kxg-EYvxM)
# - [Conda package manager](https://www.youtube.com/watch?v=JQtppspwtHE)
# - [Conda environments](https://www.youtube.com/watch?v=KBC3oc0VK0g)
# - [Anaconda environment - Conda package manager](https://www.youtube.com/watch?v=PPKj9ic5MmI)
#
# :::
#
# ---
#
# ## NumPy: AKA Numerical Python
#
# NumPy is a foundational library (module) for scientific computing. Most if not all all data science libraries (modules) rely on NumPy as one of their building blocks to reduce the need to build certain operations in primative python.
#
# NumPy provides a multi-dimensional array object called ‘ndarray’ (n-dimensional array) and methods for:
# - Computations with arrays and mathematical operations between arrays (array-by-array and element-by-element)
# - Linear algebra operations
# - Psuedo random number generation
#
# As compared to the prior lesson, multi-dimensional arrays (lists) are far easier to manipulate using numpy.
# ---
#
# ### Arrays
# A numpy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension.
#
# The figure below is a visual depiction of numpy arrays of rank 1 and rank2.
#
# <img src="http://54.243.252.9/engr-1330-webroot/1-Lessons/Lesson09/numpyarray.png" width="500">
#
# In other words, an array contains information about the raw data, how to locate an element and how to interpret an element.To make a numpy array, you can just use the `np.array()` function. All you need to do is pass a list to it. Don’t forget that, in order to work with the `np.array()` function, you need to make sure that the `numpy` library is present in your environment.
# If you want to read more about the differences between a Python list and NumPy array, this link is recommended:
# [https://webcourses.ucf.edu/courses/1249560/pages/python-lists-vs-numpy-arrays-what-is-the-difference](https://webcourses.ucf.edu/courses/1249560/pages/python-lists-vs-numpy-arrays-what-is-the-difference)
#
# ---
#
# ### Example- 1D Arrays (Vectors)
# Let's create a 1D array from the 2000s (2000-2009):
# In[2]:
import numpy #First, we need to impoty "numpy"
mylist = [2000,2001,2002,2003,2004,2005,2006,2007,2008,2009] #Create a list of the years
type(mylist)
# In[3]:
print(mylist) #Check how it looks
# In[4]:
mylist = numpy.array(mylist) #Type cast it as a numpy array
type(mylist)
# In[5]:
print(mylist)
# In[6]:
my2dlist = [[1,2,3],[4,5,6],[7,8,9]]
type(my2dlist)
# In[7]:
print(my2dlist)
# In[8]:
my2dlist= numpy.array(my2dlist) #Type cast it as a numpy array
type(mylist)
# In[9]:
print(my2dlist)
# In[10]:
len(my2dlist) #how many rows
# In[11]:
len(my2dlist[0]) #how many columns
# In[12]:
numpy.shape(my2dlist) # using the shape method
# ---
#
# ### Example: n-Dimensional Arrays
#
# We already made a 3X3 array, but let's create a 5x2 array from the 2000s (2000-2009):
# In[13]:
myotherlist = [[2000,2001],[2002,2003],[2004,2005],[2006,2007],[2008,2009]] #Since I want a 5x2 array, I should group the years two by two
print(myotherlist) #See how it looks as a list
print(numpy.shape(myotherlist)) #check the shape
print(numpy.array(myotherlist) ) #See how it looks as a numpy array
# ---
#
# #### Array Arithmetic
# Once you have created the arrays, you can do basic Numpy operations. Numpy offers a variety of operations applicable on arrays. From basic operations such as summation, subtraction, multiplication and division to more advanced and essential operations such as matrix multiplication and other elementwise operations. In the examples below, we will go over some of these:
#
# ---
#
# ### Example- 1D Array Arithmetic
# - Define a 1D array with [0,12,24,36,48,60,72,84,96]
#
# Lets do scalar multiplication, first as just a list!
# ```
# # interactive cell - copy/paste into a notebook to run
# victorVector = [0,12,24,36,48,60,72,84,96]
# MyScalar = input("Enter scalar value \n")
# MyScalar = float(MyScalar) # force a float
# # now perform element-by-element multiplication
# for i in range(0,len(victorVector),1):
# victorVector[i] = MyScalar * victorVector[i] # this will change contents of amatrix
# print(victorVector)
# ```
# Now using numpy
# In[14]:
import numpy #import numpy
Array1 = numpy.array([0,12,24,36,48,60,72,84,96]) #Step1: Define Array1
print(Array1)
# - Multiply all elements by scalar value (scalar multiplication), print result, leave array unchanged
# ```
# # interactive cell - cut/paste into a notebook to run
# MyScalar = input("Enter scalar value \n")
# MyScalar = float(MyScalar) # force a float
# # now perform element-by-element multiplication
# print(Array1*MyScalar) #Step2: Multiple all elements by 2
# ```
# - Take all elements to the power of 2
# In[15]:
print(Array1**2) #Step3: Take all elements to the power of 2
# In[16]:
print(numpy.power(Array1,2)) #Another way to do the same thing, by using a function in numpy
# - Find the maximum value of the array and its position
# In[17]:
print(numpy.max(Array1)) #Step4: Find the maximum value of the array
# In[18]:
print(numpy.argmax(Array1)) ##Step4: Find the postition of the maximum value
# - Find the minimum value of the array and its position
# In[19]:
print(numpy.min(Array1)) #Step5: Find the minimum value of the array
# In[20]:
print(numpy.argmin(Array1)) ##Step5: Find the postition of the minimum value
# - Define another 1D array with [-12,0,12,24,36,48,60,72,84]
# In[21]:
Array2 = numpy.array([-12,0,12,24,36,48,60,72,84]) #Step6: Define Array2
print(Array2)
# - Find the element-by-element sum and difference of these two arrays
# In[22]:
print(Array1+Array2) #Step7: Sum of two arrays
print(Array1-Array2) #Step7: Difference of two arrays
# - Element-by-element multiplication of these two arrays
# In[23]:
print(Array1*Array2) #Step8: Find the multiplication of these two arrays
# ---
#
# ### Example- n-Dimensional Array Arithmetic
# - Define a 2x2 array with [5,10,15,20]
# In[24]:
import numpy #import numpy
Array1 = numpy.array([[5,10],[15,20]]) #Step1: Define Array1
print(Array1)
# - Define another 2x2 array with [3,6,9,12]
# In[25]:
Array2 = numpy.array([[3,6],[9,12]]) #Step2: Define Array2
print(Array2)
# - Find the sum and difference of these two arrays
# In[26]:
print(Array1+Array2) #Step3: Find the summation
print(Array1-Array2) #Step3: Find the subtraction
# - Find the minimum number in the multiplication of these two arrays
# In[27]:
MultArray = Array1@Array2 #Step4: To perform a typical matrix multiplication (or matrix product)
print(MultArray)
MultArray1 = Array1.dot(Array2) #Step4: Another way To perform a matrix multiplication
print(MultArray1)
print(numpy.min(MultArray)) #Step4: Find the minimum value of the multiplication
# Recall how we have to do the same if using ordinary lists, just for the first line in the block above:
# In[28]:
amatrix = [[5,10],[15,20]]
bmatrix = [[3,6],[9,12]]
cmatrix = [[0 for j in range(len(bmatrix[0]))] for i in range(len(amatrix))] # 2D list to receive input; explicit sizing
# now for the multiplication
for i in range(0,len(amatrix)):
for j in range(0,len(bmatrix[0])):
for k in range(0,len(amatrix[0])):
cmatrix[i][j]=cmatrix[i][j]+amatrix[i][k]*bmatrix[k][j]
for i in range(len(cmatrix)): # print by row
print(cmatrix[i][:])
# There is considerable savings in code crafting using numpy; hence its popularity and utility.
#
# - Find the position of the maximum in the multiplication of these two arrays
# In[29]:
print(numpy.argmax(MultArray)) ##Step5: Find the postition of the maximum value
# - Find the mean of the multiplication of these two arrays
# - Find the mean of the first row of the multiplication of these two arrays
# In[30]:
print( | numpy.mean(MultArray) | numpy.mean |
import json
import numpy as np
import os
# json_data = open('accomplishment.json').read()
# gg = json.loads(json_data)
# print(len(gg['data']))
# print(gg['data'][0])
def transfer(file_name):
json_data = json.loads(open(file_name).read())
word_list = json_data['word']
x_list = [point['pos'][0] for point in json_data['data']]
y_list = [point['pos'][1] for point in json_data['data']]
time_stamp = [point['time'] for point in json_data['data']]
first_time = time_stamp[0]
tag_list = [point['tag'] for point in json_data['data']]
tag_set = set(tag_list)
tar_set = list(tag_set)
tar_set = sorted(tar_set)
print(tar_set)
time_stamp[:] = [ x - first_time for x in time_stamp]
#### calculate cos and sin
sin_list = []
cos_list = []
x_sp_list = []
y_sp_list = []
pen_up_list = []
writing_sin = []
writing_cos = []
angle_stroke = []
for tag in tag_set:
##collect
x_point = []
y_point = []
time_stroke = []
angle_stroke = []
w_sin_stroke = []
w_cos_stroke = []
pen_up_stroke = []
for id_point, point in enumerate(x_list):
if tag_list[id_point] == tag:
x_point.append(point)
y_point.append(y_list[id_point])
time_stroke.append(time_stamp[id_point])
if len(x_point) < 3 :
sin_stroke = []
cos_stroke = []
for _ in range(len(x_point)):
sin_stroke += [0.0]
cos_stroke += [1.0]
else:
for idx in range(1, len(x_point) - 1):
x_prev = x_point[idx - 1]
y_prev = y_point[idx - 1]
x_next = x_point[idx + 1]
y_next = y_point[idx + 1]
x_now = x_point[idx]
y_now = y_point[idx]
p0 = [x_prev, y_prev]
p1 = [x_now, y_now]
p2 = [x_next, y_next]
v0 = np.array(p0) - np.array(p1)
v1 = np.array(p2) - np.array(p1)
angle = np.math.atan2(
np.linalg.det([v0, v1]), np.dot(v0, v1))
angle_stroke.append(angle)
new_angle_stroke = [0] + angle_stroke + [0]
sin_stroke = np.sin(new_angle_stroke).tolist()
cos_stroke = np.cos(new_angle_stroke).tolist()
sin_list += sin_stroke
cos_list += cos_stroke
####calculate spped
if len(x_point) <2:
for _ in range(len(x_point)):
x_sp_list += [0]
y_sp_list += [0]
x_sp = [0]
y_sp = [0]
else:
time_list = np.asarray(time_stroke, dtype=np.float32)
time_list_moved = np.array(time_list)[1:]
time_diff = np.subtract(time_list_moved, time_list[:-1])
for idx, v in enumerate(time_diff):
if v == 0:
time_diff[idx] = 0.001
x_point_moved = np.array(x_point)[1:]
y_point_moved = np.array(y_point)[1:]
x_diff = np.subtract(x_point_moved, x_point[:-1])
y_diff = np.subtract(y_point_moved, y_point[:-1])
x_sp = np.divide(x_diff, time_diff).tolist()
y_sp = np.divide(y_diff, time_diff).tolist()
x_sp = [0] + x_sp
y_sp = [0] + y_sp
x_sp_list += x_sp
y_sp_list += y_sp
#####pen up and down
pen_up_stroke = [1] * (len(x_point) - 1 ) + [0]
pen_up_list += pen_up_stroke
for idx, x_v in enumerate(x_sp):
y_v = y_sp[idx]
slope = np.sqrt(x_v * x_v + y_v * y_v)
if slope != 0:
w_sin_stroke.append(y_v / slope)
w_cos_stroke.append(x_v / slope)
else:
w_sin_stroke.append(0)
w_cos_stroke.append(1)
writing_sin += w_sin_stroke
writing_cos += w_cos_stroke
x_cor = np.asarray(x_list, dtype=np.float32)
y_cor = np.asarray(y_list, dtype=np.float32)
time_stamp = np.asarray(time_stamp, dtype=np.float32)
sin_list = np.asarray(sin_list, dtype=np.float32)
cos_list = np.asarray(cos_list, dtype=np.float32)
x_sp_list = np.asarray(x_sp_list, dtype=np.float32)
y_sp_list = np.asarray(y_sp_list, dtype=np.float32)
pen_up_list = np.asarray(pen_up_list, dtype=np.float32)
writing_cos = np.asarray(writing_cos, dtype=np.float32)
writing_sin = np.asarray(writing_sin, dtype=np.float32)
k = (x_sp_list, y_sp_list, x_cor, y_cor, sin_list, cos_list, writing_sin, writing_cos, pen_up_list, time_stamp)
for each in k:
print(each.shape)
text_line_data = np.stack(
(x_sp_list, y_sp_list, x_cor, y_cor, sin_list, cos_list, writing_sin, writing_cos, pen_up_list, time_stamp), axis=1)
return text_line_data, word_list
# print(len(x_list))
# print(x_list[0])
# print(time_stamp[0])
# print(time_stamp[1])
def transferS(file_name):
json_data = file_name
# word_list = json_data['word']
x_list = [point['pos'][0] for point in json_data['data']]
y_list = [point['pos'][1] for point in json_data['data']]
time_stamp = [point['time'] for point in json_data['data']]
first_time = time_stamp[0]
tag_list = [point['tag'] for point in json_data['data']]
tag_set = set(tag_list)
tar_set = list(tag_set)
tar_set = sorted(tar_set)
print(tar_set)
time_stamp[:] = [ x - first_time for x in time_stamp]
#### calculate cos and sin
sin_list = []
cos_list = []
x_sp_list = []
y_sp_list = []
pen_up_list = []
writing_sin = []
writing_cos = []
angle_stroke = []
for tag in tag_set:
##collect
x_point = []
y_point = []
time_stroke = []
angle_stroke = []
w_sin_stroke = []
w_cos_stroke = []
pen_up_stroke = []
for id_point, point in enumerate(x_list):
if tag_list[id_point] == tag:
x_point.append(point)
y_point.append(y_list[id_point])
time_stroke.append(time_stamp[id_point])
if len(x_point) < 3 :
sin_stroke = []
cos_stroke = []
for _ in range(len(x_point)):
sin_stroke += [0.0]
cos_stroke += [1.0]
else:
for idx in range(1, len(x_point) - 1):
x_prev = x_point[idx - 1]
y_prev = y_point[idx - 1]
x_next = x_point[idx + 1]
y_next = y_point[idx + 1]
x_now = x_point[idx]
y_now = y_point[idx]
p0 = [x_prev, y_prev]
p1 = [x_now, y_now]
p2 = [x_next, y_next]
v0 = np.array(p0) - np.array(p1)
v1 = np.array(p2) - np.array(p1)
angle = np.math.atan2(
np.linalg.det([v0, v1]), np.dot(v0, v1))
angle_stroke.append(angle)
new_angle_stroke = [0] + angle_stroke + [0]
sin_stroke = np.sin(new_angle_stroke).tolist()
cos_stroke = np.cos(new_angle_stroke).tolist()
sin_list += sin_stroke
cos_list += cos_stroke
####calculate spped
if len(x_point) <2:
for _ in range(len(x_point)):
x_sp_list += [0]
y_sp_list += [0]
x_sp = [0]
y_sp = [0]
else:
time_list = np.asarray(time_stroke, dtype=np.float32)
time_list_moved = np.array(time_list)[1:]
time_diff = np.subtract(time_list_moved, time_list[:-1])
for idx, v in enumerate(time_diff):
if v == 0:
time_diff[idx] = 0.001
x_point_moved = np.array(x_point)[1:]
y_point_moved = np.array(y_point)[1:]
x_diff = np.subtract(x_point_moved, x_point[:-1])
y_diff = np.subtract(y_point_moved, y_point[:-1])
x_sp = np.divide(x_diff, time_diff).tolist()
y_sp = np.divide(y_diff, time_diff).tolist()
x_sp = [0] + x_sp
y_sp = [0] + y_sp
x_sp_list += x_sp
y_sp_list += y_sp
#####pen up and down
pen_up_stroke = [1] * (len(x_point) - 1 ) + [0]
pen_up_list += pen_up_stroke
for idx, x_v in enumerate(x_sp):
y_v = y_sp[idx]
slope = | np.sqrt(x_v * x_v + y_v * y_v) | numpy.sqrt |
import krpc
import numpy
import time
import threading
import Global
import PIDLoop
conn = Global.conn
vessel = Global.vessel
canvas = conn.ui.stock_canvas
screen_size = canvas.rect_transform.size
panel = canvas.add_panel()
constant = 0.0
def Toggle(in_r, target):
mode = in_r
#tedious transformations
target_position = target.position(target.orbit.body.reference_frame)
target_position = numpy.asarray(conn.space_center.transform_direction(target_position, target.orbit.body.reference_frame, target.surface_reference_frame))
#custom value for target position to ensure a trajectory that intercepts the target tail on instead of severe angle
target_position[0] += 10000.0-10000.0*numpy.exp(-1.0*vessel.flight(vessel.orbit.body.reference_frame).mean_altitude/30000)
target_position = (target_position[0], target_position[1], target_position[2])
target_position = conn.space_center.transform_direction(target_position, target.surface_reference_frame, target.orbit.body.reference_frame)
target_position = numpy.asarray(target_position)
vessel_position = numpy.asarray(vessel.position(vessel.orbit.body.reference_frame))
target_position = numpy.add(target_position, numpy.multiply(vessel_position, -1.0))
target_position = (target_position[0], target_position[1], target_position[2])
target_position = conn.space_center.transform_direction(target_position, target.orbit.body.reference_frame, vessel.reference_frame)
target_position = numpy.asarray(target_position)
relative_velocity = vessel.velocity(vessel.orbit.body.reference_frame)
relative_velocity = conn.space_center.transform_direction(relative_velocity, vessel.orbit.body.reference_frame, vessel.reference_frame)
relative_velocity = numpy.asarray(relative_velocity)
relative_velocity = numpy.multiply(relative_velocity, -1.0)
Omega = numpy.cross(target_position, relative_velocity)/numpy.vdot(target_position, target_position)
A_Vec = numpy.multiply(numpy.cross(relative_velocity, Omega), 5.0)
travelling = vessel.velocity(vessel.orbit.body.reference_frame)
travelling = numpy.multiply(travelling, 1.0/numpy.linalg.norm(travelling))
travelling = conn.space_center.transform_direction(travelling, vessel.orbit.body.reference_frame, vessel.surface_reference_frame)
travelling = numpy.multiply(travelling, -1.0)
error_ang = 180.0*numpy.arctan(numpy.sqrt(travelling[1]*travelling[1] + travelling[2]*travelling[2])/travelling[0])/numpy.pi
#various modes that can be triggered from Main.py
if(mode == 0):
Target_Vec = numpy.add(numpy.multiply(A_Vec, -50.0), relative_velocity)
elif(mode == 1):
Target_Vec = numpy.add(numpy.multiply(A_Vec, -25.0), relative_velocity)
elif(mode == 2):
Target_Vec = numpy.add( | numpy.multiply(A_Vec, 5.0) | numpy.multiply |
import gym
from gym import spaces
from scipy.integrate import odeint
import matplotlib.pyplot as plt
import numpy as np
import time
import random
m = 1.0
g = 9.8
l = 0.2
class SimplePendulumEnv(gym.Env):
def __init__(self, visualize=False, n_step_solver=2, dt=1e-2, n_step=1, print_state=False):
# Here we define the duration of an environment step,
# the number of solver steps / environment step
self.dt = dt
self.n_step_solver = n_step_solver
# Number of environemnt steps in an episode
self.n_step = n_step
self.print_state = print_state
# Max action
self.max_action = 2.0
# Render of the simulation
self.visualize = visualize
if self.visualize:
plt.ion()
self.fig = plt.figure()
self.ax = self.fig.add_subplot(211)
self.ax.set_xlim([-l, l])
self.ax.set_ylim([-l, l])
self.ax2 = self.fig.add_subplot(212)
self.ax2.set_xlim([0, n_step])
self.ax2.set_ylim([-1, 1])
# We get the cartesian coordinates of the mass
x = l*np.sin(0)
y = -l*np.cos(0)
# We plot the mass
self.mass, = self.ax.plot(x, y, 'bo', markersize=20)
# We plot the pole
self.pole, = self.ax.plot([0, x], [0, y])
self.data = | np.zeros((3, self.n_step)) | numpy.zeros |
"""
Module of functions involving great circles
(thus assuming spheroid model of the earth)
with points given in longitudes and latitudes.
"""
from __future__ import print_function
import math
import numpy
import numpy.random
# Equatorial radius of the earth in kilometers
EARTH_ER = 6378.137
# Authalic radius of the earth in kilometers
EARTH_AR = 6371.007
# Meridional radius of the earth in kilometers
EARTH_MR = 6367.449
# Polar radius of the earth in kilometers
EARTH_PR = 6356.752
DEG2RAD = math.pi / 180.0
RAD2DEG = 180.0 / math.pi
KM2MI = 0.6213712
MI2KM = 1.609344
def lonlatdistance(pt1lon, pt1lat, pt2lon, pt2lat):
"""
Compute the great circle distance between two points
on a sphere using the haversine formula.
Arguments:
pt1lon - longitude(s) of the first point
pt1lat - latitude(s) of the first point
pt2lon - longitude(s) of the second point
pt2lat - latitude(s) of the second point
Returns:
The great circle distance(s) in degrees [0.0, 180.0]
"""
lon1 = numpy.deg2rad(numpy.asarray(pt1lon, dtype=float))
lat1 = numpy.deg2rad(numpy.asarray(pt1lat, dtype=float))
lon2 = numpy.deg2rad(numpy.asarray(pt2lon, dtype=float))
lat2 = numpy.deg2rad(numpy.asarray(pt2lat, dtype=float))
dellat = numpy.power(numpy.sin(0.5 * (lat2 - lat1)), 2.0)
dellon = numpy.cos(lat1) * numpy.cos(lat2) * \
numpy.power(numpy.sin(0.5 * (lon2 - lon1)), 2.0)
dist = 2.0 * numpy.arcsin(numpy.power(dellon + dellat, 0.5))
return numpy.rad2deg(dist)
def lonlatintersect(gc1lon1, gc1lat1, gc1lon2, gc1lat2,
gc2lon1, gc2lat1, gc2lon2, gc2lat2):
"""
Compute the intersections of two great circles. Uses the line of
intersection between the two planes of the great circles.
Arguments:
gc1lon1 - longitude(s) of the first point on the first great circle
gc1lat1 - latitude(s) of the first point on the first great circle
gc1lon2 - longitude(s) of the second point on the first great circle
gc1lat2 - latitude(s) of the second point on the first great circle
gc2lon1 - longitude(s) of the first point on the second great circle
gc2lat1 - latitude(s) of the first point on the second great circle
gc2lon2 - longitude(s) of the second point on the second great circle
gc2lat2 - latitude(s) of the second point on the second great circle
Returns:
( (pt1lon, pt1lat), (pt2lon, pt2lat) ) - the longitudes and latitudes
of the two intersections of the two great circles. NaN will
be returned for both longitudes and latitudes if a great
circle is not well-defined, or the two great-circles coincide.
"""
# Minimum acceptable norm of a cross product
# arcsin(1.0E-7) = 0.02" or 0.64 m on the Earth
MIN_NORM = 1.0E-7
# Convert longitudes and latitudes to points on a unit sphere
# The "+ 0.0 * ptlonr" is to broadcast gcz if needed
ptlonr = numpy.deg2rad(numpy.asarray(gc1lon1, dtype=float))
ptlatr = numpy.deg2rad(numpy.asarray(gc1lat1, dtype=float))
gcz = numpy.sin(ptlatr) + 0.0 * ptlonr
coslat = numpy.cos(ptlatr)
gcy = coslat * numpy.sin(ptlonr)
gcx = coslat * numpy.cos(ptlonr)
gc1xyz1 = numpy.array([gcx, gcy, gcz])
#
ptlonr = numpy.deg2rad(numpy.asarray(gc1lon2, dtype=float))
ptlatr = numpy.deg2rad(numpy.asarray(gc1lat2, dtype=float))
gcz = | numpy.sin(ptlatr) | numpy.sin |
import numpy as np
import pydart2 as pydart
import math
from fltk import *
from PyCommon.modules.GUI import hpSimpleViewer as hsv
from PyCommon.modules.Renderer import ysRenderer as yr
from Examples.speed_skating.make_skate_keyframe import make_keyframe
render_vector = []
render_vector_origin = []
push_force = []
push_force_origin = []
blade_force = []
blade_force_origin = []
rd_footCenter = []
ik_on = True
# ik_on = False
class MyWorld(pydart.World):
def __init__(self, ):
super(MyWorld, self).__init__(1.0 / 1200.0, '../data/skel/cart_pole_blade_3dof_with_ground.skel')
# pydart.World.__init__(self, 1.0 / 1000.0, '../data/skel/cart_pole_blade_3dof_with_ground.skel')
# pydart.World.__init__(self, 1.0 / 1000.0, '../data/skel/cart_pole_blade.skel')
# pydart.World.__init__(self, 1.0 / 2000.0, '../data/skel/cart_pole.skel')
self.force = None
self.force_r = None
self.force_l = None
self.force_hip_r = None
self.duration = 0
self.skeletons[0].body('ground').set_friction_coeff(0.02)
self.ground_height = self.skeletons[0].body(0).to_world((0., 0.025, 0.))[1]
skel = self.skeletons[2]
root_state = make_keyframe(skel)
state = root_state
self.state_list = []
for i in range(10):
self.state_list.append(state)
state = state.get_next()
state_num = len(self.state_list)
self.state_num = state_num
# print("state_num: ", state_num)
self.curr_state = self.state_list[0]
self.elapsedTime = 0.0
self.curr_state_index = 0
# print("backup angle: ", backup_q)
# print("cur angle: ", self.curr_state.angles)
if ik_on:
revise_pose(self.skeletons[3], self.state_list[0])
print('IK ON')
self.skeletons[3].set_positions(self.curr_state.angles)
self.rd_contact_forces = []
self.rd_contact_positions = []
# print("dof: ", skel.ndofs)
# nonholonomic constraint initial setting
_th = 5. * math.pi / 180.
self.nh0 = pydart.constraints.NonHolonomicContactConstraint(skel.body('h_blade_right'), np.array((0.0216+0.104, -0.0216-0.027, 0.)))
self.nh1 = pydart.constraints.NonHolonomicContactConstraint(skel.body('h_blade_right'), np.array((0.0216-0.104, -0.0216-0.027, 0.)))
self.nh2 = pydart.constraints.NonHolonomicContactConstraint(skel.body('h_blade_left'), np.array((0.0216+0.104, -0.0216-0.027, 0.)))
self.nh3 = pydart.constraints.NonHolonomicContactConstraint(skel.body('h_blade_left'), np.array((0.0216-0.104, -0.0216-0.027, 0.)))
self.nh1.set_violation_angle_ignore_threshold(_th)
self.nh1.set_length_for_violation_ignore(0.208)
self.nh3.set_violation_angle_ignore_threshold(_th)
self.nh3.set_length_for_violation_ignore(0.208)
self.nh0.add_to_world()
self.nh1.add_to_world()
self.nh2.add_to_world()
self.nh3.add_to_world()
self.step_count = 0
def step(self):
# print("self.curr_state: ", self.curr_state.name)
# if self.curr_state.name == "state1":
# self.force = np.array([50.0, 0.0, 0.0])
# # elif self.curr_state.name == "state2":
# # self.force = np.array([0.0, 0.0, -10.0])
# else:
# self.force = None
if self.force is not None:
self.skeletons[2].body('h_pelvis').add_ext_force(self.force)
self.skeletons[3].set_positions(self.curr_state.angles)
if self.curr_state.dt < self.time() - self.elapsedTime:
# print("change the state!!!", self.curr_state_index)
self.curr_state_index = self.curr_state_index + 1
self.curr_state_index = self.curr_state_index % self.state_num
self.elapsedTime = self.time()
self.curr_state = self.state_list[self.curr_state_index]
# print("state_", self.curr_state_index)
# print(self.curr_state.angles)
# ground_height = -0.98 + 0.0251
# ground_height = 0.
ground_height = self.skeletons[0].body("ground").to_world()[1] #0.0251
# print("ground h: ", ground_height)
# ground_height = -0.98 + 0.05
# ground_height = -0.98
# if ik_on:
# ik_res = copy.deepcopy(self.curr_state.angles)
# if self.curr_state.name != "state02":
# # print("ik solve!!-------------------")
# self.ik.update_target(ground_height)
# ik_res[6:] = self.ik.solve()
# # self.curr_state.angles = ik_res
# self.skeletons[3].set_positions(ik_res)
# HP QP solve
lf_tangent_vec = np.array([1.0, 0.0, .0])
rf_tangent_vec = np.array([1.0, 0.0, .0])
# character_dir = copy.deepcopy(skel.com_velocity())
character_dir = skel.com_velocity()
# print(character_dir, skel.com_velocity())
character_dir[1] = 0
if np.linalg.norm(character_dir) != 0:
character_dir = character_dir / np.linalg.norm(character_dir)
centripetal_force_dir = | np.cross([0.0, 1.0, 0.0], character_dir) | numpy.cross |
# -*- coding: utf-8 -*-
"""
Created on Mon May 4 21:36:46 2020
@author: <NAME>
"""
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.layers import AveragePooling2D
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Input
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.preprocessing.image import load_img
from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import os
image_path="dataset"
#setting hyperparameters like learning rate, no of epochs and batch_size
INIT_LR=1e-4
EPOCHS=20
BS=32
#grabbing all imagepath in dataset
image_dataset=list(paths.list_images(image_path))
data=[]
labels=[]
for imagepath in image_dataset:
#extracting the class
label= imagepath.split(os.path.sep)[-2]
#loading image in 224x224 and preprocess it as model requires 224x224 input
image= load_img(imagepath,target_size=(224,224))
image=img_to_array(image)
image = preprocess_input(image)
#update labels and data respectively
data.append(image)
labels.append(label)
#convert the image to numpy array
data= | np.array(data,dtype="float32") | numpy.array |
import calculate_species_relative_abundance
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import fsolve
from scipy.special import erf
mean_abundance_dict = calculate_species_relative_abundance.load_species_mean_abun_dict()
af_abun_all = []
na_abun_all = []
for species_abundance in mean_abundance_dict.keys():
af_abun_all.append(mean_abundance_dict[species_abundance]['Africa'])
na_abun_all.append(mean_abundance_dict[species_abundance]['North America'])
af_abun_all = np.array(af_abun_all)
na_abun_all = np.array(na_abun_all)
af_log_abun = [np.log10(mean) for mean in af_abun_all]
na_log_abun = [np.log10(mean) for mean in na_abun_all]
af_log_abun = np.array(af_log_abun)
na_log_abun = np.array(na_log_abun)
standardized_africa_abun = (af_log_abun - af_log_abun.mean())/af_log_abun.std()
standardized_na_abun = (na_log_abun - na_log_abun.mean())/na_log_abun.std()
fig, axs = plt.subplots(1, 2, figsize=(15,7))
n_af, bins_af, patches = axs[1].hist(np.log10(af_abun_all), bins = 40)
n_na, bins_na, patches = axs[0].hist(np.log10(na_abun_all), bins = 40)
mode_na = (bins_na[n_na.argmax()] + bins_na[n_na.argmax()+1])/2
mode_af = (bins_af[n_af.argmax()] + bins_af[n_af.argmax()+1])/2
n = float(na_abun_all.shape[0])
na_m1 = (1/n)*na_log_abun.sum()
na_m2 = (1/n)*((na_log_abun)**2).sum()
af_m1 = (1/n)*af_log_abun.sum()
af_m2 = (1/n)*((af_log_abun)**2).sum()
c_na = np.exp(mode_na)
c_af = np.exp(mode_af)
def get_estimates(init, c):
sigma = init[0]
mu = init[1]
a = -m1 + mu + ((np.sqrt(2/np.pi)*sigma*np.exp(-1*(( | np.log(c) | numpy.log |
# -*- coding: utf-8 -*-
from __future__ import print_function
from datetime import datetime, time
from numpy import nan
from numpy.random import randn
import numpy as np
from pandas import (DataFrame, Series, Index,
Timestamp, DatetimeIndex,
to_datetime, date_range)
import pandas as pd
import pandas.tseries.offsets as offsets
from pandas.util.testing import (assert_almost_equal,
assert_series_equal,
assert_frame_equal,
assertRaisesRegexp)
import pandas.util.testing as tm
from pandas.compat import product
from pandas.tests.frame.common import TestData
class TestDataFrameTimeSeriesMethods(tm.TestCase, TestData):
def test_diff(self):
the_diff = self.tsframe.diff(1)
assert_series_equal(the_diff['A'],
self.tsframe['A'] - self.tsframe['A'].shift(1))
# int dtype
a = 10000000000000000
b = a + 1
s = Series([a, b])
rs = DataFrame({'s': s}).diff()
self.assertEqual(rs.s[1], 1)
# mixed numeric
tf = self.tsframe.astype('float32')
the_diff = tf.diff(1)
assert_series_equal(the_diff['A'],
tf['A'] - tf['A'].shift(1))
# issue 10907
df = pd.DataFrame({'y': pd.Series([2]), 'z': pd.Series([3])})
df.insert(0, 'x', 1)
result = df.diff(axis=1)
expected = pd.DataFrame({'x': np.nan, 'y': pd.Series(
1), 'z': pd.Series(1)}).astype('float64')
assert_frame_equal(result, expected)
def test_diff_timedelta(self):
# GH 4533
df = DataFrame(dict(time=[Timestamp('20130101 9:01'),
Timestamp('20130101 9:02')],
value=[1.0, 2.0]))
res = df.diff()
exp = DataFrame([[pd.NaT, np.nan],
[pd.Timedelta('00:01:00'), 1]],
columns=['time', 'value'])
assert_frame_equal(res, exp)
def test_diff_mixed_dtype(self):
df = DataFrame(np.random.randn(5, 3))
df['A'] = np.array([1, 2, 3, 4, 5], dtype=object)
result = df.diff()
self.assertEqual(result[0].dtype, np.float64)
def test_diff_neg_n(self):
rs = self.tsframe.diff(-1)
xp = self.tsframe - self.tsframe.shift(-1)
assert_frame_equal(rs, xp)
def test_diff_float_n(self):
rs = self.tsframe.diff(1.)
xp = self.tsframe.diff(1)
assert_frame_equal(rs, xp)
def test_diff_axis(self):
# GH 9727
df = DataFrame([[1., 2.], [3., 4.]])
assert_frame_equal(df.diff(axis=1), DataFrame(
[[np.nan, 1.], [np.nan, 1.]]))
assert_frame_equal(df.diff(axis=0), DataFrame(
[[np.nan, np.nan], [2., 2.]]))
def test_pct_change(self):
rs = self.tsframe.pct_change(fill_method=None)
assert_frame_equal(rs, self.tsframe / self.tsframe.shift(1) - 1)
rs = self.tsframe.pct_change(2)
filled = self.tsframe.fillna(method='pad')
assert_frame_equal(rs, filled / filled.shift(2) - 1)
rs = self.tsframe.pct_change(fill_method='bfill', limit=1)
filled = self.tsframe.fillna(method='bfill', limit=1)
assert_frame_equal(rs, filled / filled.shift(1) - 1)
rs = self.tsframe.pct_change(freq='5D')
filled = self.tsframe.fillna(method='pad')
assert_frame_equal(rs, filled / filled.shift(freq='5D') - 1)
def test_pct_change_shift_over_nas(self):
s = Series([1., 1.5, np.nan, 2.5, 3.])
df = DataFrame({'a': s, 'b': s})
chg = df.pct_change()
expected = Series([np.nan, 0.5, np.nan, 2.5 / 1.5 - 1, .2])
edf = DataFrame({'a': expected, 'b': expected})
assert_frame_equal(chg, edf)
def test_frame_ctor_datetime64_column(self):
rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50', freq='10s')
dates = np.asarray(rng)
df = DataFrame({'A': np.random.randn(len(rng)), 'B': dates})
self.assertTrue(np.issubdtype(df['B'].dtype, np.dtype('M8[ns]')))
def test_frame_add_datetime64_column(self):
rng = date_range('1/1/2000 00:00:00', '1/1/2000 1:59:50', freq='10s')
df = DataFrame(index=np.arange(len(rng)))
df['A'] = rng
self.assertTrue(np.issubdtype(df['A'].dtype, np.dtype('M8[ns]')))
def test_frame_datetime64_pre1900_repr(self):
df = DataFrame({'year': date_range('1/1/1700', periods=50,
freq='A-DEC')})
# it works!
repr(df)
def test_frame_add_datetime64_col_other_units(self):
n = 100
units = ['h', 'm', 's', 'ms', 'D', 'M', 'Y']
ns_dtype = np.dtype('M8[ns]')
for unit in units:
dtype = np.dtype('M8[%s]' % unit)
vals = np.arange(n, dtype=np.int64).view(dtype)
df = DataFrame({'ints': np.arange(n)}, index= | np.arange(n) | numpy.arange |
"""Perform normalization on inputs or rewards.
"""
import numpy as np
import torch
from gym.spaces import Box
def normalize_angle(x):
"""Wraps input angle to [-pi, pi].
"""
return ((x + np.pi) % (2 * np.pi)) - np.pi
class RunningMeanStd():
"""Calulates the running mean and std of a data stream.
Attributes:
mean (np.array): mean of data stream.
var (np.array): variance of data stream.
count (float): total count of data steam.
"""
def __init__(self, epsilon=1e-4, shape=()):
"""Initializes containers for data mean and variance.
Args:
epsilon (float): helps with arithmetic issues.
shape (tuple): the shape of the data stream's output.
"""
self.mean = np.zeros(shape, np.float64)
self.var = np.ones(shape, np.float64)
self.count = epsilon
def update(self, arr):
"""Update current stats with a new stream of data.
Args:
arr (np.array): 1D array of data, (batch_size, *shape).
"""
batch_mean = np.mean(arr, axis=0)
batch_var = np.var(arr, axis=0)
batch_count = arr.shape[0]
self.update_from_moments(batch_mean, batch_var, batch_count)
def update_from_moments(self, batch_mean, batch_var, batch_count):
"""Util function for `update` method.
"""
delta = batch_mean - self.mean
tot_count = self.count + batch_count
new_mean = self.mean + delta * batch_count / tot_count
m_a = self.var * self.count
m_b = batch_var * batch_count
m_2 = m_a + m_b + np.square(delta) * self.count * batch_count / (self.count + batch_count)
new_var = m_2 / (self.count + batch_count)
new_count = batch_count + self.count
self.mean = new_mean
self.var = new_var
self.count = new_count
class BaseNormalizer(object):
"""Template/default normalizer.
Attributes:
read_only (bool): if to freeze the current stats being tracked.
"""
def __init__(self, read_only=False):
self.read_only = read_only
def set_read_only(self):
self.read_only = True
def unset_read_only(self):
self.read_only = False
def __call__(self, x, *args, **kwargs):
"""Invokes normalization on the given input.
"""
return x
def state_dict(self):
"""Returns snapshot of current stats.
"""
return {}
def load_state_dict(self, _):
"""Restores the stats from a snapshot.
"""
pass
class MeanStdNormalizer(BaseNormalizer):
"""Normalize by the running average.
"""
def __init__(self, shape=(), read_only=False, clip=10.0, epsilon=1e-8):
"""Initializes the data stream tracker.
Args:
shape (tuple): shape of data being tracked.
read_only (bool): if to freeze the tracker.
clip (float): bounds on the data.
epsilon (float): offset to provide divide-by-zero.
"""
super().__init__(read_only)
self.read_only = read_only
self.rms = RunningMeanStd(shape=shape)
self.clip = clip
self.epsilon = epsilon
def __call__(self, x):
"""Update tracker given data, optionally normalize the data.
"""
x = np.asarray(x)
if not self.read_only:
self.rms.update(x)
return np.clip(
(x - self.rms.mean) / np.sqrt(self.rms.var + self.epsilon),
-self.clip, self.clip)
def state_dict(self):
return {'mean': self.rms.mean, 'var': self.rms.var}
def load_state_dict(self, saved):
self.rms.mean = saved['mean']
self.rms.var = saved['var']
class RewardStdNormalizer(MeanStdNormalizer):
"""Reward normalization by running average of returns.
Papers:
* arxiv.org/pdf/1808.04355.pdf
* arxiv.org/pdf/1810.12894.pdf
Also see:
* github.com/openai/baselines/issues/538
"""
def __init__(self, gamma=0.99, read_only=False, clip=10.0, epsilon=1e-8):
"""Initializes the data stream tracker.
Args:
gamma (float): discount factor for rewards.
read_only (bool): if to freeze the tracker.
clip (float): bounds on the data.
epsilon (float): offset to provide divide-by-zero.
"""
# Reward has default shape (1,) or just ().
super().__init__((), read_only, clip, epsilon)
self.gamma = gamma
self.ret = None
def __call__(self, x, dones):
"""Update tracker given reward, optionally normalize the reward (only scaling).
"""
x = np.asarray(x)
if not self.read_only:
# Track running average of forward discounted returns.
if self.ret is None:
self.ret = np.zeros(x.shape[0])
self.ret = self.ret * self.gamma + x
self.rms.update(self.ret)
# Prevent information leak from previous episodes.
self.ret[dones.astype(np.long)] = 0
return np.clip(x / | np.sqrt(self.rms.var + self.epsilon) | numpy.sqrt |
# coding: utf8
""" Unit tests:
- :class:`TestFiniteDppSamplers`
"""
import unittest
from itertools import chain # to flatten list of samples
import numpy as np
import numpy.random as rndm
import scipy.linalg as la
from scipy.stats import chisquare
import sys
sys.path.append('..')
from dppy.finite_dpps import FiniteDPP
from dppy.utils import det_ST
class TestAdequationOfFiniteDppSamplers(unittest.TestCase):
""" For various settings, test that the
"""
rank, N = 6, 10
nb_exact_samples = 1000
nb_iter_mcmc = nb_exact_samples
e_vals_eq_01 = np.ones(rank)
e_vals_in_01 = | np.random.rand(rank) | numpy.random.rand |
from __future__ import print_function
import unittest
import numpy as np
import scipy.sparse as sp
from matrixutils import (
sdiag, sub2ind, ndgrid, mkvc,
inv2X2BlockDiagonal, inv3X3BlockDiagonal,
indexCube, ind2sub, asArray_N_x_Dim, Zero, Identity,
meshTensor
)
TOL = 1e-8
class TestSequenceFunctions(unittest.TestCase):
def setUp(self):
self.a = np.array([1, 2, 3])
self.b = np.array([1, 2])
self.c = np.array([1, 2, 3, 4])
def test_mkvc1(self):
x = mkvc(self.a)
self.assertTrue(x.shape, (3, ))
def test_mkvc2(self):
x = mkvc(self.a, 2)
self.assertTrue(x.shape, (3, 1))
def test_mkvc3(self):
x = mkvc(self.a, 3)
self.assertTrue(x.shape, (3, 1, 1))
def test_ndgrid_2D(self):
XY = ndgrid([self.a, self.b])
X1_test = np.array([1, 2, 3, 1, 2, 3])
X2_test = np.array([1, 1, 1, 2, 2, 2])
self.assertTrue(np.all(XY[:, 0] == X1_test))
self.assertTrue(np.all(XY[:, 1] == X2_test))
def test_ndgrid_3D(self):
XYZ = ndgrid([self.a, self.b, self.c])
X1_test = np.array([
1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3,
1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3
])
X2_test = np.array([
1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2,
1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2
])
X3_test = np.array([
1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4
])
self.assertTrue(np.all(XYZ[:, 0] == X1_test))
self.assertTrue(np.all(XYZ[:, 1] == X2_test))
self.assertTrue(np.all(XYZ[:, 2] == X3_test))
def test_sub2ind(self):
x = np.ones((5, 2))
assert np.allclose(sub2ind(x.shape, [0, 0]), [0])
assert np.allclose(sub2ind(x.shape, [4, 0]), [4])
assert np.allclose(sub2ind(x.shape, [0, 1]), [5])
assert np.allclose(sub2ind(x.shape, [4, 1]), [9])
assert np.allclose(sub2ind(x.shape, [[4, 1]]), [9])
assert np.allclose(
sub2ind(x.shape, [[0, 0], [4, 0], [0, 1], [4, 1]]), [0, 4, 5, 9]
)
def test_ind2sub(self):
x = np.ones((5, 2))
assert np.allclose(ind2sub(x.shape, [0, 4, 5, 9])[0], [0, 4, 0, 4])
assert np.allclose(ind2sub(x.shape, [0, 4, 5, 9])[1], [0, 0, 1, 1])
def test_indexCube_2D(self):
nN = np.array([3, 3])
assert np.allclose(indexCube('A', nN), np.array([0, 1, 3, 4]))
assert np.allclose(indexCube('B', nN), np.array([3, 4, 6, 7]))
assert np.allclose(indexCube('C', nN), np.array([4, 5, 7, 8]))
assert np.allclose(indexCube('D', nN), np.array([1, 2, 4, 5]))
def test_indexCube_3D(self):
nN = np.array([3, 3, 3])
assert np.allclose(
indexCube('A', nN), np.array([0, 1, 3, 4, 9, 10, 12, 13])
)
assert np.allclose(
indexCube('B', nN), np.array([3, 4, 6, 7, 12, 13, 15, 16])
)
assert np.allclose(
indexCube('C', nN), np.array([4, 5, 7, 8, 13, 14, 16, 17])
)
assert np.allclose(
indexCube('D', nN), np.array([1, 2, 4, 5, 10, 11, 13, 14])
)
assert np.allclose(
indexCube('E', nN), | np.array([9, 10, 12, 13, 18, 19, 21, 22]) | numpy.array |
import os
import shutil
import pytest
import numpy as np
import tensorflow as tf
import torch
from torch_mimicry.metrics import compute_fid
from torch_mimicry.metrics.inception_model import inception_utils
from torch_mimicry.nets.gan import gan
class ExampleGen(gan.BaseGenerator):
def __init__(self,
bottom_width=4,
nz=4,
ngf=256,
loss_type='gan',
*args,
**kwargs):
super().__init__(nz=nz,
ngf=ngf,
bottom_width=bottom_width,
loss_type=loss_type,
*args,
**kwargs)
def forward(self, x):
output = torch.ones(x.shape[0], 3, 32, 32)
return output
class CustomDataset(torch.utils.data.Dataset):
def __init__(self, nchw=True):
super().__init__()
if nchw:
self.data = torch.ones(30, 3, 32, 32)
else:
self.data = torch.ones(30, 32, 32, 3)
def __len__(self):
return self.data.shape[0]
def __getitem__(self, idx):
return self.data[idx]
class TestComputeFID:
def setup(self):
self.netG = ExampleGen()
self.num_real_samples = 10
self.num_fake_samples = 10
self.batch_size = 10
self.device = torch.device("cpu")
# Create inception graph once.
self.inception_path = './metrics/inception_model'
if not os.path.exists(self.inception_path):
os.makedirs(self.inception_path)
inception_utils.create_inception_graph(self.inception_path)
# Directory
self.log_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"test_log")
if not os.path.exists(self.log_dir):
os.makedirs(self.log_dir)
def _create_cached_file(self):
m, s = np.ones((128, )), np.ones((128, 128))
cached_file = os.path.join(self.log_dir, 'cached.npz')
| np.savez(cached_file, mu=m, sigma=s) | numpy.savez |
# -*- coding: utf-8 -*-
from PIL import Image
import math
import numpy as np
import os
import random
import sys
import glob
import h5py
import tensorflow as tf
from .dataset_tools import *
def read_text(filename):
v = []
for l in open(filename, 'r'):
v.append(l.strip())
# v.append([x for x in l.strip().split(' ')])
return np.array(v)
class SE3PairwiseDataset(object):
# class for ScanNet or SfM dataset
def __init__(self, batch_size, offset_val=2, random_offset=False, out_width=320, out_height=240, crop_center=False, max_degree=0, max_scale=np.sqrt(2), warp_aug_mode='none', num_threads=8):
self.batch_size = batch_size
self.offset_val = offset_val
self.random_offset = random_offset
self.depth_factor = 0.001
self.far_depth_val = 1000
self.src_width = 640
self.src_height = 480
self.dst_width = out_width
self.dst_height = out_height
self.num_threads = num_threads
self.max_rad = np.pi / 180 * max_degree
self.max_scale_log = np.log(max_scale)
self.warp_aug_mode = warp_aug_mode
self.scale_table_path = '../../params/scale/scl-{:.2f}/rnd_table.npy'.format(max_scale)
self.ori_table_path = '../../params/ori/deg-{}/rnd_table.npy'.format(max_degree)
self.depth_thresh = 1.0
self.crop_center = crop_center
def set_files(self, root_dir, render_paths, max_img_num=-1):
if isinstance(render_paths, str):
render_paths = [render_paths]
num_seq = len(render_paths)
print('Number of sequences:{0}'.format(len(render_paths)))
# load from render_paths
photo_intrinsics = [None] * num_seq
depth_intrinsics = [None] * num_seq
cTws = [None] * num_seq
num_photos_per_seq = [None] * num_seq
photo_dirs = [None] * num_seq
depth_dirs = [None] * num_seq
for i, render_path in enumerate(render_paths):
calib = np.load(os.path.join(root_dir, render_path, 'calib/calib.npz'))
photo_intrinsics[i] = calib['photo_intrinsic']
depth_intrinsics[i] = calib['depth_intrinsic']
cTw = np.load(os.path.join(root_dir, render_path, 'pose/cTw.npy'))
num_photos = (len(cTw) // self.batch_size) * self.batch_size # guarantee to be divisible by batch size
if max_img_num > 0:
num_photos = min(num_photos, max_img_num)
print('#{} {} use {} / {} images'.format(i, render_path, num_photos, len(cTw)))
cTws[i] = cTw[:num_photos]
num_photos_per_seq[i] = num_photos
photo_dirs[i] = os.path.join(root_dir, render_path, 'photo')
depth_dirs[i] = os.path.join(root_dir, render_path, 'depth')
self.cTws_data = np.concatenate(cTws, axis=0)
self.cTws = tf.convert_to_tensor(self.cTws_data, dtype=tf.float32)
self.photo_intrinsics_data = np.array(photo_intrinsics)
self.photo_intrinsics = tf.convert_to_tensor(self.photo_intrinsics_data, dtype=tf.float32)
self.depth_intrinsics_data = np.array(depth_intrinsics)
self.depth_intrinsics = tf.convert_to_tensor(self.depth_intrinsics_data, dtype=tf.float32)
self.num_photos_per_seq_data = np.array(num_photos_per_seq, dtype=np.int32)
self.num_photos_per_seq = tf.convert_to_tensor(self.num_photos_per_seq_data, dtype=tf.int32)
self.seq_offsets_data = np.concatenate([np.zeros([1], dtype=np.int32), np.cumsum(self.num_photos_per_seq_data)])
self.seq_offsets = tf.convert_to_tensor(self.seq_offsets_data, tf.int32)
self.intrinsics_3x3_data = self.photo_intrinsics_data
photo_path_list = []
depth_path_list = []
seq_id_list = []
for i, (pdir, ddir) in enumerate(zip(photo_dirs, depth_dirs)):
numbers = sorted([int(os.path.splitext(x.name)[0]) for x in os.scandir(pdir)])
num_photos = self.num_photos_per_seq_data[i]
numbers = numbers[:num_photos]
photos = [os.path.join(pdir, '{}.jpg'.format(img_n)) for img_n in numbers]
depths = [os.path.join(ddir, '{}.png'.format(img_n)) for img_n in numbers]
seq_ids = [i] * len(numbers)
assert len(photos) == len(depths)
assert len(photos) == num_photos_per_seq[i]
photo_path_list += photos
depth_path_list += depths
seq_id_list += seq_ids
# set other members
self.photo_path_list_data = photo_path_list
self.depth_path_list_data = depth_path_list
self.seq_id_list_data = np.array(seq_id_list, dtype=np.int32)
self.photo_path_list = tf.convert_to_tensor(photo_path_list)
self.depth_path_list = tf.convert_to_tensor(depth_path_list)
self.seq_id_list = tf.convert_to_tensor(self.seq_id_list_data, dtype=tf.int32)
self.num_seq = num_seq
self.total_num_photos = len(photo_path_list)
if self.warp_aug_mode == 'table':
ori_table_path = os.path.join(root_dir, self.ori_table_path)
scale_table_path = os.path.join(root_dir, self.scale_table_path)
self.ori_random_table_data = self._load_random_table(ori_table_path, self.total_num_photos)
self.scale_random_table_data = self._load_random_table(scale_table_path, self.total_num_photos)
self.ori_random_table = tf.convert_to_tensor(self.ori_random_table_data, dtype=tf.float32)
self.scale_random_table = tf.convert_to_tensor(self.scale_random_table_data, dtype=tf.float32)
print('[ScanNet] #sep={}, #total={}'.format(self.num_seq, self.total_num_photos))
def get_dataset(self, shuffle=True, num_epoch=None, seed=None):
dataset = tf.data.Dataset.range(self.total_num_photos)
if shuffle:
dataset = dataset.shuffle(self.total_num_photos, seed=seed)
dataset = dataset.repeat(count=num_epoch)
dataset = dataset.map(lambda x: self.mapfn_read_and_decode(x), num_parallel_calls=self.num_threads)
dataset = dataset.map(self.mapfn_augment, num_parallel_calls=self.num_threads)
dataset = dataset.batch(self.batch_size)
return dataset
def mapfn_read_and_decode(self, tgt_idx):
tgt_idx = tf.cast(tgt_idx, tf.int32) # tf.int64->tf.int32
seq_idx = self.seq_id_list[tgt_idx]
file_idx = tgt_idx - self.seq_offsets[seq_idx]
num_photos = self.num_photos_per_seq[seq_idx]
if self.random_offset:
offset = tf.random_uniform((), -self.offset_val, self.offset_val, dtype=tf.int32)
else:
offset = self.offset_val # fixed value
offset = tf.clip_by_value(file_idx+offset, 0, num_photos-1) - file_idx
ref_idx = tgt_idx + offset
photo1 = self._load_photo(tgt_idx)
photo2 = self._load_photo(ref_idx)
depth1, valid_mask1 = self._load_depth(tgt_idx)
depth2, valid_mask2 = self._load_depth(ref_idx)
# pose
c1Tw = self.cTws[tgt_idx]
c2Tw = self.cTws[ref_idx]
c2Tc1, c1Tc2 = self._get_delta_pose(c1Tw, c2Tw)
intrinsics_3x3 = self.photo_intrinsics[seq_idx,:3,:3]
intrinsics_3x3.set_shape([3,3])
# warp params
print('WARP_AUG_MODE={} max_rad={}, max_scale_log={}'.format(self.warp_aug_mode, self.max_rad, self.max_scale_log))
if self.warp_aug_mode == 'none':
scales = tf.zeros([2], tf.float32)
oris = tf.zeros([2], tf.float32)
elif self.warp_aug_mode == 'fix':
scales = tf.constant([self.max_scale_log, self.max_scale_log], tf.float32)
oris = tf.constant([self.max_rad, self.max_rad], tf.float32)
elif self.warp_aug_mode == 'random':
scales = tf.random_uniform([2], minval=-self.max_scale_log, maxval=self.max_scale_log, dtype=tf.float32)
oris = tf.random_uniform([2], minval=-self.max_rad, maxval=self.max_rad, dtype=tf.float32)
elif self.warp_aug_mode == 'table':
scales = self.scale_random_table[tgt_idx]
oris = self.ori_random_table[tgt_idx]
else:
raise ValueError('Unknown warp_aug_mode: {}'.format(self.warp_aug_mode))
theta_params = tf.concat([scales, oris], axis=0)
use_aug = tf.constant(False) if self.warp_aug_mode == 'none' else tf.constant(True)
# add in-plane rotation
intheta_c2Rc1 = tf.py_func(get_inplane_rotation, [c2Tc1[:3,:3]], [tf.float32])
intheta_c1Rc2 = tf.py_func(get_inplane_rotation, [c1Tc2[:3,:3]], [tf.float32])
theta_params = tf.concat([theta_params, intheta_c2Rc1, intheta_c1Rc2], axis=0)
return photo1, photo2, depth1, depth2, valid_mask1, valid_mask2, c2Tc1, c1Tc2, c1Tw, c2Tw, intrinsics_3x3, intrinsics_3x3, theta_params, use_aug
def mapfn_augment(self, photo1, photo2, depth1, depth2, valid_mask1, valid_mask2, c2Tc1, c1Tc2, c1Tw, c2Tw, K1, K2, theta_params, use_aug):
dv1 = tf.concat([depth1, valid_mask1], axis=-1)
dv2 = tf.concat([depth2, valid_mask2], axis=-1)
# Crop center
if self.crop_center:
# image size = [480,640] --> [480,640]
assert self.src_width > self.src_height
x_offset = (self.src_width-self.src_height) // 2
new_height = new_width = self.src_height
photo1 = tf.slice(photo1, [0,x_offset,0], [-1, new_width, -1])
photo2 = tf.slice(photo2, [0,x_offset,0], [-1, new_width, -1])
dv1 = tf.slice(dv1, [0,x_offset,0], [-1, new_width, -1])
dv2 = tf.slice(dv2, [0,x_offset,0], [-1, new_width, -1])
# modify intrinsic matrix
K1 = fix_intrinsic_center(K1, tf.to_float(new_width)/2, tf.to_float(new_height)/2)
K2 = fix_intrinsic_center(K2, tf.to_float(new_width)/2, tf.to_float(new_height)/2)
dx = float(self.dst_width) / new_width
dy = float(self.dst_height) / new_height
else:
dx = float(self.dst_width) / self.src_width
dy = float(self.dst_height) / self.src_height
# Resizing
scale_T = self._make_scale_theta(dx, dy)
K1 = tf.matmul(scale_T, K1)
K2 = tf.matmul(scale_T, K2)
photo1 = tf.image.resize_images(photo1, (self.dst_height, self.dst_width))
photo2 = tf.image.resize_images(photo2, (self.dst_height, self.dst_width))
# do not use linear interpolation on valid_masks1
dv1 = tf.image.resize_images(dv1, (self.dst_height, self.dst_width),
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
dv2 = tf.image.resize_images(dv2, (self.dst_height, self.dst_width),
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
depth1 = tf.slice(dv1, [0,0,0],[-1,-1,1])
valid_mask1 = tf.slice(dv1, [0,0,1],[-1,-1,1])
depth2 = tf.slice(dv2, [0,0,0],[-1,-1,1])
valid_mask2 = tf.slice(dv2, [0,0,1],[-1,-1,1])
return photo1, photo2, depth1, depth2, valid_mask1, valid_mask2, c2Tc1, c1Tc2, c1Tw, c2Tw, K1, K2, theta_params, use_aug
def _load_photo(self, idx):
photo = tf.read_file(self.photo_path_list[idx])
photo = tf.image.decode_jpeg(photo, 1) # force to load as grayscale
# photo = tf.image.rgb_to_grayscale(photo)
photo = tf.cast(photo, tf.float32) / 255.0 # normalize
photo.set_shape((self.src_height, self.src_width, 1))
photo.set_shape((None, None, 1))
return photo
def _load_depth(self, idx):
depth = tf.read_file(self.depth_path_list[idx])
depth = tf.image.decode_png(depth, 1, dtype=tf.uint16) # force to load as grayscale
depth = tf.scalar_mul(self.depth_factor, tf.cast(depth, tf.float32))
is_zero = tf.equal(depth, tf.constant(0, dtype=tf.float32))
valid_mask = tf.cast(tf.logical_not(is_zero), tf.float32)
far_depth = tf.scalar_mul(self.far_depth_val, tf.ones_like(depth, dtype=tf.float32))
# pay attention when you visualize depth due to dynamic range (0~1000)
depth = tf.where(is_zero, far_depth, depth)
# depth.set_shape((self.src_height, self.src_width, 1))
depth.set_shape((None, None, 1))
return depth, valid_mask
def _get_delta_pose(self, c1Tw, c2Tw):
# cTw = world to camera pose [4x4 matrix]
# return = c2Tc1, which means c1 to c2 pose
c1Rw = tf.slice(c1Tw, [0,0], [3,3])
c2Rw = tf.slice(c2Tw, [0,0], [3,3])
c1Pw = tf.slice(c1Tw, [0,3], [3,1])
c2Pw = tf.slice(c2Tw, [0,3], [3,1])
wPc1 = -tf.matmul(c1Rw, c1Pw, transpose_a=True) # wPc = -wRc cPw
wPc2 = -tf.matmul(c2Rw, c2Pw, transpose_a=True) # wPc = -wRc cPw
c2Rc1 = tf.matmul(c2Rw, c1Rw, transpose_b=True) # c2Rc1 = c2Rw wRc1
c2Pc1 = tf.matmul(c2Rw, wPc1-wPc2) # c2Pc1 = c2Rw (wPc1-wPc2)
# c2Tc1 (4x4) =
# | c2Rc1 c2Pc1 |
# | 0 1 |
c2Tc1 = tf.concat([c2Rc1, c2Pc1], axis=1)
c2Tc1 = tf.concat([c2Tc1, tf.constant([[0,0,0,1]], dtype=tf.float32)], axis=0)
c1Tc2 = tf.matrix_inverse(c2Tc1)
return c2Tc1, c1Tc2
def _make_scale_theta(self, sx, sy):
# 3x3 matrix
theta = tf.stack(
[sx, 0, 0,
0, sy, 0,
0, 0, 1])
return tf.cast(tf.reshape(theta, [3,3]), tf.float32)
def _load_random_table(self, table_path, min_table_size):
if not os.path.join(table_path):
raise ValueError('Cannot load random-table from {}'.format(table_path))
random_table = | np.load(table_path) | numpy.load |
import numpy as np
import multiprocessing
import sys
import time
import matplotlib.pyplot as plt
# =============================================================================
# Distributed Computing Parameters
pool_size = multiprocessing.cpu_count()
# Genetic Circuit Hyperparameters
NODES = 3000
# Evolutionary Algorithm Hyperparameters
GENERATIONS = 201 # number of generations to run
# Other Hyperparameters
# STEP_MUTATION_RATE = 0.9
# BIG_STEP_MUTATION_RATE = 0.8
# RANDOM_MUTATION_RATE = 1
# SIGN_FLIP_MUTATION_RATE = 0.1
# REG_RATE = 0.0003 # regularization rate
STEP_SIZE = 2.0 # max mutation intensity of each weight
POPULATION = pool_size * 6 # total number of population
SURVIVABLE_PARENTS = POPULATION // 3 # number of parents to survive
# Novelty Search Hyperparameters
# KNN_BC_NUM = 1 # k nearest neighbors number for behavior characteristics
# ARCHIVE_STORING_RATE = 0.01
# ODE
TIME_STEPS = 300
BATCH_SIZE = 30 # Fully dividable by 3 recommended
# Score Constraints
ERROR_BOUND = 0.1 # percentage of error allowed (sigmoid bounds are +-1)
BANDPASS_BOUND = 0.3
# the absolute bound of each weight (very important)
# choose something close to sigmoid saturation is good (eg. 7.5+, 5 is not good, 10 is good)
BOUND = 13
# Parameters (Derived from hyperparameters)
DNA_SIZE = NODES * NODES
UPPER_BANDPASS_BOUND = 1 - BANDPASS_BOUND
COST_UPPER_BOUND = ERROR_BOUND * BATCH_SIZE
# =============================================================================
# Mean normalization
def standardize(population):
# as known as z-score normalization
# the other method being min-max normalization
for i, weights in enumerate(population):
mean = np.mean(weights)
std = np.std(weights)
population[i] = (weights - mean) / std
return population
# =============================================================================
# ODE & Simulations
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# FF Classifier
# Here, only the classical solution determinator is implemented
# def simulate_ode_original(W, N, B, S):
# dt = 0.01
# initial_val = 0.1 * np.ones([B, S]) # can we reuse this?
# input_val = np.linspace(0, 2, B).reshape(B, 1) * np.random.normal(
# loc=1.0, scale=0.0001, size=[N, B, S]) # can we reduce the redundants?
# input_val[:, :, 1:S] = 0.0
# output = initial_val + (
# sigmoid(np.matmul(initial_val, W)) - initial_val + input_val[0]) * dt
# # print(output)
# # HOW: create one time np.linspace(0, 2, B), mutate and reuse in for loop
# for i in range(1, N):
# output = output + (
# sigmoid(np.matmul(output, W)) - output + input_val[i]) * dt
# # print(output)
# return output
# input_initializer = np.linspace(0, 2, BATCH_SIZE).reshape(BATCH_SIZE, 1,)
# input_val[:, 0] = np.linspace(0, 2, BATCH_SIZE).reshape(BATCH_SIZE)
# print(np.random.normal(loc=1.0, scale=0.0001))
dt = 0.01
initial_val = 0.1 * np.ones([BATCH_SIZE, NODES])
input_val = np.zeros((BATCH_SIZE, NODES))
linspace_col = np.linspace(0, 2, BATCH_SIZE).reshape(BATCH_SIZE)
def simulate_ode(W, N, B, S):
# Insert one input and have three outputs
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 1] = linspace_col * | np.random.normal(loc=1.0, scale=0.0001) | numpy.random.normal |
from typing import List
import numpy as np
from poker_ai.poker.evaluation import Evaluator
class GameUtility:
"""This class takes care of some game related functions."""
def __init__(self, our_hand: np.ndarray, board: np.ndarray, cards: np.ndarray):
self._evaluator = Evaluator()
unavailable_cards = | np.concatenate([board, our_hand], axis=0) | numpy.concatenate |
# This module has been generated automatically from space group information
# obtained from the Computational Crystallography Toolbox
#
"""
Space groups
This module contains a list of all the 230 space groups that can occur in
a crystal. The variable space_groups contains a dictionary that maps
space group numbers and space group names to the corresponding space
group objects.
.. moduleauthor:: <NAME> <<EMAIL>>
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2013 The Mosaic Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file LICENSE.txt, distributed as part of this software.
#-----------------------------------------------------------------------------
import numpy as N
class SpaceGroup(object):
"""
Space group
All possible space group objects are created in this module. Other
modules should access these objects through the dictionary
space_groups rather than create their own space group objects.
"""
def __init__(self, number, symbol, transformations):
"""
:param number: the number assigned to the space group by
international convention
:type number: int
:param symbol: the Hermann-Mauguin space-group symbol as used
in PDB and mmCIF files
:type symbol: str
:param transformations: a list of space group transformations,
each consisting of a tuple of three
integer arrays (rot, tn, td), where
rot is the rotation matrix and tn/td
are the numerator and denominator of the
translation vector. The transformations
are defined in fractional coordinates.
:type transformations: list
"""
self.number = number
self.symbol = symbol
self.transformations = transformations
self.transposed_rotations = N.array([N.transpose(t[0])
for t in transformations])
self.phase_factors = N.exp(N.array([(-2j*N.pi*t[1])/t[2]
for t in transformations]))
def __repr__(self):
return "SpaceGroup(%d, %s)" % (self.number, repr(self.symbol))
def __len__(self):
"""
:return: the number of space group transformations
:rtype: int
"""
return len(self.transformations)
def symmetryEquivalentMillerIndices(self, hkl):
"""
:param hkl: a set of Miller indices
:type hkl: Scientific.N.array_type
:return: a tuple (miller_indices, phase_factor) of two arrays
of length equal to the number of space group
transformations. miller_indices contains the Miller
indices of each reflection equivalent by symmetry to the
reflection hkl (including hkl itself as the first element).
phase_factor contains the phase factors that must be applied
to the structure factor of reflection hkl to obtain the
structure factor of the symmetry equivalent reflection.
:rtype: tuple
"""
hkls = N.dot(self.transposed_rotations, hkl)
p = N.multiply.reduce(self.phase_factors**hkl, -1)
return hkls, p
space_groups = {}
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(1, 'P 1', transformations)
space_groups[1] = sg
space_groups['P 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(2, 'P -1', transformations)
space_groups[2] = sg
space_groups['P -1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(3, 'P 1 2 1', transformations)
space_groups[3] = sg
space_groups['P 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(4, 'P 1 21 1', transformations)
space_groups[4] = sg
space_groups['P 1 21 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(5, 'C 1 2 1', transformations)
space_groups[5] = sg
space_groups['C 1 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(6, 'P 1 m 1', transformations)
space_groups[6] = sg
space_groups['P 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(7, 'P 1 c 1', transformations)
space_groups[7] = sg
space_groups['P 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(8, 'C 1 m 1', transformations)
space_groups[8] = sg
space_groups['C 1 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(9, 'C 1 c 1', transformations)
space_groups[9] = sg
space_groups['C 1 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(10, 'P 1 2/m 1', transformations)
space_groups[10] = sg
space_groups['P 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(11, 'P 1 21/m 1', transformations)
space_groups[11] = sg
space_groups['P 1 21/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(12, 'C 1 2/m 1', transformations)
space_groups[12] = sg
space_groups['C 1 2/m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(13, 'P 1 2/c 1', transformations)
space_groups[13] = sg
space_groups['P 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(14, 'P 1 21/c 1', transformations)
space_groups[14] = sg
space_groups['P 1 21/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(15, 'C 1 2/c 1', transformations)
space_groups[15] = sg
space_groups['C 1 2/c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(16, 'P 2 2 2', transformations)
space_groups[16] = sg
space_groups['P 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(17, 'P 2 2 21', transformations)
space_groups[17] = sg
space_groups['P 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(18, 'P 21 21 2', transformations)
space_groups[18] = sg
space_groups['P 21 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(19, 'P 21 21 21', transformations)
space_groups[19] = sg
space_groups['P 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(20, 'C 2 2 21', transformations)
space_groups[20] = sg
space_groups['C 2 2 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(21, 'C 2 2 2', transformations)
space_groups[21] = sg
space_groups['C 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(22, 'F 2 2 2', transformations)
space_groups[22] = sg
space_groups['F 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(23, 'I 2 2 2', transformations)
space_groups[23] = sg
space_groups['I 2 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(24, 'I 21 21 21', transformations)
space_groups[24] = sg
space_groups['I 21 21 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(25, 'P m m 2', transformations)
space_groups[25] = sg
space_groups['P m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(26, 'P m c 21', transformations)
space_groups[26] = sg
space_groups['P m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(27, 'P c c 2', transformations)
space_groups[27] = sg
space_groups['P c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(28, 'P m a 2', transformations)
space_groups[28] = sg
space_groups['P m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(29, 'P c a 21', transformations)
space_groups[29] = sg
space_groups['P c a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(30, 'P n c 2', transformations)
space_groups[30] = sg
space_groups['P n c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(31, 'P m n 21', transformations)
space_groups[31] = sg
space_groups['P m n 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(32, 'P b a 2', transformations)
space_groups[32] = sg
space_groups['P b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(33, 'P n a 21', transformations)
space_groups[33] = sg
space_groups['P n a 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(34, 'P n n 2', transformations)
space_groups[34] = sg
space_groups['P n n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(35, 'C m m 2', transformations)
space_groups[35] = sg
space_groups['C m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(36, 'C m c 21', transformations)
space_groups[36] = sg
space_groups['C m c 21'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(37, 'C c c 2', transformations)
space_groups[37] = sg
space_groups['C c c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(38, 'A m m 2', transformations)
space_groups[38] = sg
space_groups['A m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(39, 'A b m 2', transformations)
space_groups[39] = sg
space_groups['A b m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(40, 'A m a 2', transformations)
space_groups[40] = sg
space_groups['A m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(41, 'A b a 2', transformations)
space_groups[41] = sg
space_groups['A b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(42, 'F m m 2', transformations)
space_groups[42] = sg
space_groups['F m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(43, 'F d d 2', transformations)
space_groups[43] = sg
space_groups['F d d 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(44, 'I m m 2', transformations)
space_groups[44] = sg
space_groups['I m m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(45, 'I b a 2', transformations)
space_groups[45] = sg
space_groups['I b a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(46, 'I m a 2', transformations)
space_groups[46] = sg
space_groups['I m a 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(47, 'P m m m', transformations)
space_groups[47] = sg
space_groups['P m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(48, 'P n n n :2', transformations)
space_groups[48] = sg
space_groups['P n n n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(49, 'P c c m', transformations)
space_groups[49] = sg
space_groups['P c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(50, 'P b a n :2', transformations)
space_groups[50] = sg
space_groups['P b a n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(51, 'P m m a', transformations)
space_groups[51] = sg
space_groups['P m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(52, 'P n n a', transformations)
space_groups[52] = sg
space_groups['P n n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(53, 'P m n a', transformations)
space_groups[53] = sg
space_groups['P m n a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(54, 'P c c a', transformations)
space_groups[54] = sg
space_groups['P c c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(55, 'P b a m', transformations)
space_groups[55] = sg
space_groups['P b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(56, 'P c c n', transformations)
space_groups[56] = sg
space_groups['P c c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(57, 'P b c m', transformations)
space_groups[57] = sg
space_groups['P b c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(58, 'P n n m', transformations)
space_groups[58] = sg
space_groups['P n n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(59, 'P m m n :2', transformations)
space_groups[59] = sg
space_groups['P m m n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(60, 'P b c n', transformations)
space_groups[60] = sg
space_groups['P b c n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(61, 'P b c a', transformations)
space_groups[61] = sg
space_groups['P b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(62, 'P n m a', transformations)
space_groups[62] = sg
space_groups['P n m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(63, 'C m c m', transformations)
space_groups[63] = sg
space_groups['C m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(64, 'C m c a', transformations)
space_groups[64] = sg
space_groups['C m c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(65, 'C m m m', transformations)
space_groups[65] = sg
space_groups['C m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(66, 'C c c m', transformations)
space_groups[66] = sg
space_groups['C c c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(67, 'C m m a', transformations)
space_groups[67] = sg
space_groups['C m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(68, 'C c c a :2', transformations)
space_groups[68] = sg
space_groups['C c c a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(69, 'F m m m', transformations)
space_groups[69] = sg
space_groups['F m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(70, 'F d d d :2', transformations)
space_groups[70] = sg
space_groups['F d d d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(71, 'I m m m', transformations)
space_groups[71] = sg
space_groups['I m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(72, 'I b a m', transformations)
space_groups[72] = sg
space_groups['I b a m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(73, 'I b c a', transformations)
space_groups[73] = sg
space_groups['I b c a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(74, 'I m m a', transformations)
space_groups[74] = sg
space_groups['I m m a'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(75, 'P 4', transformations)
space_groups[75] = sg
space_groups['P 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(76, 'P 41', transformations)
space_groups[76] = sg
space_groups['P 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(77, 'P 42', transformations)
space_groups[77] = sg
space_groups['P 42'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(78, 'P 43', transformations)
space_groups[78] = sg
space_groups['P 43'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(79, 'I 4', transformations)
space_groups[79] = sg
space_groups['I 4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(80, 'I 41', transformations)
space_groups[80] = sg
space_groups['I 41'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(81, 'P -4', transformations)
space_groups[81] = sg
space_groups['P -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(82, 'I -4', transformations)
space_groups[82] = sg
space_groups['I -4'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(83, 'P 4/m', transformations)
space_groups[83] = sg
space_groups['P 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(84, 'P 42/m', transformations)
space_groups[84] = sg
space_groups['P 42/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(85, 'P 4/n :2', transformations)
space_groups[85] = sg
space_groups['P 4/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(86, 'P 42/n :2', transformations)
space_groups[86] = sg
space_groups['P 42/n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(87, 'I 4/m', transformations)
space_groups[87] = sg
space_groups['I 4/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(88, 'I 41/a :2', transformations)
space_groups[88] = sg
space_groups['I 41/a :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(89, 'P 4 2 2', transformations)
space_groups[89] = sg
space_groups['P 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(90, 'P 4 21 2', transformations)
space_groups[90] = sg
space_groups['P 4 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(91, 'P 41 2 2', transformations)
space_groups[91] = sg
space_groups['P 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(92, 'P 41 21 2', transformations)
space_groups[92] = sg
space_groups['P 41 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(93, 'P 42 2 2', transformations)
space_groups[93] = sg
space_groups['P 42 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(94, 'P 42 21 2', transformations)
space_groups[94] = sg
space_groups['P 42 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,3])
trans_den = N.array([1,1,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(95, 'P 43 2 2', transformations)
space_groups[95] = sg
space_groups['P 43 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(96, 'P 43 21 2', transformations)
space_groups[96] = sg
space_groups['P 43 21 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(97, 'I 4 2 2', transformations)
space_groups[97] = sg
space_groups['I 4 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(98, 'I 41 2 2', transformations)
space_groups[98] = sg
space_groups['I 41 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(99, 'P 4 m m', transformations)
space_groups[99] = sg
space_groups['P 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(100, 'P 4 b m', transformations)
space_groups[100] = sg
space_groups['P 4 b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(101, 'P 42 c m', transformations)
space_groups[101] = sg
space_groups['P 42 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(102, 'P 42 n m', transformations)
space_groups[102] = sg
space_groups['P 42 n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(103, 'P 4 c c', transformations)
space_groups[103] = sg
space_groups['P 4 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(104, 'P 4 n c', transformations)
space_groups[104] = sg
space_groups['P 4 n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(105, 'P 42 m c', transformations)
space_groups[105] = sg
space_groups['P 42 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(106, 'P 42 b c', transformations)
space_groups[106] = sg
space_groups['P 42 b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(107, 'I 4 m m', transformations)
space_groups[107] = sg
space_groups['I 4 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(108, 'I 4 c m', transformations)
space_groups[108] = sg
space_groups['I 4 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(109, 'I 41 m d', transformations)
space_groups[109] = sg
space_groups['I 41 m d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(110, 'I 41 c d', transformations)
space_groups[110] = sg
space_groups['I 41 c d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(111, 'P -4 2 m', transformations)
space_groups[111] = sg
space_groups['P -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(112, 'P -4 2 c', transformations)
space_groups[112] = sg
space_groups['P -4 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(113, 'P -4 21 m', transformations)
space_groups[113] = sg
space_groups['P -4 21 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(114, 'P -4 21 c', transformations)
space_groups[114] = sg
space_groups['P -4 21 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(115, 'P -4 m 2', transformations)
space_groups[115] = sg
space_groups['P -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(116, 'P -4 c 2', transformations)
space_groups[116] = sg
space_groups['P -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(117, 'P -4 b 2', transformations)
space_groups[117] = sg
space_groups['P -4 b 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(118, 'P -4 n 2', transformations)
space_groups[118] = sg
space_groups['P -4 n 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(119, 'I -4 m 2', transformations)
space_groups[119] = sg
space_groups['I -4 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(120, 'I -4 c 2', transformations)
space_groups[120] = sg
space_groups['I -4 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(121, 'I -4 2 m', transformations)
space_groups[121] = sg
space_groups['I -4 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,3])
trans_den = N.array([2,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,5])
trans_den = N.array([1,2,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(122, 'I -4 2 d', transformations)
space_groups[122] = sg
space_groups['I -4 2 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(123, 'P 4/m m m', transformations)
space_groups[123] = sg
space_groups['P 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(124, 'P 4/m c c', transformations)
space_groups[124] = sg
space_groups['P 4/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(125, 'P 4/n b m :2', transformations)
space_groups[125] = sg
space_groups['P 4/n b m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(126, 'P 4/n n c :2', transformations)
space_groups[126] = sg
space_groups['P 4/n n c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(127, 'P 4/m b m', transformations)
space_groups[127] = sg
space_groups['P 4/m b m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(128, 'P 4/m n c', transformations)
space_groups[128] = sg
space_groups['P 4/m n c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(129, 'P 4/n m m :2', transformations)
space_groups[129] = sg
space_groups['P 4/n m m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(130, 'P 4/n c c :2', transformations)
space_groups[130] = sg
space_groups['P 4/n c c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(131, 'P 42/m m c', transformations)
space_groups[131] = sg
space_groups['P 42/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(132, 'P 42/m c m', transformations)
space_groups[132] = sg
space_groups['P 42/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(133, 'P 42/n b c :2', transformations)
space_groups[133] = sg
space_groups['P 42/n b c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(134, 'P 42/n n m :2', transformations)
space_groups[134] = sg
space_groups['P 42/n n m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(135, 'P 42/m b c', transformations)
space_groups[135] = sg
space_groups['P 42/m b c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(136, 'P 42/m n m', transformations)
space_groups[136] = sg
space_groups['P 42/m n m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(137, 'P 42/n m c :2', transformations)
space_groups[137] = sg
space_groups['P 42/n m c :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(138, 'P 42/n c m :2', transformations)
space_groups[138] = sg
space_groups['P 42/n c m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(139, 'I 4/m m m', transformations)
space_groups[139] = sg
space_groups['I 4/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(140, 'I 4/m c m', transformations)
space_groups[140] = sg
space_groups['I 4/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(141, 'I 41/a m d :2', transformations)
space_groups[141] = sg
space_groups['I 41/a m d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-3,-3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,-1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(142, 'I 41/a c d :2', transformations)
space_groups[142] = sg
space_groups['I 41/a c d :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(143, 'P 3', transformations)
space_groups[143] = sg
space_groups['P 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(144, 'P 31', transformations)
space_groups[144] = sg
space_groups['P 31'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(145, 'P 32', transformations)
space_groups[145] = sg
space_groups['P 32'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(146, 'R 3 :H', transformations)
space_groups[146] = sg
space_groups['R 3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(147, 'P -3', transformations)
space_groups[147] = sg
space_groups['P -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(148, 'R -3 :H', transformations)
space_groups[148] = sg
space_groups['R -3 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(149, 'P 3 1 2', transformations)
space_groups[149] = sg
space_groups['P 3 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(150, 'P 3 2 1', transformations)
space_groups[150] = sg
space_groups['P 3 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(151, 'P 31 1 2', transformations)
space_groups[151] = sg
space_groups['P 31 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(152, 'P 31 2 1', transformations)
space_groups[152] = sg
space_groups['P 31 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(153, 'P 32 1 2', transformations)
space_groups[153] = sg
space_groups['P 32 1 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(154, 'P 32 2 1', transformations)
space_groups[154] = sg
space_groups['P 32 2 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(155, 'R 3 2 :H', transformations)
space_groups[155] = sg
space_groups['R 3 2 :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(156, 'P 3 m 1', transformations)
space_groups[156] = sg
space_groups['P 3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(157, 'P 3 1 m', transformations)
space_groups[157] = sg
space_groups['P 3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(158, 'P 3 c 1', transformations)
space_groups[158] = sg
space_groups['P 3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(159, 'P 3 1 c', transformations)
space_groups[159] = sg
space_groups['P 3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(160, 'R 3 m :H', transformations)
space_groups[160] = sg
space_groups['R 3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(161, 'R 3 c :H', transformations)
space_groups[161] = sg
space_groups['R 3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(162, 'P -3 1 m', transformations)
space_groups[162] = sg
space_groups['P -3 1 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(163, 'P -3 1 c', transformations)
space_groups[163] = sg
space_groups['P -3 1 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(164, 'P -3 m 1', transformations)
space_groups[164] = sg
space_groups['P -3 m 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(165, 'P -3 c 1', transformations)
space_groups[165] = sg
space_groups['P -3 c 1'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(166, 'R -3 m :H', transformations)
space_groups[166] = sg
space_groups['R -3 m :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,7])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,2,2])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,2,1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,5])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([2,1,1])
trans_den = N.array([3,3,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([2,1,-1])
trans_den = N.array([3,3,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(167, 'R -3 c :H', transformations)
space_groups[167] = sg
space_groups['R -3 c :H'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(168, 'P 6', transformations)
space_groups[168] = sg
space_groups['P 6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(169, 'P 61', transformations)
space_groups[169] = sg
space_groups['P 61'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(170, 'P 65', transformations)
space_groups[170] = sg
space_groups['P 65'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(171, 'P 62', transformations)
space_groups[171] = sg
space_groups['P 62'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(172, 'P 64', transformations)
space_groups[172] = sg
space_groups['P 64'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(173, 'P 63', transformations)
space_groups[173] = sg
space_groups['P 63'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(174, 'P -6', transformations)
space_groups[174] = sg
space_groups['P -6'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(175, 'P 6/m', transformations)
space_groups[175] = sg
space_groups['P 6/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(176, 'P 63/m', transformations)
space_groups[176] = sg
space_groups['P 63/m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(177, 'P 6 2 2', transformations)
space_groups[177] = sg
space_groups['P 6 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(178, 'P 61 2 2', transformations)
space_groups[178] = sg
space_groups['P 61 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,5])
trans_den = N.array([1,1,6])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(179, 'P 65 2 2', transformations)
space_groups[179] = sg
space_groups['P 65 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(180, 'P 62 2 2', transformations)
space_groups[180] = sg
space_groups['P 62 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,2])
trans_den = N.array([1,1,3])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(181, 'P 64 2 2', transformations)
space_groups[181] = sg
space_groups['P 64 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(182, 'P 63 2 2', transformations)
space_groups[182] = sg
space_groups['P 63 2 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(183, 'P 6 m m', transformations)
space_groups[183] = sg
space_groups['P 6 m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(184, 'P 6 c c', transformations)
space_groups[184] = sg
space_groups['P 6 c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(185, 'P 63 c m', transformations)
space_groups[185] = sg
space_groups['P 63 c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(186, 'P 63 m c', transformations)
space_groups[186] = sg
space_groups['P 63 m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(187, 'P -6 m 2', transformations)
space_groups[187] = sg
space_groups['P -6 m 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(188, 'P -6 c 2', transformations)
space_groups[188] = sg
space_groups['P -6 c 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(189, 'P -6 2 m', transformations)
space_groups[189] = sg
space_groups['P -6 2 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(190, 'P -6 2 c', transformations)
space_groups[190] = sg
space_groups['P -6 2 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(191, 'P 6/m m m', transformations)
space_groups[191] = sg
space_groups['P 6/m m m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(192, 'P 6/m c c', transformations)
space_groups[192] = sg
space_groups['P 6/m c c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(193, 'P 63/m c m', transformations)
space_groups[193] = sg
space_groups['P 63/m c m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,1,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,1,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,-1,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,-1,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(194, 'P 63/m m c', transformations)
space_groups[194] = sg
space_groups['P 63/m m c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(195, 'P 2 3', transformations)
space_groups[195] = sg
space_groups['P 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(196, 'F 2 3', transformations)
space_groups[196] = sg
space_groups['F 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(197, 'I 2 3', transformations)
space_groups[197] = sg
space_groups['I 2 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(198, 'P 21 3', transformations)
space_groups[198] = sg
space_groups['P 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(199, 'I 21 3', transformations)
space_groups[199] = sg
space_groups['I 21 3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(200, 'P m -3', transformations)
space_groups[200] = sg
space_groups['P m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(201, 'P n -3 :2', transformations)
space_groups[201] = sg
space_groups['P n -3 :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(202, 'F m -3', transformations)
space_groups[202] = sg
space_groups['F m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,3,3])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,0,3])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([4,4,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(203, 'F d -3 :2', transformations)
space_groups[203] = sg
space_groups['F d -3 :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(204, 'I m -3', transformations)
space_groups[204] = sg
space_groups['I m -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(205, 'P a -3', transformations)
space_groups[205] = sg
space_groups['P a -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(206, 'I a -3', transformations)
space_groups[206] = sg
space_groups['I a -3'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(207, 'P 4 3 2', transformations)
space_groups[207] = sg
space_groups['P 4 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(208, 'P 42 3 2', transformations)
space_groups[208] = sg
space_groups['P 42 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(209, 'F 4 3 2', transformations)
space_groups[209] = sg
space_groups['F 4 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(210, 'F 41 3 2', transformations)
space_groups[210] = sg
space_groups['F 41 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(211, 'I 4 3 2', transformations)
space_groups[211] = sg
space_groups['I 4 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(212, 'P 43 3 2', transformations)
space_groups[212] = sg
space_groups['P 43 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(213, 'P 41 3 2', transformations)
space_groups[213] = sg
space_groups['P 41 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(214, 'I 41 3 2', transformations)
space_groups[214] = sg
space_groups['I 41 3 2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(215, 'P -4 3 m', transformations)
space_groups[215] = sg
space_groups['P -4 3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(216, 'F -4 3 m', transformations)
space_groups[216] = sg
space_groups['F -4 3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(217, 'I -4 3 m', transformations)
space_groups[217] = sg
space_groups['I -4 3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(218, 'P -4 3 n', transformations)
space_groups[218] = sg
space_groups['P -4 3 n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(219, 'F -4 3 c', transformations)
space_groups[219] = sg
space_groups['F -4 3 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,5,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,5])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([3,5,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([3,3,3])
trans_den = N.array([4,4,4])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(220, 'I -4 3 d', transformations)
space_groups[220] = sg
space_groups['I -4 3 d'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(221, 'P m -3 m', transformations)
space_groups[221] = sg
space_groups['P m -3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,-1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(222, 'P n -3 n :2', transformations)
space_groups[222] = sg
space_groups['P n -3 n :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,-1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(223, 'P m -3 n', transformations)
space_groups[223] = sg
space_groups['P m -3 n'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,-1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(224, 'P n -3 m :2', transformations)
space_groups[224] = sg
space_groups['P n -3 m :2'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(225, 'F m -3 m', transformations)
space_groups[225] = sg
space_groups['F m -3 m'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,0])
trans_den = N.array([2,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([2,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,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([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-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([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,1])
trans_den = N.array([1,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,-1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,-1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,-1,0,0,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,1,0,0,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([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([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([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([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([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,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([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([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,0])
trans_den = N.array([1,2,1])
transformations.append((rot, trans_num, trans_den))
sg = SpaceGroup(226, 'F m -3 c', transformations)
space_groups[226] = sg
space_groups['F m -3 c'] = sg
transformations = []
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,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,0])
trans_den = N.array([4,4,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([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,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([0,1,1])
trans_den = N.array([1,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,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([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,1,0,0,0,1,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, 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([0,1,0,1,0,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([0,-1,0,-1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,0,1])
trans_den = N.array([4,1,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([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,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([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,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,0])
trans_den = N.array([4,4,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([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,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([0,-1,-1])
trans_den = N.array([1,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,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([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,-1,0,0,0,-1,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, 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([0,-1,0,-1,0,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([0,1,0,1,0,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,-1,0,1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([-1,0,-1])
trans_den = N.array([4,1,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([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([0,-1,-1])
trans_den = N.array([1,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([0,0,0])
trans_den = N.array([1,1,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([4,2,4])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,3,1])
trans_den = N.array([4,4,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,3,1])
trans_den = N.array([4,4,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,3,3])
trans_den = N.array([1,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([0,3,3])
trans_den = N.array([1,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,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([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([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,2])
transformations.append((rot, trans_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([1,1,3])
trans_den = N.array([4,2,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([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,3,3])
trans_den = N.array([1,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([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([-1,1,1])
trans_den = N.array([4,2,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,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([4,4,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,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([0,1,1])
trans_den = N.array([1,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,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([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([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,2])
transformations.append((rot, trans_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([-1,1,1])
trans_den = N.array([4,2,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([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,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([0,1,1])
trans_den = N.array([1,2,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([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,0,3])
trans_den = N.array([4,1,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,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([3,1,1])
trans_den = N.array([4,4,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,3])
trans_den = N.array([2,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([2,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,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([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([0,1,0,1,0,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([3,1,1])
trans_den = N.array([4,4,2])
transformations.append((rot, trans_num, 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([3,0,3])
trans_den = N.array([4,1,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,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,0,1,0,1,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,3])
trans_den = N.array([2,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,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([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([4,1,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,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([4,4,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,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([2,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,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,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([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,2])
transformations.append((rot, trans_num, 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([4,1,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,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,0,-1,0,-1,0])
rot.shape = (3, 3)
trans_num = N.array([1,-1,1])
trans_den = N.array([2,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,0,1])
trans_den = N.array([2,1,2])
transformations.append((rot, trans_num, trans_den))
rot = N.array([1,0,0,0,1,0,0,0,1])
rot.shape = (3, 3)
trans_num = N.array([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,1,1])
trans_den = N.array([4,2,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,0])
trans_den = N.array([4,4,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([3,3,0])
trans_den = N.array([4,4,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,3,1])
trans_den = N.array([2,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([2,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,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([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([0,1,0,1,0,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([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([3,1,1])
trans_den = N.array([4,2,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,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,3,1])
trans_den = N.array([2,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,0])
trans_den = N.array([2,2,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([-1,0,0,0,-1,0,0,0,-1])
rot.shape = (3, 3)
trans_num = N.array([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,-1])
trans_den = N.array([4,2,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,0])
trans_den = N.array([4,4,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([4,4,1])
transformations.append((rot, trans_num, trans_den))
rot = N.array([0,0,1,0,-1,0,-1,0,0])
rot.shape = (3, 3)
trans_num = N.array([1,1,-1])
trans_den = N.array([2,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([2,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,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([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]) | numpy.array |
import pandas as pd
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
from sklearn.preprocessing import LabelEncoder #IMPORTA A BIBLIOTECA DO ENCODER
from keras.utils import np_utils #IMPORTA A BIBLIOTECA PARA COMPLEMENTAR O ENCODER
import numpy as np
from sklearn.metrics import confusion_matrix
base = pd.read_csv('iris.csv')
previsores = base.iloc[:, 0:4].values
classe = base.iloc[:, 4].values
labelEncoder = LabelEncoder() #CRIA O OBJETO DO ENCODER
classe = labelEncoder.fit_transform(classe) #TRANSFORMA AS CLASSES DAS PLANTAS EM VALORES NUMERICOS
classe_dummy = np_utils.to_categorical(classe)
"""
iris setosa 1 0 0
iris virginica 0 1 0
iris versicolor 0 0 1
"""
previsores_treinamento, previsores_teste, classe_treinamento, classe_teste = train_test_split(previsores,
classe_dummy,
test_size=0.25)
classificador = Sequential()
classificador.add(Dense(units = 4, activation = 'relu', input_dim = 4))
classificador.add(Dense(units = 4, activation = 'relu'))
classificador.add(Dense(units = 3, activation = 'softmax'))
classificador.compile(optimizer='adam', loss = 'categorical_crossentropy', metrics = ['categorical_accuracy'])
classificador.fit(previsores_treinamento, classe_treinamento, batch_size = 10, epochs = 1000)
resultado = classificador.evaluate(previsores_teste, classe_teste)
previsoes = classificador.predict(previsores_teste)
previsoes = (previsoes > 0.5)
classe_teste2 = [ | np.argmax(t) | numpy.argmax |
import os
import numpy as np
#select a region of the spectrum within [wmin, wmax]
def spectrum_in_range(l_original, f_original, wmin, wmax):
l_trim, f_trim = [], []
for l, f in zip(l_original, f_original):
if l >= wmin and l <= wmax:
l_trim.append(l)
f_trim.append(f)
l_trim, f_trim = np.array(l_trim), np.array(f_trim)
return l_trim, f_trim
#run SNID
def run_snid(l, f, snid_options, snid_templates):
#save the input spectrum in a file
input_spectrum = 'input.txt'
file_spectrum = open(input_spectrum, 'w')
for ll, ff in zip(l, f): file_spectrum.write('%8.3f %.7e\n' % (ll, ff))
file_spectrum.close()
#run SNID
os.system('snid '+snid_options+' '+snid_templates+' '+input_spectrum)
os.system('rm '+input_spectrum)
os.system('rm snid.param')
snid_file = 'input_snid.output'
if os.path.exists(snid_file) == False:
print('ERROR in run_snid: there is no SNID output')
sne_bm, rlaps, zs, snid_phases = np.array([]), np.array([]), np.array([]), np.array([])
else:
#read important parameters
sne_bm = np.atleast_1d(np.genfromtxt(snid_file, skip_header=67, usecols=1, dtype=str))
rlaps = np.atleast_1d(np.genfromtxt(snid_file, skip_header=67, usecols=4))
zs = np.atleast_1d(np.genfromtxt(snid_file, skip_header=67, usecols=5))
snid_phases = np.atleast_1d(np.genfromtxt(snid_file, skip_header=67, usecols=7))
os.system('rm '+snid_file)
return sne_bm, rlaps, zs, snid_phases
#average snid results
def average_snid_results(phases, rms_phases):
phase, err_phase = float('nan'), float('nan')
if len(phases) != 0:
if len(phases) == 1:
phase, err_phase = phases[0], rms_phases[0]
else:
#compute the phase and its error minimizing the log-likelihood
residuals = phases - np.mean(phases)
rms = np.sqrt(np.sum(residuals**2)/float(len(residuals)-1))
err_0s = np.linspace(0.0, rms, 100)
m2ln_L_min = 1.0e90
for err_0 in err_0s:
var = rms_phases**2 + err_0**2
phase = np.sum(phases/var)/np.sum(1.0/var)
m2ln_L = np.sum(np.log(var)+(phases-phase)**2/var)
if m2ln_L < m2ln_L_min:
m2ln_L_min = m2ln_L
phase_min = phase
err_0_min = err_0
err_0 = err_0_min
phase = phase_min
var = rms_phases**2 + err_0**2
err_phase = np.sqrt(np.sum(rms_phases**2/var**2))/np.sum(1.0/var)
err_phase = np.sqrt(err_phase**2)
return phase, err_phase
#select results based on rlap and zfilter values
def filter_snid_results(t_specs, sne_match, rlaps, zs, t0s, rlap_min, zfilter, N_bests):
r, p, s, t, zz, i = [], [], [], [], [], 0
for rlap, z, t0, t_spec, sn_match in zip(rlaps, zs, t0s, t_specs, sne_match):
if rlap >= rlap_min and abs(z)<zfilter:
if i<N_bests:
r.append(rlap)
zz.append(z)
p.append(t0)
t.append(t_spec)
s.append(sn_match)
i = i + 1
rlaps, zs, t0s, t_specs, sne_match = np.array(r), np.array(zz), np.array(p), np.array(t), s
return t_specs, sne_match, rlaps, zs, t0s
#compute snid phases
def compute_snid_time(t_specs, sne_match, rlaps, zs, t0s, N_bests, JD_spectrum=-9999):
zfilter = 0.01
rlap_min = 5.0
rlap2err_par = np.array([3.0, 72.0, -75.0]) #rlap to rms(t0) conversion
#select good results
t_specs, sne_match, rlaps, zs, t0s = filter_snid_results(t_specs, sne_match, rlaps, zs, t0s, rlap_min, zfilter, N_bests)
if len(t0s) != 0:
#convert rlaps to rms(t0)
rms_t0s = 0.0
for i in range(0, len(rlap2err_par)): rms_t0s = rms_t0s + rlap2err_par[i]/rlaps**i
#average results
t0, err_t0 = average_snid_results(t0s, rms_t0s)
else:
if JD_spectrum == -9999:
print('ERROR in compute_snid_time: no match meeting our SNID requirements')
else:
print("spectrum at JD="+str(JD_spectrum)+" does not have best-matches meeting our SNID requirements")
t0, err_t0 = float('nan'), float('nan')
t_specs, sne_match, rlaps, zs, t0s, rms_t0s = np.array([]), np.array([]), np.array([]), np.array([]), np.array([]), np.array([])
return t_specs, sne_match, rlaps, zs, t0s, rms_t0s, t0, err_t0
#compute t0 and rms(t0) with SNID and the input spectra
def snid_results(templates_path, sn, z, JD_fd, JD_spectra, wl_spectra, f_spectra, snid_verbose, display_snid_plots):
wmin, wmax = 4100.0, 7000.0
N_bests = 10
if snid_verbose:
snid_verbose = '1'
else:
snid_verbose = '0'
if display_snid_plots:
display_snid_plots = '1'
else:
display_snid_plots = '0'
#aplicaremos SNID a todos los espectros input
t_specs_all, sne_match_all, rlaps_all, zs_all, t0s_all, N_good_spectra = np.array([]), np.array([]), np.array([]), np.array([]), np.array([]), 0
JD_list, t_specs_list, sne_match_list, rlaps_list, zs_list, t0s_list = [], {}, {}, {}, {}, {}
for JD_spectrum, wl_spectrum, f_spectrum in zip(JD_spectra, wl_spectra, f_spectra):
#select data within a wl range
wl, f = spectrum_in_range(wl_spectrum, f_spectrum, wmin, wmax)
#define the SNID options
snid_options = 'verbose='+snid_verbose+' plot='+display_snid_plots+' forcez=0.0 rlapmin=1.0 k1=1 k2=4 k3=85 k4=102'
#if the input SN is among the templates, then we avoid their templates
sn_templates = np.genfromtxt(templates_path+'/templist', usecols=0, dtype=str)
if sn+'.lnw' in sn_templates: snid_options = snid_options + ' avoid='+sn
snid_templates = 'tempdir='+templates_path+'/'
#run snid
sne_match, rlaps, zs, snid_phases = run_snid(wl, f, snid_options, snid_templates)
if len(sne_match) != 0:
#convert snid phases to t0: JD_spec-JD_t0=phase -> t0_JD = JD_spec-phase -> t0 = JD_spec-phase - JD_fd = (JD_spec-JD_fd)/(1.0+z) - phase
t0s = (JD_spectrum-JD_fd)/(1.0+z)-snid_phases
t_specs = snid_phases-snid_phases+JD_spectrum
#compute preliminar result
t_spec_best, sne_best, rlap_best, zs_best, t0_best, err_t0_best, t0, err_t0 = compute_snid_time(t_specs, sne_match, rlaps, zs, t0s, N_bests, JD_spectrum=JD_spectrum)
if np.isnan(t0) == False:
JD_list.append(JD_spectrum)
t_specs_list[str(JD_spectrum)] = t_spec_best
sne_match_list[str(JD_spectrum)] = sne_best
rlaps_list[str(JD_spectrum)] = rlap_best
zs_list[str(JD_spectrum)] = zs_best
t0s_list[str(JD_spectrum)] = t0_best
N_good_spectra = N_good_spectra+1
t_specs_all, sne_match_all = np.append(t_specs_all, t_spec_best), np.append(sne_match_all, sne_best)
rlaps_all, zs_all, t0s_all = np.append(rlaps_all, rlap_best), np.append(zs_all, zs_best), np.append(t0s_all, t0_best)
#sort by rlap
inds = rlaps_all.argsort()[::-1]
t_specs_all, sne_match_all = t_specs_all[inds], sne_match_all[inds]
rlaps_all, zs_all, t0s_all = rlaps_all[inds], zs_all[inds], t0s_all[inds]
t_spec_best, sne_best, rlap_best, zs_best, t0_best, err_t0_best, t0, err_t0 = compute_snid_time(t_specs_all, sne_match_all, rlaps_all, zs_all, t0s_all, N_bests*N_good_spectra)
t_specs_all, sne_match_all, rlaps_all, zs_all, t0s_all, N_good_spectra = np.array([]), np.array([]), np.array([]), np.array([]), | np.array([]) | numpy.array |
from firedrake import *
import numpy as np
import math,sys
import time as tm
from matplotlib import pyplot as plt
# from Limiter.hsign_backup import *
from Limiter.hsign import *
np.set_printoptions(precision=9)
from warnings import *
class get_flux(SignFlip):
def __init__(self,mesh,fluxes):
self.mesh = mesh
self.fluxes = fluxes
def apply(self):
hsign,cell_map,TwoCell,boundary_facet = SignFlip(self.mesh).HSIGN()
#========================;
# Step 0: Define H_{E,E'}:
#========================;
flux_val= self.fluxes.vector().array()
row , col = np.shape(cell_map)
old_FLUX = np.zeros((row,col))
for irow in range(row):
for icol in range(col):
old_FLUX[irow,icol] = flux_val[cell_map[irow,icol]]
# print('Old flux:\n',old_FLUX)
FLUX = np.multiply(old_FLUX,hsign)
return FLUX
class flux_limiter(SignFlip):
# def __init__(self,mesh,sol_0,sol,fluxes,solMax,solMin,dt):
def __init__(self,mesh,sol_0,sol,wells_avg,q_I,q_P,fluxes,solMax,solMin,dt):
self.mesh = mesh
self.sol_0 = sol_0
self.sol = sol
self.wells_avg = wells_avg.vector().array()
self.q_I = q_I.vector().array()
self.q_P = q_P.vector().array()
self.fluxes = fluxes
self.solMax = solMax
self.solMin = solMin
self.dt = dt
def wells_update(self,s):
fw = lambda t:\
( ((t-0.2)/0.65) * ((t-0.2)/0.65) * 1./(1e-3) )\
/( ( ((t-0.2)/0.65) * ((t-0.2)/0.65) * 1./(1e-3) ) +\
( (1-((t-0.2)/0.65)) *(1-((t-0.2)/0.65) ) * 1./(1e-2) ))
return ( self.q_I - fw(s) * self.q_P)
# self.wells_update(s) is when we want to use this function in this class
# forexample self.wells_update(solAvg)
def apply(self):
hsign,cell_map,TwoCell,boundary_facet = SignFlip(self.mesh).HSIGN()
# print('Hsign', signing)
# print('cell_map\n', cell_map)
# print('TwoCell', TwoCell)
# print('boundary_facet', boundary_facet)
#========================;
# Step 0: Define H_{E,E'}:
#========================;
flux_val= self.fluxes.vector().array()
row , col = np.shape(cell_map)
old_FLUX = np.zeros((row,col))
for irow in range(row):
for icol in range(col):
old_FLUX[irow,icol] = flux_val[cell_map[irow,icol]]
# print('Old flux:\n',old_FLUX)
FLUX = np.multiply(old_FLUX,hsign)
# print('original FLUX:\n',FLUX)
#========================================;
# Calculate element correction factors:
#========================================;
# container to store alphaEplus and alphaEminu
Vdg0 = FunctionSpace(self.mesh, "DG", 0)
V0 = Function(Vdg0)
# print(type(self.solMax))
deltaBound = 10*np.finfo(self.solMax).eps #Arithmetic perturbations may violate the bounds.
epsBound = np.finfo(self.solMax).eps
# print('delatabound',deltaBound)
area = V0.interpolate(CellVolume(self.mesh)).vector().array()
# print(area)
solAvgDG0_0 = V0.interpolate(self.sol_0).vector().array()
#==================;
# Start iteration ;
#==================;
maxIter = 10000
epsFLUX = 1e-6
epsDelta = 1e-6
solAvg = solAvgDG0_0 # limiter solution from last time step s0 on DG0 space
Corrector = np.ones((row,))
for numIter in range(maxIter):
# print('numIter of Flux-limiter',numIter)
# Save suppressed fluxes.
FLUX_0 = FLUX
alphaEplus= np.zeros((row,1))
# incompressible patch test
# Qplus = area*np.maximum(0, (0.2)*\
# np.subtract((self.solMax-deltaBound),solAvg))
# Qplus = (area *(0.2 * 1000)* np.maximum(0,np.subtract((self.solMax-deltaBound),solAvg)) )
# incompressible well problem
# Qplus = area*np.maximum(0, (0.2*1000)*\
# np.subtract((self.solMax-deltaBound),solAvg)-self.wells_avg*self.dt)
Qplus = area*np.maximum(0, (0.2)*\
np.subtract((self.solMax-deltaBound),solAvg)+\
Corrector * self.wells_update(solAvg)*self.dt)
# compressible patch test
# Qplus = area * np.maximum(0,np.subtract\
# ((self.rPAvg * self.solMax-deltaBound),self.rPAvg_0 * solAvg))
# print('Qplus:\n',Qplus)
assert (np.all(Qplus >= 0))\
,"Qplus is less than zero!"
Pplus = -1 *np.where(FLUX<0,FLUX,0).sum(axis=1) * self.dt + epsBound
# print('Pplus:\n',Pplus)
alphaEplus = np.minimum(1,np.divide(Qplus,Pplus))
# print('alphaEplus at iteration %d:\n'%numIter,alphaEplus)
# if alphaEplus is 1 means that no limiting is needed. (100% of unlimited flux is allowed
# without introducing a mean-value overshoot); If alphaEplus is 0 this means that:
# means Qplus = 0 which means no mass is allowed to be stored in E without introducing
# mean-value overshoot.
# incompressible patch test
# Qminus = area *(np.minimum(0,(0.2)*\
# np.subtract((self.solMin+deltaBound),solAvg )))
#
# incompressible well problem
Qminus = area *(np.minimum(0,(0.2)*\
np.subtract((self.solMin+deltaBound),solAvg ) -\
Corrector * self.wells_update(solAvg)*self.dt) )
# compressible patch test
# Qminus = area * np.minimum(0,np.subtract\
# ((self.rPAvg * self.solMin+deltaBound),self.rPAvg_0 * solAvg ))
#
# Qminus = (area * np.subtract(solAvg,(self.solMin-deltaBound) ) )
# Qminus = (area * np.subtract(solAvg,(self.solMin) ) )
# assert (np.all(Qminus >= 0))\
# ,"Qminus is less than zero!"
assert (np.all(Qminus <= 0))\
,"Qminus is greater than zero!"
# Qminus = (area * np.subtract(solAvg,(self.solMin+deltaBound)) )
# print('Qminus:\n',Qminus)
# Pminus = 1 *np.where(FLUX>0,FLUX,0).sum(axis=1) * self.dt + epsBound
Pminus = -1 *np.where(FLUX>0,FLUX,0).sum(axis=1) * self.dt - epsBound
# print('Pminus:\n',Pminus)
alphaEminus = np.minimum(1,np.divide(Qminus,Pminus))
# print('alphaEminus at iteration %d:\n' %numIter,alphaEminus)
# alphaEminus shows the percentage of howmuch of mass (Pminus) is allowd to exit element E
# if alphaEminus = 1 no limiting is needed. and alphaEminus = 0
# it means that no mass is allowed to exit and hence 100% of flux should be limited.
# np.savetxt('Qminus.out',Qminus)
#============================================;
# Compute edge correction factors alpha_E,E' :
#============================================;
# met1_Start = tm.time()
alphaEface = np.ones((row,col))
for irow in range(row):
for icol in range(col):
facet = cell_map[irow,icol]
# Handling boundary terms
if facet in boundary_facet:
if FLUX[irow,icol] < 0:
alphaEface[irow,icol] = alphaEplus[irow]
elif FLUX[irow,icol] > 0:
alphaEface[irow,icol] = alphaEminus[irow]
# Handling interior edges
else:
if FLUX[irow,icol] < 0:
b0 = TwoCell[facet] # cellID of irow and the opposite cell
oppCell_ID = int(b0[np.where( b0 != irow )]) # includes only oppoiste cell ID
alphaEface[irow,icol] = np.minimum(alphaEplus[irow] , alphaEminus[oppCell_ID])
elif FLUX[irow,icol] > 0:
b0 = TwoCell[facet] # cellID of irow and the opposite cell
oppCell_ID = int(b0[np.where( b0 != irow )]) # includes only oppoiste cell ID
alphaEface[irow,icol] = np.minimum(alphaEminus[irow] , alphaEplus[oppCell_ID])
# met1_End = tm.time()
# print('alphaEface at numIter %d:\n'%numIter,alphaEface,type(alphaEface))
# met2_Start = tm.time()
# # use list comprehension in python which is very fast
# alphaEface_fast=[alphaEplus[irow]*np.where(FLUX[irow,icol]<0,1,0) +
# alphaEminus[irow]*np.where(FLUX[irow,icol]>0,1,0)
# if cell_map[irow,icol] in boundary_facet
# else np.minimum(alphaEplus[irow] ,
# alphaEminus[ int(TwoCell[cell_map[irow,icol]][np.where( TwoCell[cell_map[irow,icol]] != irow )]) ])
# *np.where(FLUX[irow,icol]<0,1,0) + np.minimum(alphaEminus[irow] ,
# alphaEplus[ int(TwoCell[cell_map[irow,icol]][np.where( TwoCell[cell_map[irow,icol]] != irow )]) ])
# *np.where(FLUX[irow,icol]>0,1,0)
# for irow in range(row)
# for icol in range(col)
# ]
# alphaEface_fast = np.asarray(alphaEface_fast).reshape((row,col))
# met2_End = tm.time()
# print('alphaEface_fast:\n',alphaEface_fast,type(alphaEface_fast))
# # print('For-loop took: %f and comprehension took: %f'%(met1_End-met1_Start,met2_End-met2_Start))
# # Comment: loop-comprehension(even withour asarray conversion and reshaping)
# # for some reason takes more time than for-loop!
#
# Verify that all correction factors are within [0,1].
assert (np.all((alphaEface <= 1 ) & (alphaEface >= 0) ) )\
,"alphaEface are not between 0 and 1!"
#=========================================;
# Compute the updated solution and fluxes ;
#=========================================;
# Incompressible patch test
# solAvg = solAvg - self.dt/area * \
# (1./(0.2))* np.multiply(alphaEface,FLUX).sum(axis=1)
# solAvg = solAvg - self.dt/area * \
# (1./(0.2*1000))* np.multiply(alphaEface,FLUX).sum(axis=1)
# incompressible well problem
# solAvg = solAvg - self.dt/area * \
# (1./(0.2*1000))* np.multiply(alphaEface,FLUX).sum(axis=1) + \
# self.dt * (1./(0.2*1000)) * self.wells_avg
solAvg = solAvg - self.dt/area * \
(1./(0.2))* np.multiply(alphaEface,FLUX).sum(axis=1) + \
Corrector * self.dt * (1./(0.2)) * self.wells_update(solAvg)
# compressible patch test
# solAvg = (self.rPAvg_0/self.rPAvg) * solAvg - self.dt/area * \
# (1./self.rPAvg)* np.multiply(alphaEface,FLUX).sum(axis=1)
# print("rpAvg_0/rPAvg\n",self.rPAvg_0/self.rPAvg)
# solAvg = solAvg - self.dt/area * \
# (1./self.rPAvg)* np.multiply(alphaEface,FLUX).sum(axis=1)
# solAvg = solAvg - self.dt/area * \
# (1./self.rPAvg_0)* np.multiply(alphaEface,FLUX).sum(axis=1)
# print('alphaEface',alphaEface[150])
# last one seems to work the better than others
# print('solAvgUpdated at iteration %d is:\n'%numIter,solAvg)
# print(alphaEface*FLUX)
FLUX = FLUX * np.subtract(1.,alphaEface)
Corrector = Corrector * 0.
#=========================;
# Check stopping criteria ;
#=========================;
# Compute new errors:
# Criterion 1
# method 1(the maximum absolute row sum)
# normFLUX = np.linalg.norm(FLUX,np.inf)
# print('normFLUX',normFLUX)
#
#method 2
normFLUX = np.abs(FLUX).max()
# print('normFLUX',normFLUX)
# Criterion 2
# method 1
# normDelta = np.linalg.norm(np.subtract(FLUX_0,FLUX),np.inf)
# method 2
normDelta = np.abs(np.subtract(FLUX_0,FLUX)).max()
# print('normDelta',normDelta)
# Check stopping criteria.
# if (normFLUX < epsFLUX)|(normDelta < epsDelta) :
# if (normFLUX < epsFLUX)&(normDelta < epsDelta) :
if normFLUX < epsFLUX :
flag = 0
break
elif normDelta < epsDelta:
flag = 1;
break
elif numIter == maxIter:
flag = 2;
break
# print('Flux-limiter converged in %d iterations'%numIter)
# print('normFLUX',normFLUX)
# print('normDelta',normDelta)
# print('Exit flag is:', flag)
#==================================;
# Compute new reconstructed values ;
#==================================;
V = self.sol.function_space()
sol_value = self.sol.vector().array()
# print('sol_value_old:\n',sol_value)
solPost = solAvg
solAvgDG_current = V0.interpolate(self.sol).vector().array() # unlimited solution current step
# print('sol_value current time (not limited)',solAvgDG_current)
Diff = solPost-solAvgDG_current
# print('solPost - solAvgDG_current:\n',Diff)
sol_cell_map = V.cell_node_map().values
# print('sol_cell_map',sol_cell_map)
row , col = | np.shape(sol_cell_map) | numpy.shape |
import numpy as np
from numba import jit
@jit(nopython=True)
def find_near_tile(state, x, y, d):
if d == 0: # UP
for i in range(x-1, -1, -1):
if state[i][y] != 0:
return state[i][y]
if d == 1: # DOWN
for i in range(x+1, 4):
if state[i][y] != 0:
return state[i][y]
if d == 2: # RIGHT
for i in range(y+1, 4):
if state[x][i] != 0:
return state[x][i]
if d == 3: # UP
for i in range(y-1, -1, -1):
if state[x][i] != 0:
return state[x][i]
return 0
@jit(nopython=True)
def smoothness(state):
s = 0.
height, width = state.shape
for i in range(height):
for j in range(width):
a = state[i][j]
if a == 0:
continue
for d in range(4):
b = find_near_tile(state, i, j, d)
s -= np.abs(np.log2(a + 0.1) - np.log2(b + 0.1))
return s
@jit(nopython=True)
def tonicity(state):
t = 0
a, b = 0, 0
height, width = state.shape
for i in range(height):
for j in range(width):
if state[i, j] == 0:
continue
c = state[i, j]
n = find_near_tile(state, i, j, 2) # RIGHT
if n != 0:
if c > n:
a += np.log2(c + 0.1) - np.log2(n + 0.1)
if n > c:
b += np.log2(n + 0.1) - np.log2(c + 0.1)
# t += max(a, b)
t += np.abs(a - b)
a, b = 0, 0
for j in range(width):
for i in range(height):
if state[i, j] == 0:
continue
c = state[i, j]
n = find_near_tile(state, i, j, 1) # DOWN
if n != 0:
if c > n:
a += np.log2(c + 0.1) - np.log2(n + 0.1)
if n > c:
b += np.log2(n + 0.1) - np.log2(c + 0.1)
# t += max(a, b)
t += np.abs(a - b)
return t
def avg_dis(state):
def dis(a, b):
return np.abs(a[0] - b[0]) + np.abs(a[1] - b[1])
s = {}
d = 0.
height, width = state.shape
tiles = | np.unique(state) | numpy.unique |
# -*- coding: utf-8 -*-
"""
Generate character embeddings
Created on 2020/5/30
"""
__author__ = "<NAME>"
import itertools
import json
import pickle
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from model import CharEmbedding
WORD_EMBEDDING_DIM = 48
CHAR_EMBEDDING_DIM = WORD_EMBEDDING_DIM
with open('config.json', 'r') as fin:
args = json.loads(fin.read())
with open(args['dataset_path'], 'rb') as fin:
dataset = pickle.load(fin)
with open(args['lookup_path'], 'rb') as fin:
lookup = pickle.load(fin)
word_embeddings = np.load(args['embed_word_path']) # (vocab_size, embedding_dim)
vocabs = list(lookup['word2idx'].keys()) # list of unique vocabularies
token2index_lookup = lookup['word2idx']
distinct_chars = sorted(list(set(itertools.chain.from_iterable(vocabs))))
num_chars = len(distinct_chars) # 60
char2index_lookup = {c: i for i, c in enumerate(distinct_chars)}
vocab_lens = list(map(len, vocabs))
# from collections import Counter
# vocab_len_ctr = Counter(vocab_lens)
#
# import matplotlib.pyplot as plt
# fig, ax = plt.subplots()
# ax.bar(vocab_len_ctr.keys(), vocab_len_ctr.values())
#
# ax.set_xlabel('length of word')
# ax.set_ylabel('count')
# ax.legend()
# plt.show()
allowed_max_vocab_len = 15 # Set allowed maximum vocabulary length
vocab_groups = [[] for _ in range(allowed_max_vocab_len)]
for vocab in vocabs:
length = len(vocab)
if length <= allowed_max_vocab_len:
vocab_groups[length - 1].append(vocab)
def gen_batch(vocab_groups, char2index_lookup, token2index_lookup, word_embeddings, batch_size, shuffle=True):
"""Generate ranodm batches of words from different word groups (identified by different lengths of words)
Args:
vocab_groups (list[list[str]]): groups of words. Words in each group have same length
char2index_lookup (dict): map a character to an integer index
token2index_lookup (dict): map a word(token) to an integer index
word_embeddings (numpy.ndarray): word embedding matrix with shape (vocab_size, embedding_size)
batch_size (int):
shuffle (bool):
Returns:
(generator) with shape [(B, VAR_word_len), (B, embedding_size)]
Notes:
Make the vocabularies in each batch have same character-length, then no need for padding
Each iteration, a tuple composed of "character indices of batch-of-words" and "embedding of batch-of-words" will be return.
Note that the group is selected randomly, so the length of "character indices" is variable.
"""
num_groups = len(vocab_groups) # number of differect word groups
num_samps = [len(group) for group in vocab_groups] # number of words in each word group
# Make indices to get word from different groups
indices = []
for i in range(num_groups):
inds = [i for i in range(num_samps[i])]
if shuffle:
| np.random.shuffle(inds) | numpy.random.shuffle |
'''-------------------------------------------------------------------------------
Tool Name: CreateDischargeMap
Source Name: CreateDischargeMap.py
Version: ArcGIS 10.2
License: Apache 2.0
Author: Environmental Systems Research Institute Inc.
Updated by: Environmental Systems Research Institute Inc.
Description: Create a dischage map document.
History: Initial coding - 05/8/2015, version 1.0
Updated: Version 1.0, 06/02/2015, rename the default template layer file names
from FGDB_TimeEnabled_5NaturalBreaks.lyr and SQL_TimeEnabled_5NaturalBreaks.lyr
to FGDB_TimeEnabled.lyr and SQL_TimeEnabled.lyr
Version 1.1, 06/24/2015, add all layers into a group layer named as "AllScales",
which is specified in the template .mxd
Version 1.1, 04/01/2016, deleted unnecessary line of import netCDF4
-------------------------------------------------------------------------------'''
import os
import arcpy
import numpy as NUM
import time
class CreateDischargeMap(object):
def __init__(self):
"""Define the tool (tool name is the name of the class)."""
self.label = "Create Discharge Map"
self.description = "Create a discharge map document for stream flow visualization based on \
the discharge table and the drainage line feature class"
self.name_ID = "COMID"
self.GDBtemplate_layer = os.path.join(os.path.dirname(__file__), "templates", "FGDB_TimeEnabled.lyr")
self.SQLtemplate_layer = os.path.join(os.path.dirname(__file__), "templates", "SQL_TimeEnabled.lyr")
self.template_mxd = os.path.join(os.path.dirname(__file__), "templates", "template_mxd.mxd")
self.name_df = "DischargeMap"
self.field_streamOrder = "StreamOrde"
self.layer_minScale_maxScale_query = {"All": [None, None, None]}
self.canRunInBackground = False
self.category = "Postprocessing"
def copyFlowlines(self, in_drainage_line, path_database, list_uniqueID):
"""Create copies of flowlines based on the layer query definitions"""
# make a feature layer for query selection
name_lyr = "flowlines"
arcpy.MakeFeatureLayer_management(in_drainage_line, name_lyr)
'''Create the query expression for line features with matching records in the flat table'''
expression_base = self.name_ID + " IN ("
count = len(list_uniqueID)
counter = 1
for each_ID in list_uniqueID:
if counter == count:
expression_base = expression_base + str(each_ID) + ")"
else:
expression_base = expression_base + str(each_ID) + ", "
counter += 1
for each_key in self.layer_minScale_maxScale_query.keys():
out_copy = os.path.join(path_database, "Flowline_"+each_key)
pars = self.layer_minScale_maxScale_query[each_key]
query = pars[2]
expression = expression_base
if query is not None:
expression = expression_base + "AND " + query
arcpy.SelectLayerByAttribute_management(name_lyr, "NEW_SELECTION", expression)
arcpy.CopyFeatures_management(name_lyr, out_copy)
arcpy.AddIndex_management(out_copy, self.name_ID, self.name_ID, "UNIQUE", "ASCENDING")
return
def getParameterInfo(self):
"""Define parameter definitions"""
param0 = arcpy.Parameter(name = "in_drainage_line",
displayName = "Input Drainage Line Features",
direction = "Input",
parameterType = "Required",
datatype = "GPFeatureLayer")
param1 = arcpy.Parameter(name = "in_discharge_table",
displayName = "Input Discharge Table",
direction = "Input",
parameterType = "Required",
datatype = "DETable")
param2 = arcpy.Parameter(name = "out_discharge_map",
displayName = "Output Discharge Map",
direction = "Output",
parameterType = "Required",
datatype = "DEMapDocument"
)
param3 = arcpy.Parameter(name = "in_unique_ID_table",
displayName = "Input Unique ID Table",
direction = "Input",
parameterType = "Optional",
datatype = "DETable")
param4 = arcpy.Parameter(name = "in_layer_info",
displayName = "Input Layer Information",
direction = "Input",
parameterType = "Optional",
datatype = "GPValueTable")
param4.columns = [['String', 'Layer Name'], ['Long', 'Minimum Scale'], ['Long', 'Maximum Scale'], ['Long', 'Minimum Stream Order']]
params = [param0, param1, param2, param3, param4]
return params
def isLicensed(self):
"""Set whether tool is licensed to execute."""
return True
def updateParameters(self, parameters):
"""Modify the values and properties of parameters before internal
validation is performed. This method is called whenever a parameter
has been changed."""
'''Add .mxd suffix to the output map document name'''
if parameters[2].altered:
(dirnm, basenm) = os.path.split(parameters[2].valueAsText)
if not basenm.endswith(".mxd"):
parameters[2].value = os.path.join(dirnm, "{}.mxd".format(basenm))
return
def updateMessages(self, parameters):
"""Modify the messages created by internal validation for each tool
parameter. This method is called after internal validation."""
return
def execute(self, parameters, messages):
"""The source code of the tool."""
arcpy.env.overwriteOutput = True
in_drainage_line = parameters[0].valueAsText
in_flat_table = parameters[1].valueAsText
out_map_document = parameters[2].valueAsText
in_uniqueID_table = parameters[3].valueAsText
in_layer_info = parameters[4].value
''' Obtain a list of unique IDs '''
list_uniqueID = []
if in_uniqueID_table is not None:
arr_uniqueID = arcpy.da.TableToNumPyArray(in_uniqueID_table, self.name_ID)
arr_uniqueID = arr_uniqueID[self.name_ID]
list_uniqueID = list(arr_uniqueID)
else:
arr_ID = arcpy.da.TableToNumPyArray(in_flat_table, self.name_ID)
arr_ID = arr_ID[self.name_ID]
list_uniqueID = list( | NUM.unique(arr_ID) | numpy.unique |
import numpy as np
from scipy.stats.distributions import norm, lognorm, rv_frozen
from math import sqrt
from scipy.sparse import spdiags
class BrownianMotion:
def __init__(self):
pass
def simulate(self, x0: np.array, n: int, dt: float, mu: float, sigma: float, out=None):
"""
Generate an instance of Brownian motion (i.e. the Wiener process):
X(t) = X(0) + N(mu, sigma**2 * t; 0, t)
where N(a,b; t0, t1) is a normally distributed random variable with mean a and
variance b. The parameters t0 and t1 make explicit the statistical
independence of N on different time intervals; that is, if [t0, t1) and
[t2, t3) are disjoint intervals, then N(a, b; t0, t1) and N(a, b; t2, t3)
are independent.
Written as an iteration scheme,
X(t + dt) = X(t) + N(mu, sigma**2 * dt; t, t+dt)
If `x0` is an array (or array-like), each value in `x0` is treated as
an initial condition, and the value returned is a numpy array with one
more dimension than `x0`.
Arguments
---------
x0 : float or numpy array (or something that can be converted to a numpy array
using numpy.asarray(x0)).
The initial condition(s) (i.e. position(s)) of the Brownian motion.
n : int
The number of steps to take.
dt : float
The time step.
sigma: float
delta determines the "speed" of the Brownian motion. The random variable
of the position at time t, X(t), has a normal distribution whose mean is
the position at time t=0 and whose variance is delta**2*t.
out : numpy array or None
If `out` is not None, it specifies the array in which to put the
result. If `out` is None, a new numpy array is created and returned.
Returns
-------
A numpy array of floats with shape `x0.shape + (n,)`.
"""
x0 = np.asarray(x0)
# For each element of x0, generate a sample of n numbers from a
# normal distribution.
r = norm.rvs(size=x0.shape + (n,), scale=sigma * sqrt(dt))
# If `out` was not given, create an output array.
if out is None:
out = np.empty(r.shape)
# This computes the Brownian motion by forming the cumulative sum of
# the random samples.
np.cumsum(r, axis=-1, out=out)
# Add the initial condition.
out += np.expand_dims(x0, axis=-1)
return out
class FractionalBrownianMotion:
def __init__(self, n, hurst, length):
self.n = n
self.hurst = hurst
self.length = length
def autocovariance(self, k):
"""Autocovariance for fgn."""
return 0.5 * (np.abs(k - 1) ** (2 * self.hurst) - 2 * np.abs(k) ** (2 * self.hurst) + np.abs(k + 1) ** (2 * self.hurst))
def simulate(self):
"""Generate a fgn realization using the Cholesky method.
Uses Cholesky decomposition method (exact method) from:
<NAME>. (1998). Stochastic simulation with a view towards
stochastic processes. University of Aarhus. Centre for Mathematical
Physics and Stochastics (MaPhySto)[MPS].
"""
# create Gaussian Noise
scale = (1.0 * self.length / self.n) ** self.hurst
gn = np.random.normal(0.0, 1.0, self.n)
# If hurst == 1/2 then just return Gaussian noise
if self.hurst == 0.5:
return gn * scale
else:
# Monte carlo consideration
# Generate covariance matrix
g = []
offset = []
for i in range(self.n):
g.append(self.autocovariance(i)*np.ones(self.n))
offset.append(-i)
g = np.array(g)
offset = np.array(offset)
G = spdiags(g, offset, self.n, self.n).toarray()
"""G = np.zeros([self.n, self.n])
for i in range(self.n):
for j in range(i + 1):
G[i, j] = self.autocovariance(i - j)"""
# Cholesky decomposition
chol = np.linalg.cholesky(G)
# Generate fgn
fgn = np.dot(chol, | np.array(gn) | numpy.array |
# coding=utf-8
# MSC means Multiple Spectral Clustering
import numpy as np
import scipy as sp
import scipy.linalg as linalg
import networkx as nx
import matplotlib.pyplot as plt
def getNormLaplacian(W):
"""input matrix W=(w_ij)
"compute D=diag(d1,...dn)
"and L=D-W
"and Lbar=D^(-1/2)LD^(-1/2)
"return Lbar
"""
d = [np.sum(row) for row in W]
D = np.diag(d)
L = D - W
# Dn=D^(-1/2)
Dn = np.power(np.linalg.matrix_power(D, -1), 0.5)
Lbar = np.dot(np.dot(Dn, L), Dn)
return Lbar
def getKSmallestEigVec(Lbar, k):
"""input
"matrix Lbar and k
"return
"k smallest eigen values and their corresponding eigen vectors
"""
eigval, eigvec = linalg.eig(Lbar)
dim = len(eigval)
# 查找前k小的eigval
dictEigval = dict(zip(eigval, range(0, dim)))
kEig = | np.sort(eigval) | numpy.sort |
import tempfile
import unittest
from pathlib import Path
from typing import List
from unittest.mock import patch
import docker
import numpy as np
import psutil
import pytest
from docker.models.containers import Container
from durations import Duration
from tests.fixtures.docker_mocks import MockDockerClient, TEST_DOCKER_IMAGE
from timeeval import ResourceConstraints
from timeeval.adapters import DockerAdapter
from timeeval.adapters.docker import (
DATASET_TARGET_PATH,
RESULTS_TARGET_PATH,
SCORES_FILE_NAME,
MODEL_FILE_NAME,
DockerTimeoutError,
DockerAlgorithmFailedError,
AlgorithmInterface
)
from timeeval.data_types import ExecutionType
class TestDockerAdapter(unittest.TestCase):
def test_algorithm_interface_with_numpy(self):
ai = AlgorithmInterface(
dataInput=Path("in.csv"),
dataOutput=Path("out.csv"),
modelInput=Path("model-in.csv"),
modelOutput=Path("model-out.csv"),
executionType=ExecutionType.TRAIN,
customParameters={
"bool": True,
"float": 1e-3,
"numpy": [np.int64(4), np.float64(2.3)],
"numpy-list": np.arange(2)
}
)
ai_string = ('{"dataInput": "in.csv", "dataOutput": "out.csv", "modelInput": "model-in.csv", '
'"modelOutput": "model-out.csv", "executionType": "train", "customParameters": '
'{"bool": true, "float": 0.001, "numpy": [4, 2.3], "numpy-list": [0, 1]}}')
self.assertEqual(ai.to_json_string(), ai_string)
@patch("timeeval.adapters.docker.docker.from_env")
def test_correct_json_string(self, mock_client):
mock_docker_client = MockDockerClient()
mock_client.return_value = mock_docker_client
results_path = Path("./results/")
input_string = 'execute-algorithm \'{' \
f'"dataInput": "{DATASET_TARGET_PATH}/test.csv", ' \
f'"dataOutput": "{RESULTS_TARGET_PATH}/{SCORES_FILE_NAME}", ' \
f'"modelInput": "{RESULTS_TARGET_PATH}/{MODEL_FILE_NAME}", ' \
f'"modelOutput": "{RESULTS_TARGET_PATH}/{MODEL_FILE_NAME}", ' \
'"executionType": "train", ' \
'"customParameters": {"a": 0}' \
'}\''
adapter = DockerAdapter("test-image")
adapter._run_container(Path("/tmp/test.csv"), {
"results_path": results_path,
"hyper_params": {"a": 0},
"executionType": ExecutionType.TRAIN
})
self.assertEqual(mock_docker_client.containers.cmd, input_string)
@patch("timeeval.adapters.docker.docker.from_env")
def test_results_at_correct_location(self, mock_client):
mock_docker_client = MockDockerClient()
mock_client.return_value = mock_docker_client
with tempfile.TemporaryDirectory() as tmp_path:
adapter = DockerAdapter("test-image")
result = adapter(Path("tests/example_data/data.txt"), {"results_path": Path(tmp_path)})
np.testing.assert_array_equal(result, | np.arange(10, dtype=np.float64) | numpy.arange |
from numpy import sqrt
from numpy import std
from numpy import arange
from limix_inference.link import LogitLink
from limix_inference.link import LogLink
from limix_inference.lik import BernoulliLik
from limix_inference.lik import BernoulliProdLik
from limix_inference.lik import BinomialProdLik
from limix_inference.lik import PoissonProdLik
from limix_inference.mean import OffsetMean
from limix_inference.mean import LinearMean
from limix_inference.mean import SumMean
from limix_inference.cov import LinearCov
from limix_inference.cov import SumCov
from limix_inference.cov import EyeCov
from .glmm import GLMMSampler
from ..tool.normalize import stdnorm
def bernoulli(offset, G, heritability=0.5, causal_variants=None,
causal_variance=0, random_state=None):
link = LogitLink()
mean, cov = _mean_cov(offset, G, heritability, causal_variants,
causal_variance, random_state)
lik = BernoulliProdLik(link)
sampler = GLMMSampler(lik, mean, cov)
return sampler.sample(random_state)
def binomial(ntrials,
offset,
G,
heritability=0.5,
causal_variants=None,
causal_variance=0,
random_state=None):
link = LogitLink()
mean, cov = _mean_cov(offset, G, heritability, causal_variants,
causal_variance, random_state)
lik = BinomialProdLik(ntrials, link)
sampler = GLMMSampler(lik, mean, cov)
return sampler.sample(random_state)
def poisson(offset, G, heritability=0.5, causal_variants=None,
causal_variance=0, random_state=None):
mean, cov = _mean_cov(offset, G, heritability, causal_variants,
causal_variance, random_state)
link = LogLink()
lik = PoissonProdLik(link)
sampler = GLMMSampler(lik, mean, cov)
return sampler.sample(random_state)
def _causal_mean(causal_variants, causal_variance, random):
causal_variants = stdnorm(causal_variants, axis=0)
causal_variants /= | sqrt(causal_variants.shape[1]) | numpy.sqrt |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Class of variatonal Gaussian Mixture Image models.
It serves as a baseline for a hidden Potts-MRF for Bayesian unsupervised image
segmentation.
Author: <NAME>
Date: 29-11-2018
"""
import numpy as np
import numpy.random as rnd
from numpy.linalg import inv, cholesky
from scipy.misc import logsumexp
from scipy.special import betaln, digamma, gammaln
from scipy.spatial.distance import cdist
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
from vis import plot_posteriors
class VariationalMixture(object):
"""
Superclass of variational mixture models.
Methods are functions common to all submixture models.
"""
def log_multivariate_gamma(self, n, p):
"""
Logarithmic multivariate gamma function.
This function is necessary for expectations and partition functions of
Wishart distributions. See also:
https://en.wikipedia.org/wiki/Multivariate_gamma_function
Parameters
----------
nu : float
Degrees of freedom.
p : int
Dimensionality.
Returns
-------
Gp : float
p-th order multivariate gamma function.
"""
# Check for appropriate degree of freedom
if not n > (p-1):
raise ValueError('Degrees of freedom too low for dimensionality.')
# Preallocate
Gp = 0
# Product from d=1 to p
for d in range(1, p+1):
# Gamma function of degrees of freedom and dimension
Gp += gammaln((n + 1 - d)/2)
return (p * (p-1) / 4)*np.log(np.pi) + Gp
def multivariate_digamma(self, n, p):
"""
Multivariate digamma function.
This function is necessary for expectations and partition functions of
Wishart distributions. See also:
https://en.wikipedia.org/wiki/Multivariate_gamma_function
Parameters
----------
nu : float
Degrees of freedom.
p : int
Dimensionality.
Returns
-------
Pp : float
p-th order multivariate digamma function.
"""
# Check for appropriate degree of freedom
if not n > (p-1):
raise ValueError('Degrees of freedom too low for dimensionality.')
# Preallocate
Pp = 0
# Sum from d=1 to D
for d in range(1, p+1):
# Digamma function of degrees of freedom and dimension
Pp += digamma((n + 1 - d)/2)
return Pp
def log_partition_Wishart(self, W, n):
"""
Logarithmic partition function of the Wishart distribution.
To compute variational expectations, the partition of the Wishart
distribution is sometimes needed. The current computation follows
Appendix B, equations B.78 to B.82 from Bishop's "Pattern Recognition &
Machine Learning."
Parameters
----------
W : array
Positive definite, symmetric precision matrix.
nu : int
Degrees of freedom.
Returns
-------
B : float
Partition of Wishart distribution.
"""
# Extract dimensionality
D, D_ = W.shape
# Check for symmetric matrix
if not D == D_:
raise ValueError('Matrix is not symmetric.')
# Check for appropriate degree of freedom
if not n > D-1:
raise ValueError('Degrees of freedom too low for dimensionality.')
# Compute log-multivariate gamma
lmG = self.log_multivariate_gamma(n, D)
# Compute partition function
B = (-n/2)*self.log_det(W) - (n*D/2)*np.log(2) - lmG
return B
def entropy_Wishart(self, W, n):
"""
Entropy of the Wishart distribution.
To compute variational expectations, the entropy of the Wishart
distribution is sometimes needed. The current computation follows
Appendix B, equations B.78 to B.82 from Bishop's "Pattern Recognition &
Machine Learning."
Parameters
----------
W : array
Positive definite, symmetric precision matrix.
nu : int
Degrees of freedom.
Returns
-------
H : float
Entropy of Wishart distribution.
"""
# Extract dimensionality
D, D_ = W.shape
# Check for symmetric matrix
if not D == D_:
raise ValueError('Matrix is not symmetric.')
# Check for appropriate degree of freedom
if not n > D-1:
raise ValueError('Degrees of freedom too low for dimensionality.')
# Expected log-determinant of precision matrix
E = self.multivariate_digamma(n, D) + D*np.log(2) + self.log_det(W)
# Entropy
H = -self.log_partition_Wishart(W, n) - (n - D - 1)/2 * E + n*D/2
return H
def log_det(self, A):
"""
Numerically stable computation of log determinant of a matrix.
Parameters
----------
A : array
Expecting a positive definite, symmetric matrix.
Returns
-------
float
Log-determinant of given matrix.
"""
# Perform cholesky decomposition
L = cholesky(A)
# Stable log-determinant
return np.sum(2*np.log(np.diag(L)))
def distW(self, X, S):
"""
Compute weighted distance.
Parameters
----------
X : array
Vectors (N by D) or (H by W by D).
W : array
Weights (D by D).
Returns
-------
array
Weighted distance for each vector.
"""
if not S.shape[0] == S.shape[1]:
raise ValueError('Weight matrix not symmetric.')
if not X.shape[-1] == S.shape[0]:
raise ValueError('Dimensionality of data and weights mismatch.')
if len(X.shape) == 2:
# Shapes
N, D = X.shape
# Preallocate
A = np.zeros((N,))
# Loop over samples
for n in range(N):
# Compute weighted inner product between vectors
A[n] = X[n, :] @ S @ X[n, :].T
elif len(X.shape) == 3:
# Shape
H, W, D = X.shape
# Preallocate
A = np.zeros((H, W))
# Loop over samples
for h in range(H):
for w in range(W):
# Compute weighted inner product between vectors
A[h, w] = X[h, w, :] @ S @ X[h, w, :].T
return A
def one_hot(self, A):
"""
Map array to pages with binary encodings.
Parameters
----------
A : array
2-dimensional array of integers
Returns
-------
B : array (height by width by number of unique integers in A)
3-dimensional array with each page as an indicator of value in A.
"""
# Unique values
labels = np.unique(A)
# Preallocate new array
B = np.zeros((*A.shape, len(labels)))
# Loop over unique values
for i, label in enumerate(labels):
B[:, :, i] = (A == label)
return B
class UnsupervisedGaussianMixture(VariationalMixture):
"""
Variational Gaussian Mixture Image model.
This implementation multivariate images (height by width by channel).
It is based on the RPubs note by <NAME>:
https://rpubs.com/cakapourani/variational-bayes-gmm
"""
def __init__(self, num_channels=1,
num_components=2,
init_params='nn',
max_iter=10,
tol=1e-5):
"""
Model-specific constructors.
Parameters
----------
num_channels : int
Number of channels of image (def: 1).
num_components : int
Number of components (def: 2).
theta0 : tuple
Prior hyperparameters.
max_iter : int
Maximum number of iterations to run for (def: 10).
tol : float
Tolerance on change in x-value (def: 1e-5).
Returns
-------
None
"""
# Store data dimensionality
if num_channels >= 1:
self.D = num_channels
else:
raise ValueError('Number of channels must be larger than 0.')
# Store model parameters
if num_components >= 2:
self.K = num_components
else:
raise ValueError('Too few components specified')
# Optimization parameters
self.init_params = init_params
self.max_iter = max_iter
self.tol = tol
# Set prior hyperparameters
self.set_prior_hyperparameters(D=num_channels,
K=num_components)
def set_prior_hyperparameters(self, D, K,
a0=np.array([0.1]),
b0=np.array([0.1]),
n0=np.array([2.0]),
m0=np.array([0.0]),
W0=np.array([1.0])):
"""
Set hyperparameters of prior distributions.
Default prior hyperparameters are minimally informative symmetric
parameters.
Parameters
----------
D : int
Dimensionality of data.
K : int
Number of components.
a0 : float / array (components by None)
Hyperparameters of Dirichlet distribution on component weights.
b0 : float / array (components by None)
Scale parameters for hypermean normal distribution.
n0 : array (components by None)
Degrees of freedom for Wishart precision prior.
m0 : array (components by dimensions)
Hypermeans.
W0 : array (dimensions by dimensions by components)
Wishart precision parameters.
Returns
-------
theta : tuple
"""
# Expand alpha's if necessary
if not a0.shape[0] == K:
a0 = np.tile(a0[0], (K,))
# Expand beta's if necessary
if not b0.shape[0] == K:
b0 = np.tile(b0[0], (K,))
# Expand nu's if necessary
if not n0.shape[0] == K:
# Check for sufficient degrees of freedom
if n0[0] < D:
print('Cannot set Wishart degrees of freedom lower than data \
dimensionality.\n Setting it to data dim.')
n0 = np.tile(D, (K,))
else:
n0 = np.tile(n0[0], (K,))
# Expand hypermeans if necessary
if not np.all(m0.shape == (K, D)):
# If mean vector given, replicate to each component
if len(m0.shape) == 2:
if m0.shape[1] == D:
m0 = np.tile(m0, (K, 1))
else:
m0 = np.tile(m0[0], (K, D))
# Expand hypermeans if necessary
if not | np.all(W0.shape == (D, D, K)) | numpy.all |
import numpy as np
import os.path as path
from os import listdir
from trainingFunctions import *
from merlFunctions import *
from coordinateFunctions import *
MERLDir = "MERLDir/"
OutputDir = "data/"
#Parse filenames
materials = [brdfFile for i,brdfFile in enumerate(listdir(MERLDir)) \
if (path.isfile(MERLDir+brdfFile)
and path.splitext(brdfFile)[1] == ".binary")]
#Fill observation array
obs = np.zeros((90*90*180, 3*len(materials)),'float32')
#Add each color channel as a single observation
for i in range(0,len(materials)):
mat = readMERLBRDF("%s/%s"%(MERLDir,materials[i]))
obs[:,3*i] = np.reshape(mat[:,:,:,0],(-1))
obs[:,3*i+1] = np.reshape(mat[:,:,:,1],(-1))
obs[:,3*i+2] = np.reshape(mat[:,:,:,2],(-1))
#Pre-compute maskMap (VERY SLOW if horizonCheck=True)
maskMap = ComputeMaskMap(obs, horizonCheck=False)
#Pre-compute cosine-map (VERY SLOW! - do once and store, or download!)
cosMap = ComputeCosMap(maskMap)
#Perform PCA on data
(scaledPCs,relativeOffset,median) = LearnMapping(obs,maskMap,cosMap)
#Save data
np.save('%s/MaskMap'%OutputDir,maskMap)
np.save('%s/CosineMap'%OutputDir,cosMap)
| np.save('%s/ScaledEigenvectors'%OutputDir,scaledPCs) | numpy.save |
"""
Feature extraction
"""
# Author: <NAME> <<EMAIL>>
#
# License: Apache, Version 2.0
import numpy as np
from sklearn.base import BaseEstimator
from sklearn.metrics import adjusted_mutual_info_score
from scipy.special import psi
from scipy.stats.stats import pearsonr
from scipy.stats import skew, kurtosis
from collections import Counter, defaultdict
from multiprocessing import Pool
import pandas as pd
import operator
from .hsic import FastHsicTestGamma
import math
BINARY = "Binary"
CATEGORICAL = "Categorical"
NUMERICAL = "Numerical"
class FeatureMapper:
def __init__(self, features):
self.features = features
def fit(self, X, y=None):
for feature_name in self.features:
extractor.fit(X[feature_name].values[:, np.newaxis], y)
def transform(self, X):
return X[self.features].values
def fit_transform(self, X, y=None):
return self.transform(X)
def weighted_mean_and_std(values, weights):
"""
Returns the weighted average and standard deviation.
values, weights -- numpy ndarrays with the same shape.
"""
average = np.average(values, weights=weights, axis=0)
variance = np.dot(weights, (values - average) ** 2) / weights.sum() # Fast and numerically precise
return (average, np.sqrt(variance))
def count_unique(x):
try:
return len(set(x))
except TypeError:
return len(set(x.flat))
def count_unique_ratio(x):
try:
return len(set(x)) / float(len(x))
except TypeError:
return len(set(x.flat))/float(len(x))
def binary(tp):
assert type(tp) is str
return tp == BINARY
def categorical(tp):
assert type(tp) is str
return tp == CATEGORICAL
def numerical(tp):
assert type(tp) is str
return tp == NUMERICAL
def binary_entropy(p, base):
assert p <= 1 and p >= 0
h = -(p * np.log(p) + (1 - p) * np.log(1 - p)) if (p != 0) and (p != 1) else 0
return h / np.log(base)
def discrete_probability(x, tx, ffactor, maxdev):
x = discretized_sequence(x, tx, ffactor, maxdev)
try:
return Counter(x)
except TypeError as e:
return Counter( | np.array(x) | numpy.array |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Script to compute all of the Diffusion Tensor Imaging (DTI) metrics.
By default, will output all available metrics, using default names. Specific
names can be specified using the metrics flags that are listed in the "Metrics
files flags" section.
If --not_all is set, only the metrics specified explicitly by the flags
will be output. The available metrics are:
fractional anisotropy (FA), geodesic anisotropy (GA), axial diffusivisty (AD),
radial diffusivity (RD), mean diffusivity (MD), mode, red-green-blue colored
FA (rgb), principal tensor e-vector and tensor coefficients (dxx, dxy, dxz,
dyy, dyz, dzz).
For all the quality control metrics such as residual, physically implausible
signals, pulsation and misalignment artifacts, see
[<NAME>, <NAME>, <NAME>. Diffusion Tensor Imaging and Beyond.
MRM 2011].
"""
from __future__ import division, print_function
from builtins import range
import argparse
import logging
import matplotlib.pyplot as plt
import nibabel as nib
import numpy as np
from dipy.core.gradients import gradient_table
import dipy.denoise.noise_estimate as ne
from dipy.io.gradients import read_bvals_bvecs
from dipy.reconst.dti import (TensorModel, color_fa, fractional_anisotropy,
geodesic_anisotropy, mean_diffusivity,
axial_diffusivity, norm,
radial_diffusivity, lower_triangular)
# Aliased to avoid clashes with images called mode.
from dipy.reconst.dti import mode as dipy_mode
from scilpy.io.utils import (add_overwrite_arg, assert_inputs_exist,
assert_outputs_exist, add_force_b0_arg)
from scilpy.utils.bvec_bval_tools import (normalize_bvecs, is_normalized_bvecs,
check_b0_threshold)
from scilpy.utils.filenames import add_filename_suffix, split_name_with_nii
logger = logging.getLogger("Compute_DTI_Metrics")
logger.setLevel(logging.INFO)
def _get_min_nonzero_signal(data):
return np.min(data[data > 0])
def _build_args_parser():
p = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawTextHelpFormatter)
p.add_argument('input',
help='Path of the input diffusion volume.')
p.add_argument('bvals',
help='Path of the bvals file, in FSL format.')
p.add_argument('bvecs',
help='Path of the bvecs file, in FSL format.')
add_overwrite_arg(p)
p.add_argument(
'--mask',
help='Path to a binary mask.\nOnly data inside the mask will be used '
'for computations and reconstruction. (Default: None)')
p.add_argument(
'--method', dest='method', metavar='method_name', default='WLS',
choices=['WLS', 'LS', 'NLLS', 'restore'],
help='Tensor fit method.\nWLS for weighted least squares' +
'\nLS for ordinary least squares' +
'\nNLLS for non-linear least-squares' +
'\nrestore for RESTORE robust tensor fitting. (Default: WLS)')
p.add_argument(
'--not_all', action='store_true', dest='not_all',
help='If set, will only save the metrics explicitly specified using '
'the other metrics flags. (Default: not set).')
g = p.add_argument_group(title='Metrics files flags')
g.add_argument('--ad', dest='ad', metavar='file', default='',
help='Output filename for the axial diffusivity.')
g.add_argument(
'--evecs', dest='evecs', metavar='file', default='',
help='Output filename for the eigenvectors of the tensor.')
g.add_argument(
'--evals', dest='evals', metavar='file', default='',
help='Output filename for the eigenvalues of the tensor.')
g.add_argument(
'--fa', dest='fa', metavar='file', default='',
help='Output filename for the fractional anisotropy.')
g.add_argument(
'--ga', dest='ga', metavar='file', default='',
help='Output filename for the geodesic anisotropy.')
g.add_argument(
'--md', dest='md', metavar='file', default='',
help='Output filename for the mean diffusivity.')
g.add_argument(
'--mode', dest='mode', metavar='file', default='',
help='Output filename for the mode.')
g.add_argument(
'--norm', dest='norm', metavar='file', default='',
help='Output filename for the tensor norm.')
g.add_argument(
'--rgb', dest='rgb', metavar='file', default='',
help='Output filename for the colored fractional anisotropy.')
g.add_argument(
'--rd', dest='rd', metavar='file', default='',
help='Output filename for the radial diffusivity.')
g.add_argument(
'--tensor', dest='tensor', metavar='file', default='',
help='Output filename for the tensor coefficients.')
g = p.add_argument_group(title='Quality control files flags')
g.add_argument(
'--non-physical', dest='p_i_signal', metavar='file', default='',
help='Output filename for the voxels with physically implausible '
'signals \nwhere the mean of b=0 images is below one or more '
'diffusion-weighted images.')
g.add_argument(
'--pulsation', dest='pulsation', metavar='string', default='',
help='Standard deviation map across all diffusion-weighted images '
'and across b=0 images if more than one is available.\nShows '
'pulsation and misalignment artifacts.')
g.add_argument(
'--residual', dest='residual', metavar='file', default='',
help='Output filename for the map of the residual of the tensor fit.')
add_force_b0_arg(p)
return p
def main():
parser = _build_args_parser()
args = parser.parse_args()
if not args.not_all:
args.fa = args.fa or 'fa.nii.gz'
args.ga = args.ga or 'ga.nii.gz'
args.rgb = args.rgb or 'rgb.nii.gz'
args.md = args.md or 'md.nii.gz'
args.ad = args.ad or 'ad.nii.gz'
args.rd = args.rd or 'rd.nii.gz'
args.mode = args.mode or 'mode.nii.gz'
args.norm = args.norm or 'tensor_norm.nii.gz'
args.tensor = args.tensor or 'tensor.nii.gz'
args.evecs = args.evecs or 'tensor_evecs.nii.gz'
args.evals = args.evals or 'tensor_evals.nii.gz'
args.residual = args.residual or 'dti_residual.nii.gz'
args.p_i_signal =\
args.p_i_signal or 'physically_implausible_signals_mask.nii.gz'
args.pulsation = args.pulsation or 'pulsation_and_misalignment.nii.gz'
outputs = [args.fa, args.ga, args.rgb, args.md, args.ad, args.rd,
args.mode, args.norm, args.tensor, args.evecs, args.evals,
args.residual, args.p_i_signal, args.pulsation]
if args.not_all and not any(outputs):
parser.error('When using --not_all, you need to specify at least ' +
'one metric to output.')
assert_inputs_exist(
parser, [args.input, args.bvals, args.bvecs], args.mask)
assert_outputs_exist(parser, args, outputs)
img = nib.load(args.input)
data = img.get_data()
affine = img.get_affine()
if args.mask is None:
mask = None
else:
mask = nib.load(args.mask).get_data().astype(np.bool)
# Validate bvals and bvecs
logging.info('Tensor estimation with the %s method...', args.method)
bvals, bvecs = read_bvals_bvecs(args.bvals, args.bvecs)
if not is_normalized_bvecs(bvecs):
logging.warning('Your b-vectors do not seem normalized...')
bvecs = normalize_bvecs(bvecs)
check_b0_threshold(args, bvals.min())
gtab = gradient_table(bvals, bvecs, b0_threshold=bvals.min())
# Get tensors
if args.method == 'restore':
sigma = ne.estimate_sigma(data)
tenmodel = TensorModel(gtab, fit_method=args.method, sigma=sigma,
min_signal=_get_min_nonzero_signal(data))
else:
tenmodel = TensorModel(gtab, fit_method=args.method,
min_signal=_get_min_nonzero_signal(data))
tenfit = tenmodel.fit(data, mask)
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
FA = np.clip(FA, 0, 1)
if args.tensor:
# Get the Tensor values and format them for visualisation
# in the Fibernavigator.
tensor_vals = lower_triangular(tenfit.quadratic_form)
correct_order = [0, 1, 3, 2, 4, 5]
tensor_vals_reordered = tensor_vals[..., correct_order]
fiber_tensors = nib.Nifti1Image(
tensor_vals_reordered.astype(np.float32), affine)
nib.save(fiber_tensors, args.tensor)
if args.fa:
fa_img = nib.Nifti1Image(FA.astype(np.float32), affine)
nib.save(fa_img, args.fa)
if args.ga:
GA = geodesic_anisotropy(tenfit.evals)
GA[np.isnan(GA)] = 0
ga_img = nib.Nifti1Image(GA.astype(np.float32), affine)
nib.save(ga_img, args.ga)
if args.rgb:
RGB = color_fa(FA, tenfit.evecs)
rgb_img = nib.Nifti1Image(np.array(255 * RGB, 'uint8'), affine)
nib.save(rgb_img, args.rgb)
if args.md:
MD = mean_diffusivity(tenfit.evals)
md_img = nib.Nifti1Image(MD.astype(np.float32), affine)
nib.save(md_img, args.md)
if args.ad:
AD = axial_diffusivity(tenfit.evals)
ad_img = nib.Nifti1Image(AD.astype(np.float32), affine)
nib.save(ad_img, args.ad)
if args.rd:
RD = radial_diffusivity(tenfit.evals)
rd_img = nib.Nifti1Image(RD.astype(np.float32), affine)
nib.save(rd_img, args.rd)
if args.mode:
# Compute tensor mode
inter_mode = dipy_mode(tenfit.quadratic_form)
# Since the mode computation can generate NANs when not masked,
# we need to remove them.
non_nan_indices = np.isfinite(inter_mode)
mode = np.zeros(inter_mode.shape)
mode[non_nan_indices] = inter_mode[non_nan_indices]
mode_img = nib.Nifti1Image(mode.astype(np.float32), affine)
nib.save(mode_img, args.mode)
if args.norm:
NORM = norm(tenfit.quadratic_form)
norm_img = nib.Nifti1Image(NORM.astype(np.float32), affine)
nib.save(norm_img, args.norm)
if args.evecs:
evecs = tenfit.evecs.astype(np.float32)
evecs_img = nib.Nifti1Image(evecs, affine)
nib.save(evecs_img, args.evecs)
# save individual e-vectors also
e1_img = nib.Nifti1Image(evecs[..., 0], affine)
e2_img = nib.Nifti1Image(evecs[..., 1], affine)
e3_img = nib.Nifti1Image(evecs[..., 2], affine)
nib.save(e1_img, add_filename_suffix(args.evecs, '_v1'))
nib.save(e2_img, add_filename_suffix(args.evecs, '_v2'))
nib.save(e3_img, add_filename_suffix(args.evecs, '_v3'))
if args.evals:
evals = tenfit.evals.astype(np.float32)
evals_img = nib.Nifti1Image(evals, affine)
nib.save(evals_img, args.evals)
# save individual e-values also
e1_img = nib.Nifti1Image(evals[..., 0], affine)
e2_img = nib.Nifti1Image(evals[..., 1], affine)
e3_img = nib.Nifti1Image(evals[..., 2], affine)
nib.save(e1_img, add_filename_suffix(args.evals, '_e1'))
nib.save(e2_img, add_filename_suffix(args.evals, '_e2'))
nib.save(e3_img, add_filename_suffix(args.evals, '_e3'))
if args.p_i_signal:
S0 = np.mean(data[..., gtab.b0s_mask], axis=-1, keepdims=True)
DWI = data[..., ~gtab.b0s_mask]
pis_mask = np.max(S0 < DWI, axis=-1)
if args.mask is not None:
pis_mask *= mask
pis_img = nib.Nifti1Image(pis_mask.astype(np.int16), affine)
nib.save(pis_img, args.p_i_signal)
if args.pulsation:
STD = np.std(data[..., ~gtab.b0s_mask], axis=-1)
if args.mask is not None:
STD *= mask
std_img = nib.Nifti1Image(STD.astype(np.float32), affine)
nib.save(std_img, add_filename_suffix(args.pulsation, '_std_dwi'))
if np.sum(gtab.b0s_mask) <= 1:
logger.info('Not enough b=0 images to output standard '
'deviation map')
else:
if len( | np.where(gtab.b0s_mask) | numpy.where |
import numpy as np
import pandas as pd
import cv2 as cv
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from IPython.display import Image
#from moviepy.editor import VideoFileClip
from IPython.display import HTML
import pickle
import io
import os
import glob
# %matplotlib inline
def abs_sobel_thresh(img, orient='x', thresh=(0,255)):
# Convert to grayscale
gray = cv.cvtColor(img, cv.COLOR_RGB2GRAY)
# Apply x or y gradient with the OpenCV Sobel() function
# and take the absolute value
if orient == 'x':
abs_sobel = np.absolute(cv.Sobel(gray, cv.CV_64F, 1, 0))
if orient == 'y':
abs_sobel = np.absolute(cv.Sobel(gray, cv.CV_64F, 0, 1))
# Rescale back to 8 bit integer
scaled_sobel = np.uint8(255*abs_sobel/np.max(abs_sobel))
# Create a copy and apply the threshold
binary_output = | np.zeros_like(scaled_sobel) | numpy.zeros_like |
import numpy as np
from conductor import Conductor
from constants import Constants
class Plate(Conductor):
vertex1 = tuple() # 3D coordinate of one vertex
vertex2 = tuple() # 3D coordinate of the opposing vertex
vertices = [] # list of all 8 vertices
shape = tuple() # tuple of positive floats indicating dimensions
faces = [] # list of all 6 faces on the plate stored as tuples of the rectangle's corners
thicknessDimension = 0 # 0, 1, or 2 indicating which dimension of the plate is its thickness (the index of the smallest value in shape)
thickness = 0
def __init__(self, vertex1, vertex2, resistivity=Constants.COPPER_RESISTIVITY):
"""
input the 3D coordinate numpy arrays of 2 opposing vertices of the plate
requires that the plate's edges lie parallel to the coordinate system
generates all the corners of the prism
"""
self.vertex1 = vertex1
self.vertex2 = vertex2
self.shape = np.absolute(vertex2 - vertex1)
self.thicknessDimension = np.argmin(self.shape)
self.thickness = self.shape[self.thicknessDimension]
self.vertices = []
for x in (vertex1[0], vertex2[0]):
for y in (vertex1[1], vertex2[1]):
for z in (vertex1[2], vertex2[2]):
self.vertices.append(np.array((x, y, z)))
self.faces = []
self.faces.append(tuple(self.vertices[i] for i in [0, 1, 3, 2]))
self.faces.append(tuple(self.vertices[i] for i in [4, 5, 7, 6]))
self.faces.append(tuple(self.vertices[i] for i in [0, 1, 5, 4]))
self.faces.append(tuple(self.vertices[i] for i in [2, 3, 7, 6]))
self.faces.append(tuple(self.vertices[i] for i in [0, 2, 6, 4]))
self.faces.append(tuple(self.vertices[i] for i in [1, 3, 7, 5]))
super(Plate, self).__init__(resistivity=resistivity)
def checkCollision(self, prevPos, pos, velocity, dampingFactor=1):
"""
checks to see if the specified particle collided with any of the faces of the plate
:param prevPos: previous position vector of the particle
:param pos: current position of the particle
:param velocity: current velocity vector of the particle
:param dampingFactor: the factor by which the velocity decreases upon impact
:return: the position of the collision, the particle's new velocity vector, the corners of face the particle
collided with. If there was no collision, returns None
"""
collisions = []
for face in self.faces:
col = Plate.rectangleCollision(prevPos, pos, face, velocity, dampingFactor=dampingFactor)
if col is not None:
collisions.append((face, col))
if len(collisions) == 0:
return None
col = min(collisions, key=lambda x: abs(x[1][0][0] - prevPos[0])) # the actual collision is the first one
return col[1][0], col[1][1], col[0]
@staticmethod
def rectangleCollision(prevPos, pos, rCorners, velocity, dampeningFactor=1):
"""
checks to see if a particle collided with the defined rectangle and gives you that particle's updated info
:param prevPos: position of a particle at the previous iteration
:param pos: position of that particle at the current iteration
:param rCorners: a tuple of the corner points of a rectangle in 3D space to check for collisions
stored such that ADJACENT CORNERS IN THE LIST ARE ADJACENT IN THE RECTANGLE
:param velocity: the initial velocity vector of the particle
:param dampeningFactor: the factor by which the particle's velocity decreases upon impact
:return: the collision position of the particle and its new velocity. if no collision returns None
"""
basis = list()
basis.append(rCorners[1] - rCorners[0])
basis.append(rCorners[2] - rCorners[1])
normal = | np.cross(basis[0], basis[1]) | numpy.cross |
# 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]) | numpy.array |
import sys
import numpy as np
import pandas as pd
import openmdao.api as om
from wisdem.commonse import gravity
eps = 1e-3
# Convenience functions for computing McDonald's C and F parameters
def chsMshc(x):
return np.cosh(x) * np.sin(x) - np.sinh(x) * np.cos(x)
def chsPshc(x):
return np.cosh(x) * np.sin(x) + np.sinh(x) * np.cos(x)
def carterFactor(airGap, slotOpening, slotPitch):
"""Return Carter factor
(based on Langsdorff's empirical expression)
See page 3-13 Boldea Induction machines Chapter 3
"""
gma = (2 * slotOpening / airGap) ** 2 / (5 + 2 * slotOpening / airGap)
return slotPitch / (slotPitch - airGap * gma * 0.5)
# ---------------
def carterFactorMcDonald(airGap, h_m, slotOpening, slotPitch):
"""Return Carter factor using Carter's equation
(based on Schwartz-Christoffel's conformal mapping on simplified slot geometry)
This code is based on Eq. B.3-5 in Appendix B of McDonald's thesis.
It is used by PMSG_arms and PMSG_disc.
h_m : magnet height (m)
b_so : stator slot opening (m)
tau_s : Stator slot pitch (m)
"""
mu_r = 1.06 # relative permeability (probably for neodymium magnets, often given as 1.05 - GNS)
g_1 = airGap + h_m / mu_r # g
b_over_a = slotOpening / (2 * g_1)
gamma = 4 / np.pi * (b_over_a * np.arctan(b_over_a) - np.log(np.sqrt(1 + b_over_a ** 2)))
return slotPitch / (slotPitch - gamma * g_1)
# ---------------
def carterFactorEmpirical(airGap, slotOpening, slotPitch):
"""Return Carter factor using Langsdorff's empirical expression"""
sigma = (slotOpening / airGap) / (5 + slotOpening / airGap)
return slotPitch / (slotPitch - sigma * slotOpening)
# ---------------
def carterFactorSalientPole(airGap, slotWidth, slotPitch):
"""Return Carter factor for salient pole rotor
Where does this equation come from? It's different from other approximations above.
Original code:
tau_s = np.pi * dia / S # slot pitch
b_s = tau_s * b_s_tau_s # slot width
b_t = tau_s - b_s # tooth width
K_C1 = (tau_s + 10 * g_a) / (tau_s - b_s + 10 * g_a) # salient pole rotor
slotPitch - slotWidth == toothWidth
"""
return (slotPitch + 10 * airGap) / (slotPitch - slotWidth + 10 * airGap) # salient pole rotor
# ---------------------------------
def array_seq(q1, b, c, Total_number):
Seq = np.array([1, 0, 0, 1, 0])
diff = Total_number * 5 / 6
G = np.prod(Seq.shape)
return Seq, diff, G
# ---------------------------------
def winding_factor(Sin, b, c, p, m):
S = int(Sin)
# Step 1 Writing q1 as a fraction
q1 = b / c
# Step 2: Writing a binary sequence of b-c zeros and b ones
Total_number = int(S / b)
L = array_seq(q1, b, c, Total_number)
# STep 3 : Repeat binary sequence Q_s/b times
New_seq = np.tile(L[0], Total_number)
Actual_seq1 = pd.DataFrame(New_seq[:, None].T)
Winding_sequence = ["A", "C1", "B", "A1", "C", "B1"]
New_seq2 = np.tile(Winding_sequence, int(L[1]))
Actual_seq2 = pd.DataFrame(New_seq2[:, None].T)
Seq_f = pd.concat([Actual_seq1, Actual_seq2], ignore_index=True)
Seq_f.reset_index(drop=True)
Slots = S
R = S if S % 2 == 0 else S + 1
Windings_arrange = (pd.DataFrame(index=Seq_f.index, columns=Seq_f.columns[1:R])).fillna(0)
counter = 1
# Step #4 Arranging winding in Slots
for i in range(0, len(New_seq)):
if Seq_f.loc[0, i] == 1:
Windings_arrange.loc[0, counter] = Seq_f.loc[1, i]
counter = counter + 1
Windings_arrange.loc[1, 1] = "C1"
for k in range(1, R):
if Windings_arrange.loc[0, k] == "A":
Windings_arrange.loc[1, k + 1] = "A1"
elif Windings_arrange.loc[0, k] == "B":
Windings_arrange.loc[1, k + 1] = "B1"
elif Windings_arrange.loc[0, k] == "C":
Windings_arrange.loc[1, k + 1] = "C1"
elif Windings_arrange.loc[0, k] == "A1":
Windings_arrange.loc[1, k + 1] = "A"
elif Windings_arrange.loc[0, k] == "B1":
Windings_arrange.loc[1, k + 1] = "B"
elif Windings_arrange.loc[0, k] == "C1":
Windings_arrange.loc[1, k + 1] = "C"
Phase_A = | np.zeros((1000, 1), dtype=float) | numpy.zeros |
"""Module for creating illustrations.
To create an annotated image we need an instance of the
:class:`jicbioimage.illustrate.AnnotatedImage` class.
>>> from jicbioimage.illustrate import AnnotatedImage
Suppose that we have an existing image.
>>> from jicbioimage.core.image import Image
>>> im = Image((50,50))
We can use this image to create an canvas instance populated with the data
as a RGB gray scale image.
>>> canvas = AnnotatedImage.from_grayscale(im)
The :class:`jicbioimage.illustrate.Canvas` instance has built in annotation
functionality.
One can use it to draw crosses.
>>> canvas.draw_cross(10, 20)
One can use it to mask out bitmaps (in the example below with the color cyan).
>>> bitmap = np.zeros((50, 50), dtype=bool)
>>> bitmap[30:40, 30:40] = True
>>> canvas.mask_region(bitmap, color=(0, 255, 255))
One can use it to add text at particular locations on the canvas.
>>> canvas.text_at("Hello", 30, 60)
"""
import os.path
import PIL.ImageFont
import numpy as np
import skimage.draw
import jicbioimage.core.image
__version__ = "0.6.1"
HERE = os.path.dirname(__file__)
DEFAULT_FONT_PATH = os.path.join(HERE, "fonts", "UbuntuMono-R.ttf")
class Canvas(jicbioimage.core.image._BaseImage):
"""Class for building up annotated images."""
@staticmethod
def blank_canvas(width, height):
"""Return a blank canvas to annotate.
:param width: xdim (int)
:param height: ydim (int)
:returns: :class:`jicbioimage.illustrate.Canvas`
"""
canvas = np.zeros((height, width, 3), dtype=np.uint8)
return canvas.view(Canvas)
def draw_cross(self, position, color=(255, 0, 0), radius=4):
"""Draw a cross on the canvas.
:param position: (row, col) tuple
:param color: RGB tuple
:param radius: radius of the cross (int)
"""
y, x = position
for xmod in | np.arange(-radius, radius+1, 1) | numpy.arange |
# Copyright 2019, the MIDOSS project contributors, The University of British Columbia,
# and Dalhousie University.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import h5py
import os
import yaml
def wind_speed_dir(u_wind, v_wind):
"""Calculate wind speed and direction from u and v wind components.
:kbd:`u_wind` and :kbd:`v_wind` may be either scalar numbers or
:py:class:`numpy.ndarray` objects,
and the elements of the return value will be of the same type.
:arg u_wind: u-direction component of wind vector.
:arg v_wind: v-direction component of wind vector.
:returns: 2-tuple containing the wind speed and direction.
The :py:attr:`speed` attribute holds the wind speed(s),
and the :py:attr:`dir` attribute holds the wind
direction(s).
:rtype: :py:class:`collections.namedtuple`
"""
speed = np.sqrt(u_wind**2 + v_wind**2)
dir = np.arctan2(v_wind, u_wind)
dir = np.rad2deg(dir + (dir < 0) * 2 * np.pi)
return speed, dir
def add_to_dict(group, timeseries, dict24, dict168, start_hour):
dict24[group] = {'min': "%.4g" % np.min(timeseries[start_hour:start_hour+24]),
'max': "%.4g" % np.max(timeseries[start_hour:start_hour+24]),
'mean': "%.4g" % np.mean(timeseries[start_hour:start_hour+24]),
'std': "%.4g" % np.std(timeseries[start_hour:start_hour+24])}
dict168[group] = {'min': "%.4g" % np.min(timeseries[start_hour:start_hour+168]),
'max': "%.4g" % np.max(timeseries[start_hour:start_hour+168]),
'mean': "%.4g" % np.mean(timeseries[start_hour:start_hour+168]),
'std': "%.4g" % np.std(timeseries[start_hour:start_hour+168])}
return dict24, dict168
def make_forcing_statistics(path, GridX, GridY, start_hour):
files =[]
for r, d, f in os.walk(path):
for file in f:
if '.hdf5' in file:
files.append(os.path.join(r, file))
stats24_dict = {'variable':{'mean':2, 'min':1, 'max':5, 'std':6}}
stats168_dict = {'variable':{'mean':2, 'min':1, 'max':5, 'std':6}}
for file in files:
with h5py.File(file, 'r') as f:
for group in list(f['Results'].keys()):
timeseries = np.array([])
for time in list(f['Results'][group].keys()):
if np.ndim(f['Results'][group][time][:]) == 3:
timeseries = | np.append(timeseries, f['Results'][group][time][-1, GridX, GridY]) | numpy.append |
import nipype.pipeline.engine as pe
import nipype.interfaces.fsl as fsl
import nipype.interfaces.utility as util
import nipype.interfaces.afni as afni
from nipype import logging
def get_voxel_timeseries(wf_name='voxel_timeseries'):
"""
Workflow to extract time series for each voxel
in the data that is present in the input mask
Parameters
----------
wf_name : string
name of the workflow
Returns
-------
wflow : workflow object
workflow object
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/timeseries/timeseries_analysis.py>`_
Workflow Inputs::
inputspec.rest : string (nifti file)
path to input functional data
inputspec.output_type : string (list of boolean)
list of boolean for csv and npz file formats
input_mask.masks : string (nifti file)
path to ROI mask
Workflow Outputs::
outputspec.mask_outputs: string (1D, csv and/or npz files)
list of time series matrices stored in csv and/or
npz files.By default it outputs mean of voxels
across each time point in a afni compatible 1D file.
High Level Workflow Graph:
Example
-------
>>> import CPAC.timeseries.timeseries_analysis as t
>>> wf = t.get_voxel_timeseries()
>>> wf.inputs.inputspec.rest = '/home/data/rest.nii.gz'
>>> wf.inputs.input_mask.mask = '/usr/local/fsl/data/standard/MNI152_T1_2mm_brain.nii.gz'
>>> wf.inputs.inputspec.output_type = [True,True]
>>> wf.base_dir = './'
>>> wf.run()
"""
wflow = pe.Workflow(name=wf_name)
inputNode = pe.Node(util.IdentityInterface(fields=['rest',
'output_type']),
name='inputspec')
inputNode_mask = pe.Node(util.IdentityInterface(fields=['mask']),
name='input_mask')
outputNode = pe.Node(util.IdentityInterface(fields=['mask_outputs']),
name='outputspec')
timeseries_voxel = pe.Node(util.Function(input_names=['data_file',
'template',
'output_type'],
output_names=['out_file'],
function=gen_voxel_timeseries),
name='timeseries_voxel')
wflow.connect(inputNode, 'rest',
timeseries_voxel, 'data_file')
wflow.connect(inputNode, 'output_type',
timeseries_voxel, 'output_type')
wflow.connect(inputNode_mask, 'mask',
timeseries_voxel, 'template')
wflow.connect(timeseries_voxel, 'out_file',
outputNode, 'mask_outputs')
return wflow
def clean_roi_csv(roi_csv):
"""Remove the file path comments from every other row of the output of
AFNI's 3dROIstats.
3dROIstats has a -nobriklab and a -quiet option, but neither remove the
file path comments while retaining the ROI label header, which is needed.
If there are no file path comments to remove, this function simply
passes the original file as output, instead of unnecessarily opening and
re-writing it.
"""
import pandas as pd
import os
import pandas as pd
import numpy as np
with open(roi_csv, 'r') as f:
csv_lines = f.readlines()
modified = False
edited_lines = []
for line in csv_lines:
line = line.replace('\t\t\t', '')
line = line.replace('\t\t', '')
line = line.replace('\t', ',')
line = line.replace('#,', '#')
if '#' in line:
if '/' in line and '.' in line:
modified = True
continue
edited_lines.append(line)
if modified:
edited_roi_csv = os.path.join(os.getcwd(), os.path.basename(roi_csv))
with open(edited_roi_csv, 'wt') as f:
for line in edited_lines:
f.write(line)
edited_roi_csv = [edited_roi_csv]
else:
edited_roi_csv = [roi_csv]
data = pd.read_csv(edited_roi_csv[0], sep = ',', header = 1)
data = data.dropna(axis=1)
roi_array = np.transpose(data.values)
return roi_array, edited_roi_csv
def write_roi_npz(roi_csv, out_type=None):
roi_npz = None
roi_outputs = [roi_csv[0]]
if not out_type:
return roi_outputs
elif out_type[1]:
np_roi_data = genfromtxt(roi_csv[0], delimiter=',')
roi_npz = os.path.join(os.getcwd(), 'roi_stats.npz')
with open(roi_npz, 'wb') as f:
np.savez(f, np_roi_data)
roi_outputs.append(roi_npz)
return roi_outputs
def get_roi_timeseries(wf_name='roi_timeseries'):
"""
Workflow to extract timeseries for each node in the ROI mask.
For each node, mean across all the timepoint is calculated and stored
in csv and npz format.
Parameters
----------
wf_name : string
name of the workflow
Returns
-------
wflow : workflow object
workflow object
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/timeseries/timeseries_analysis.py>`_
Workflow Inputs::
inputspec.rest : string (nifti file)
path to input functional data
inputspec.output_type : string (list of boolean)
list of boolean for csv and npz file formats
input_roi.roi : string (nifti file)
path to ROI mask
Workflow Outputs::
outputspec.roi_ts : numpy array
Voxel time series stored in numpy array, which is used to create ndmg graphs.
outputspec.roi_outputs : string (list of files)
Voxel time series stored in 1D (column wise timeseries for each node),
csv and/or npz files. By default it outputs timeseries in a 1D file.
The 1D file is compatible with afni interfaces.
Example
-------
>>> import CPAC.timeseries.timeseries_analysis as t
>>> wf = t.get_roi_timeseries()
>>> wf.inputs.inputspec.rest = '/home/data/rest.nii.gz'
>>> wf.inputs.input_roi.roi = '/usr/local/fsl/data/atlases/HarvardOxford/HarvardOxford-cort-maxprob-thr0-2mm.nii.gz'
>>> wf.inputs.inputspec.output_type = [True,True]
>>> wf.base_dir = './'
>>> wf.run()
"""
wflow = pe.Workflow(name=wf_name)
inputNode = pe.Node(util.IdentityInterface(fields=['rest',
'output_type']),
name='inputspec')
inputnode_roi = pe.Node(util.IdentityInterface(fields=['roi']),
name='input_roi')
outputNode = pe.Node(util.IdentityInterface(fields=['roi_ts',
'roi_outputs']),
name='outputspec')
timeseries_roi = pe.Node(interface=afni.ROIStats(),
name='3dROIstats')
timeseries_roi.inputs.quiet = False
timeseries_roi.inputs.args = "-1Dformat"
# TODO: add -mask_f2short for float parcellation mask
# if parcellation mask has float values
# timeseries_roi.inputs.mask_f2short = True
wflow.connect(inputNode, 'rest',
timeseries_roi, 'in_file')
wflow.connect(inputnode_roi, 'roi',
timeseries_roi, 'mask')
clean_csv_imports = ['import os']
clean_csv = pe.Node(util.Function(input_names=['roi_csv'],
output_names=['roi_array',
'edited_roi_csv'],
function=clean_roi_csv,
imports=clean_csv_imports),
name='clean_roi_csv')
wflow.connect(timeseries_roi, 'stats', clean_csv, 'roi_csv')
write_npz_imports = ['import os', 'import numpy as np',
'from numpy import genfromtxt']
write_npz = pe.Node(util.Function(input_names=['roi_csv', 'out_type'],
output_names=['roi_output_npz'],
function=write_roi_npz,
imports=write_npz_imports),
name='write_roi_npz')
wflow.connect(clean_csv, 'edited_roi_csv', write_npz, 'roi_csv')
wflow.connect(inputNode, 'output_type', write_npz, 'out_type')
wflow.connect(clean_csv, 'roi_array', outputNode, 'roi_ts')
wflow.connect(write_npz, 'roi_output_npz', outputNode, 'roi_outputs')
return wflow
def get_spatial_map_timeseries(wf_name='spatial_map_timeseries'):
"""
Workflow to regress each provided spatial
map to the subjects functional 4D file in order
to return a timeseries for each of the maps
Parameters
----------
wf_name : string
name of the workflow
Returns
-------
wflow : workflow object
workflow object
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/timeseries/timeseries_analysis.py>`_
Workflow Inputs::
inputspec.subject_rest : string (nifti file)
path to input functional data
inputspec.subject_mask : string (nifti file)
path to subject functional mask
inputspec.spatial_map : string (nifti file)
path to Spatial Maps
inputspec.demean : Boolean
control whether to demean model and data
Workflow Outputs::
outputspec.subject_timeseries: string (txt file)
list of time series stored in a space separated
txt file
the columns are spatial maps, rows are timepoints
Example
-------
>>> import CPAC.timeseries.timeseries_analysis as t
>>> wf = t.get_spatial_map_timeseries()
>>> wf.inputs.inputspec.subject_rest = '/home/data/rest.nii.gz'
>>> wf.inputs.inputspec.subject_mask = '/home/data/rest_mask.nii.gz'
>>> wf.inputs.inputspec.ICA_map = '/home/data/spatialmaps/spatial_map.nii.gz'
>>> wf.inputs.inputspec.demean = True
>>> wf.base_dir = './'
>>> wf.run()
"""
wflow = pe.Workflow(name=wf_name)
inputNode = pe.Node(util.IdentityInterface
(fields=['subject_rest',
'subject_mask',
'spatial_map',
'demean']),
name='inputspec')
outputNode = pe.Node(util.IdentityInterface(
fields=['subject_timeseries']),
name='outputspec')
spatialReg = pe.Node(interface=fsl.GLM(),
name='spatial_regression')
spatialReg.inputs.out_file = 'spatial_map_timeseries.txt'
wflow.connect(inputNode, 'subject_rest', spatialReg, 'in_file')
wflow.connect(inputNode, 'subject_mask', spatialReg, 'mask')
wflow.connect(inputNode, 'spatial_map', spatialReg, 'design')
wflow.connect(inputNode, 'demean', spatialReg, 'demean')
wflow.connect(spatialReg, 'out_file', outputNode, 'subject_timeseries')
return wflow
def get_vertices_timeseries(wf_name='vertices_timeseries'):
"""
Workflow to get vertices time series from a FreeSurfer surface file
Parameters
----------
wf_name : string
name of the workflow
Returns
-------
wflow : workflow object
workflow object
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/timeseries/timeseries_analysis.py>`_
Workflow Inputs::
inputspec.lh_surface_file : string (nifti file)
left hemishpere surface file
inputspec.rh_surface_file : string (nifti file)
right hemisphere surface file
Workflow Outputs::
outputspec.surface_outputs: string (csv and/or npz files)
list of timeseries matrices stored in csv and/or
npz files
Example
-------
>>> import CPAC.timeseries.timeseries_analysis as t
>>> wf = t.get_vertices_timeseries()
>>> wf.inputs.inputspec.lh_surface_file = '/home/data/outputs/SurfaceRegistration/lh_surface_file.nii.gz'
>>> wf.inputs.inputspec.rh_surface_file = '/home/data/outputs/SurfaceRegistration/rh_surface_file.nii.gz'
>>> wf.base_dir = './'
>>> wf.run()
"""
wflow = pe.Workflow(name=wf_name)
inputNode = pe.Node(util.IdentityInterface(fields=['lh_surface_file',
'rh_surface_file']),
name='inputspec')
timeseries_surface = pe.Node(util.Function(input_names=['rh_surface_file',
'lh_surface_file'],
output_names=['out_file'],
function=gen_vertices_timeseries),
name='timeseries_surface')
outputNode = pe.Node(util.IdentityInterface(fields=['surface_outputs']),
name='outputspec')
wflow.connect(inputNode, 'rh_surface_file',
timeseries_surface, 'rh_surface_file')
wflow.connect(inputNode, 'lh_surface_file',
timeseries_surface, 'lh_surface_file')
wflow.connect(timeseries_surface, 'out_file',
outputNode, 'surface_outputs')
return wflow
def get_normalized_moments(wf_name='normalized_moments'):
"""
Workflow to calculate the normalized moments for skewedness calculations
Parameters
----------
wf_name : string
name of the workflow
Returns
-------
wflow : workflow object
workflow object
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/timeseries/timeseries_analysis.py>`_
Workflow Inputs::
inputspec.spatial_timeseries : string (nifti file)
spatial map timeseries
Workflow Outputs::
outputspec.moments: list
list of moment values
Example
-------
>>> import CPAC.timeseries.timeseries_analysis as t
>>> wf = t.get_normalized_moments()
>>> wf.inputs.inputspec.spatial_timeseries = '/home/data/outputs/SurfaceRegistration/lh_surface_file.nii.gz'
>>> wf.base_dir = './'
>>> wf.run()
"""
wflow = pe.Workflow(name=wf_name)
inputNode = pe.Node(util.IdentityInterface(fields=['spatial_timeseries']),
name='inputspec')
# calculate normalized moments
# output of this node is a list, 'moments'
norm_moments = pe.Node(util.CalculateNormalizedMoments(moment='3'),
name='norm_moments')
outputNode = pe.Node(util.IdentityInterface(fields=['moments_outputs']),
name='outputspec')
wflow.connect(inputNode, 'spatial_timeseries',
norm_moments, 'timeseries_file')
wflow.connect(norm_moments, 'moments', outputNode, 'moments_outputs')
return wflow
def gen_roi_timeseries(data_file, template, output_type):
"""
Method to extract mean of voxel across
all timepoints for each node in roi mask
Parameters
----------
data_file : string
path to input functional data
template : string
path to input roi mask in functional native space
output_type : list
list of two boolean values suggesting
the output types - numpy npz file and csv
format
Returns
-------
out_list : list
list of 1D file, txt file, csv file and/or npz file containing
mean timeseries for each scan corresponding
to each node in roi mask
Raises
------
Exception
"""
import nibabel as nib
import csv
import numpy as np
import os
import shutil
unit_data = nib.load(template).get_data()
# Cast as rounded-up integer
unit_data = np.int64(np.ceil(unit_data))
datafile = nib.load(data_file)
img_data = datafile.get_data()
vol = img_data.shape[3]
if unit_data.shape != img_data.shape[:3]:
raise Exception('\n\n[!] CPAC says: Invalid Shape Error.'
'Please check the voxel dimensions. '
'Data and roi should have the same shape.\n\n')
nodes = np.unique(unit_data).tolist()
sorted_list = []
node_dict = {}
out_list = []
# extracting filename from input template
tmp_file = os.path.splitext(
os.path.basename(template))[0]
tmp_file = os.path.splitext(tmp_file)[0]
oneD_file = os.path.abspath('roi_' + tmp_file + '.1D')
txt_file = os.path.abspath('roi_' + tmp_file + '.txt')
csv_file = os.path.abspath('roi_' + tmp_file + '.csv')
numpy_file = os.path.abspath('roi_' + tmp_file + '.npz')
nodes.sort()
for n in nodes:
if n > 0:
node_array = img_data[unit_data == n]
node_str = 'node_{0}'.format(n)
avg = np.mean(node_array, axis=0)
avg = np.round(avg, 6)
list1 = [n] + avg.tolist()
sorted_list.append(list1)
node_dict[node_str] = avg.tolist()
# writing to 1Dfile
print("writing 1D file..")
f = open(oneD_file, 'w')
writer = csv.writer(f, delimiter=',')
value_list = []
new_keys = sorted([
int(float(key.split('node_')[1])) for key in node_dict
])
roi_number_list = [str(n) for n in new_keys]
roi_number_str = []
for number in roi_number_list:
roi_number_str.append("#" + number)
for key in new_keys:
value_list.append(str('{0}\n'.format(node_dict['node_{0}'.format(key)])))
column_list = list(zip(*value_list))
writer.writerow(roi_number_str)
for column in column_list:
writer.writerow(list(column))
f.close()
out_list.append(oneD_file)
# copy the 1D contents to txt file
shutil.copy(oneD_file, txt_file)
out_list.append(txt_file)
# if csv is required
if output_type[0]:
print("writing csv file..")
f = open(csv_file, 'wt')
writer = csv.writer(f, delimiter=',', quoting=csv.QUOTE_MINIMAL)
headers = ['node/volume'] + | np.arange(vol) | numpy.arange |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 14 21:31:56 2017
@author: Franz
"""
import scipy.signal
import numpy as np
import scipy.io as so
import os.path
import re
import matplotlib.pylab as plt
import h5py
import matplotlib.patches as patches
import numpy.random as rand
import seaborn as sns
import pandas as pd
from functools import reduce
import random
import pdb
class Mouse :
def __init__(self, idf, list=None, typ='') :
self.recordings = []
self.recordings.append(list)
self.typ = typ
self.idf = idf
def add(self, rec) :
self.recordings.append(rec)
def __len__(self) :
return len(self.recordings)
def __repr__(self) :
return ", ".join(self.recordings)
### PROCESSING OF RECORDING DATA ##############################################
def load_stateidx(ppath, name, ann_name=''):
""" load the sleep state file of recording (folder) $ppath/$name
@Return:
M,K sequence of sleep states, sequence of
0'1 and 1's indicating non- and annotated states
"""
ddir = os.path.join(ppath, name)
ppath, name = os.path.split(ddir)
if ann_name == '':
ann_name = name
sfile = os.path.join(ppath, name, 'remidx_' + ann_name + '.txt')
f = open(sfile, 'r')
lines = f.readlines()
f.close()
n = 0
for l in lines:
if re.match('\d', l):
n += 1
M = np.zeros(n, dtype='int')
K = np.zeros(n, dtype='int')
i = 0
for l in lines :
if re.search('^\s+$', l) :
continue
if re.search('\s*#', l) :
continue
if re.match('\d+\s+-?\d+', l) :
a = re.split('\s+', l)
M[i] = int(a[0])
K[i] = int(a[1])
i += 1
return M,K
def load_recordings(ppath, rec_file) :
"""
load_recordings(ppath, rec_file)
load recording listing with syntax:
[E|C] \s+ recording_name
#COMMENT
@RETURN:
(list of controls, lis of experiments)
"""
exp_list = []
ctr_list = []
rfile = os.path.join(ppath, rec_file)
f = open(rfile, newline=None)
lines = f.readlines()
f.close()
for l in lines :
if re.search('^\s+$', l) :
continue
if re.search('^\s*#', l) :
continue
a = re.split('\s+', l)
if re.search('E', a[0]) :
exp_list.append(a[1])
if re.search('C', a[0]) :
ctr_list.append(a[1])
return ctr_list, exp_list
def load_dose_recordings(ppath, rec_file):
"""
load recording list with following syntax:
A line is either control or experiments; Control recordings look like:
C \s recording_name
Experimental recordings also come with an additional dose parameter
(allowing for comparison of multiple doses with controls)
E \s recording_name \s dose_1
E \s recording_name \s dose_2
"""
rfile = os.path.join(ppath, rec_file)
f = open(rfile, newline=None)
lines = f.readlines()
f.close()
# first get all potential doses
doses = {}
ctr_list = []
for l in lines :
if re.search('^\s+$', l):
continue
if re.search('^\s*#', l):
continue
a = re.split('\s+', l)
if re.search('E', a[0]):
if a[2] in doses:
doses[a[2]].append(a[1])
else:
doses[a[2]] = [a[1]]
if re.search('C', a[0]):
ctr_list.append(a[1])
return ctr_list, doses
def get_snr(ppath, name):
"""
read and return sampling rate (SR) from file $ppath/$name/info.txt
"""
fid = open(os.path.join(ppath, name, 'info.txt'), newline=None)
lines = fid.readlines()
fid.close()
values = []
for l in lines :
a = re.search("^" + 'SR' + ":" + "\s+(.*)", l)
if a :
values.append(a.group(1))
return float(values[0])
def get_infoparam(ifile, field):
"""
NOTE: field is a single string
and the function does not check for the type
of the values for field.
In fact, it just returns the string following field
"""
fid = open(ifile, newline=None)
lines = fid.readlines()
fid.close()
values = []
for l in lines :
a = re.search("^" + field + ":" + "\s+(.*)", l)
if a :
values.append(a.group(1))
return values
def add_infoparam(ifile, field, vals):
"""
:param ifile: info file
:param field: Parameters specifier, e.g. 'SR'
:param vals: list with parameters
"""
fid = open(ifile, 'a')
vals = [str(s) for s in vals]
param = " ".join(vals)
fid.write('%s:\t%s' % (field, param))
fid.write(os.linesep)
fid.close()
def laser_start_end(laser, SR=1525.88, intval=5):
"""laser_start_end(ppath, name)
print start and end index of laser stimulation trains: For example,
if you was stimulated for 2min every 20 min with 20 Hz, return the
start and end index of the each 2min stimulation period (train)
returns the tuple (istart, iend), both indices are inclusive,
i.e. part of the sequence
@Param:
laser - laser, vector of 0s and 1s
intval - minimum time separation [s] between two laser trains
@Return:
(istart, iend) - tuple of two np.arrays with laser start and end indices
"""
idx = np.where(laser > 0.5)[0]
if len(idx) == 0 :
return ([], [])
idx2 = np.nonzero(np.diff(idx)*(1./SR) > intval)[0]
istart = np.hstack([idx[0], idx[idx2+1]])
iend = np.hstack([idx[idx2], idx[-1]])
return (istart, iend)
def load_laser(ppath, name):
"""
load laser from recording ppath/name
@RETURN:
@laser, vector of 0's and 1's
"""
# laser might be .mat or h5py file
# perhaps we could find a better way of testing that
file = os.path.join(ppath, name, 'laser_'+name+'.mat')
try:
laser = np.array(h5py.File(file,'r').get('laser'))
except:
laser = so.loadmat(file)['laser']
return np.squeeze(laser)
def laser_protocol(ppath, name):
"""
What was the stimulation frequency and the inter-stimulation interval for recording
$ppath/$name?
@Return:
iinter-stimulation intervals, avg. inter-stimulation interval, frequency
"""
laser = load_laser(ppath, name)
SR = get_snr(ppath, name)
# first get inter-stimulation interval
(istart, iend) = laser_start_end(laser, SR)
intv = np.diff(np.array(istart/float(SR)))
d = intv/60.0
print("The laser was turned on in average every %.2f min," % (np.mean(d)))
print("with a min. interval of %.2f min and max. interval of %.2f min." % (np.min(d), np.max(d)))
print("Laser stimulation lasted for %f s." % (np.mean(np.array(iend/float(SR)-istart/float(SR)).mean())))
# print laser start times
print("Start time of each laser trial:")
j=1
for t in istart:
print("trial %d: %.2f" % (j, (t / float(SR)) / 60))
j += 1
# for each laser stimulation interval, check laser stimulation frequency
dt = 1/float(SR)
freq = []
laser_up = []
laser_down = []
for (i,j) in zip(istart, iend):
part = laser[i:j+1]
(a,b) = laser_start_end(part, SR, 0.005)
dur = (j-i+1)*dt
freq.append(len(a) / dur)
up_dur = (b-a+1)*dt*1000
down_dur = (a[1:]-b[0:-1]-1)*dt*1000
laser_up.append(np.mean(up_dur))
laser_down.append(np.mean(down_dur))
print(os.linesep + "Laser stimulation freq. was %.2f Hz," % np.mean(np.array(freq)))
print("with laser up and down duration of %.2f and %.2f ms." % (np.mean(np.array(laser_up)), np.mean(np.array(laser_down))))
return d, np.mean(d), np.mean(np.array(freq))
def swap_eeg(ppath, rec, ch='EEG'):
"""
swap EEG and EEG2 or EMG with EMG2 if $ch='EMG'
"""
if ch == 'EEG':
name = 'EEG'
else:
name = ch
EEG = so.loadmat(os.path.join(ppath, rec, name+'.mat'))[name]
EEG2 = so.loadmat(os.path.join(ppath, rec, name+'2.mat'))[name + '2']
tmp = EEG
EEG = EEG2
EEG2 = tmp
file_eeg1 = os.path.join(ppath, rec, '%s.mat' % name)
file_eeg2 = os.path.join(ppath, rec, '%s2.mat' % name)
so.savemat(file_eeg1, {name : EEG})
so.savemat(file_eeg2, {name+'2' : EEG2})
def eeg_conversion(ppath, rec, conv_factor=0.195):
"""
multiply all EEG and EMG channels with the given
conversion factor and write the conversion factor
as parameter (conversion:) into the info file.
Only if there's no conversion factor in the info file
specified, the conversion will be executed
:param ppath: base filder
:param rec: recording
:param conv_factor: conversion factor
:return: n/s
"""
ifile = os.path.join(ppath, rec, 'info.txt')
conv = get_infoparam(ifile, 'conversion')
if len(conv) > 0:
print("found conversion: parameter in info file")
print("returning: no conversion necessary!!!")
return
else:
files = os.listdir(os.path.join(ppath, rec))
files = [f for f in files if re.match('^EEG', f)]
for f in files:
name = re.split('\.', f)[0]
EEG = so.loadmat(os.path.join(ppath, rec, name+'.mat'), squeeze_me=True)[name]
if EEG[0].dtype == 'int16':
EEG = EEG * conv_factor
file_eeg = os.path.join(ppath, rec, '%s.mat' % name)
print(file_eeg)
so.savemat(file_eeg, {name: EEG})
else:
print('Wrong datatype! probably already converted; returning...')
return
files = os.listdir(os.path.join(ppath, rec))
files = [f for f in files if re.match('^EMG', f)]
for f in files:
name = re.split('\.', f)[0]
EMG = so.loadmat(os.path.join(ppath, rec, name+'.mat'), squeeze_me=True)[name]
if EMG[0].dtype == 'int16':
EMG = EMG * conv_factor
file_emg = os.path.join(ppath, rec, '%s.mat' % name)
print(file_emg)
so.savemat(file_emg, {name: EMG})
else:
print('Wrong datatype! probably already converted; returning...')
return
add_infoparam(ifile, 'conversion', [conv_factor])
calculate_spectrum(ppath, rec)
### DEPRICATED ############################################
def video_pulse_detection(ppath, rec, SR=1000, iv = 0.01):
"""
return index of each video frame onset
ppath/rec - recording
@Optional
SR - sampling rate of EEG(!) recording
iv - minimum time inverval (in seconds) between two frames
@Return
index of each video frame onset
"""
V = np.squeeze(so.loadmat(os.path.join(ppath, rec, 'videotime_' + rec + '.mat'))['video'])
TS = np.arange(0, len(V))
# indices where there's a jump in the signal
t = TS[np.where(V<0.5)];
if len(t) == 0:
idx = []
return idx
# time points where the interval between jumps is longer than iv
t2 = np.where(np.diff(t)*(1.0/SR)>=iv)[0]
idx = np.concatenate(([t[0]],t[t2+1]))
return idx
# SIGNAL PROCESSING ###########################################################
def my_lpfilter(x, w0, N=4):
"""
create a lowpass Butterworth filter with a cutoff of w0 * the Nyquist rate.
The nice thing about this filter is that is has zero-phase distortion.
A conventional lowpass filter would introduce a phase lag.
w0 - filter cutoff; value between 0 and 1, where 1 corresponds to nyquist frequency.
So if you want a filter with cutoff at x Hz, the corresponding w0 value is given by
w0 = 2 * x / sampling_rate
N - order of filter
@Return:
low-pass filtered signal
See also my hp_filter, or my_bpfilter
"""
from scipy import signal
b,a = signal.butter(N, w0)
y = signal.filtfilt(b,a, x)
return y
def my_hpfilter(x, w0, N=4):
"""
create an N-th order highpass Butterworth filter with cutoff frequency w0 * sampling_rate/2
"""
from scipy import signal
# use scipy.signal.firwin to generate filter
#taps = signal.firwin(numtaps, w0, pass_zero=False)
#y = signal.lfilter(taps, 1.0, x)
b,a = signal.butter(N, w0, 'high')
y = signal.filtfilt(b,a, x, padlen = x.shape[0]-1)
return y
def my_bpfilter(x, w0, w1, N=4,bf=True):
"""
create N-th order bandpass Butterworth filter with corner frequencies
w0*sampling_rate/2 and w1*sampling_rate/2
"""
#from scipy import signal
#taps = signal.firwin(numtaps, w0, pass_zero=False)
#y = signal.lfilter(taps, 1.0, x)
#return y
from scipy import signal
b,a = signal.butter(N, [w0, w1], 'bandpass')
if bf:
y = signal.filtfilt(b,a, x)
else:
y = signal.lfilter(b,a, x)
return y
def my_notchfilter(x, sr=1000, band=5, freq=60, ripple=10, order=3, filter_type='butter'):
from scipy.signal import iirfilter,lfilter
fs = sr
nyq = fs/2.0
low = freq - band/2.0
high = freq + band/2.0
low = low/nyq
high = high/nyq
b, a = iirfilter(order, [low, high], rp=ripple, btype='bandstop',
analog=False, ftype=filter_type)
filtered_data = lfilter(b, a, x)
return filtered_data
def downsample_vec(x, nbin):
"""
y = downsample_vec(x, nbin)
downsample the vector x by replacing nbin consecutive \
bin by their mean \
@RETURN: the downsampled vector
"""
n_down = int(np.floor(len(x) / nbin))
x = x[0:n_down*nbin]
x_down = np.zeros((n_down,))
# 0 1 2 | 3 4 5 | 6 7 8
for i in range(nbin) :
idx = list(range(i, int(n_down*nbin), int(nbin)))
x_down += x[idx]
return x_down / nbin
def smooth_data(x, sig):
"""
y = smooth_data(x, sig)
smooth data vector @x with gaussian kernel
with standard deviation $sig
"""
sig = float(sig)
if sig == 0.0:
return x
# gaussian:
gauss = lambda x, sig : (1/(sig*np.sqrt(2.*np.pi)))*np.exp(-(x*x)/(2.*sig*sig))
bound = 1.0/10000
L = 10.
p = gauss(L, sig)
while (p > bound):
L = L+10
p = gauss(L, sig)
#F = map(lambda x: gauss((x, sig)), np.arange(-L, L+1.))
# py3:
F = [gauss(x, sig) for x in np.arange(-L, L+1.)]
F = F / np.sum(F)
return scipy.signal.fftconvolve(x, F, 'same')
def power_spectrum(data, length, dt):
"""
scipy's implementation of Welch's method using hanning window to estimate
the power spectrum
The function returns power density with units V**2/Hz
see also https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.signal.welch.html
The label on the y-axis should say PSD [V**2/Hz]
@Parameters
data - time series; float vector!
length - length of hanning window, even integer!
@Return:
power density, frequencies
The function returns power density in units V^2 / Hz
Note that
np.var(data) ~ np.sum(power density) * (frequencies[1]-frequencies[0])
"""
f, pxx = scipy.signal.welch(data, fs=1.0/dt, window='hanning', nperseg=int(length), noverlap=int(length/2))
return pxx, f
def spectral_density(data, length, nfft, dt):
"""
calculate the spectrogram for the time series given by data with time resolution dt
The powerspectrum for each window of length $length is computed using
Welch's method.
The windows for the powerspectrum calculation are half-overlapping. If length contains 5s of data,
then the first windows goes from 0s to 5s, the second window from 2.5 to 7.5s, ...
The last window ends at ceil(len(data)/length)*5s
Another example, assume we have 13 s of data, with 5 s windows, the the powerdensity is calculated for the following
time windows:
0 -- 5, 2.5 -- 7.5, 5 -- 10, 7.5 -- 12.5, 10 -- 15
In total there are thus 2*ceil(13/5)-1 = 5 windows
The last window starts at 2*3-2 * (5/2) = 10 s
Note: the returned time axis starts at time point goes from 0 to 10s in 2.5s steps
@Parameters:
data - time series
length - window length of data used to calculate powerspectrum.
Note that the time resolution of the spectrogram is length/2
nfft - size of the window used to calculate the powerspectrum.
determines the frequency resolution.
@Return:
Powspectrum, frequencies, time axis
"""
n = len(data)
k = int(np.ceil((1.0*n)/length))
data = np.concatenate((data, np.zeros((length*k-n,))))
fdt = length*dt/2 # time step for spectrogram
t = np.arange(0, fdt*(2*k-2)+fdt/2.0, fdt)
# frequency axis of spectrogram
f = np.linspace(0, 1, int(np.ceil(nfft/2.0))+1) * (0.5/dt)
# the power spectrum is calculated for 2*k-1 time points
Pow = np.zeros((len(f), k*2-1))
j = 0
for i in range(0, k-2+1):
w1=data[(length*i):(i+1)*length]
w2=data[length*i+int(length/2):(i+1)*length+int(length/2)]
Pow[:,j] = power_spectrum(w1, nfft, dt)[0]
Pow[:,j+1] = power_spectrum(w2, nfft, dt)[0]
j += 2
# last time point
Pow[:,j],f = power_spectrum(data[length*(k-1):k*length], nfft, dt)
return Pow, f, t
def calculate_spectrum(ppath, name, fres=0.5):
"""
calculate EEG and EMG spectrogram used for sleep stage detection.
Function assumes that data vectors EEG.mat and EMG.mat exist in recording
folder ppath/name; these are used to calculate the powerspectrum
fres - resolution of frequency axis
all data saved in "true" mat files
:return EEG Spectrogram, EMG Spectrogram, frequency axis, time axis
"""
SR = get_snr(ppath, name)
swin = round(SR)*5
fft_win = round(swin/5) # approximate number of data points per second
if (fres == 1.0) or (fres == 1):
fft_win = int(fft_win)
elif fres == 0.5:
fft_win = 2*int(fft_win)
else:
print("Resolution %f not allowed; please use either 1 or 0.5" % fres)
(peeg2, pemg2) = (False, False)
# Calculate EEG spectrogram
EEG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EEG.mat'))['EEG'])
Pxx, f, t = spectral_density(EEG, int(swin), int(fft_win), 1/SR)
if os.path.isfile(os.path.join(ppath, name, 'EEG2.mat')):
peeg2 = True
EEG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EEG2.mat'))['EEG2'])
Pxx2, f, t = spectral_density(EEG, int(swin), int(fft_win), 1/SR)
#save the stuff to a .mat file
spfile = os.path.join(ppath, name, 'sp_' + name + '.mat')
if peeg2 == True:
so.savemat(spfile, {'SP':Pxx, 'SP2':Pxx2, 'freq':f, 'dt':t[1]-t[0],'t':t})
else:
so.savemat(spfile, {'SP':Pxx, 'freq':f, 'dt':t[1]-t[0],'t':t})
# Calculate EMG spectrogram
EMG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EMG.mat'))['EMG'])
Qxx, f, t = spectral_density(EMG, int(swin), int(fft_win), 1/SR)
if os.path.isfile(os.path.join(ppath, name, 'EMG2.mat')):
pemg2 = True
EMG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EMG2.mat'))['EMG2'])
Qxx2, f, t = spectral_density(EMG, int(swin), int(fft_win), 1/SR)
# save the stuff to .mat file
spfile = os.path.join(ppath, name, 'msp_' + name + '.mat')
if pemg2 == True:
so.savemat(spfile, {'mSP':Qxx, 'mSP2':Qxx2, 'freq':f, 'dt':t[1]-t[0],'t':t})
else:
so.savemat(spfile, {'mSP':Qxx, 'freq':f, 'dt':t[1]-t[0],'t':t})
return Pxx, Qxx, f, t
def whiten_spectrogram(ppath, name, fmax=50):
"""
experimental
:param ppath:
:param name:
:param fmax:
:return:
"""
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'), squeeze_me=True)
SPE = P['SP']
freq = P['freq']
ifreq = np.where(freq <= fmax)[0]
SPE = SPE[ifreq,:]
nfilt = 5
filt = np.ones((nfilt, nfilt))
filt = np.divide(filt, filt.sum())
#SPE = scipy.signal.convolve2d(SPE, filt, boundary='symm', mode='same')
m = np.mean(SPE,axis=1)
SPE -= np.tile(m, (SPE.shape[1], 1)).T
SPE = SPE.T
C = np.dot(SPE.T, SPE)
[evals, L] = np.linalg.eigh(C)
idx = np.argsort(evals)
D = np.diag(np.sqrt(evals[idx]))
L = L[:,idx]
W = np.dot(L, np.dot(np.linalg.inv(D),np.dot(L.T,SPE.T)))
nfilt = 2
filt = np.ones((nfilt,nfilt))
filt = np.divide(filt, filt.sum())
W = scipy.signal.convolve2d(W, filt, boundary='symm', mode='same')
return W, D, L
def normalize_spectrogram(ppath, name, fmax=0, band=[], vm=5, pplot=True, sptype='', filt_dim=[]):
"""
Normalize EEG spectrogram by deviding each frequency band by its average value.
:param ppath, name: base folder, recording name
:param fmax: maximum frequency; frequency axis of spectrogram goes from 0 to fmax
if fmax=0, use complete frequency axis
:param band: list or tuple, define lower and upper range of a frequency band,
if pplot=True, plot band, along with spectrogram;
if band=[], disregard
:param vm: color range for plotting spectrogram
:pplot: if True, plot spectrogram along with power band
:sptype: if sptype='fine' plot 'special' spectrogram, save under sp_fine_$name.mat;
otherwise plot 'normal' spectrogram sp_$name.mat
:filt_dim: list or tuple; the two values define the dimensions of box filter
used to filter the normalized spectrogram; if filt_dim=[], then no filtering
:return SPE, t, freq: normalized spectrogram (np.array), time axis, frequency axis
"""
if (len(sptype) == 0) or (sptype=='std'):
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'), squeeze_me=True)
elif sptype == 'fine':
P = so.loadmat(os.path.join(ppath, name, 'sp_fine_' + name + '.mat'), squeeze_me=True)
SPE = P['SP']
freq = P['freq']
t = P['t']
if fmax > 0:
ifreq = np.where(freq <= fmax)[0]
else:
ifreq = np.arange(0, len(freq))
freq = freq[ifreq]
nfilt = 4
filt = np.ones((nfilt,nfilt))
filt = np.divide(filt, filt.sum())
SPE = SPE[ifreq,:]
# before
#SPE = SPE[ifreq]
#W = scipy.signal.convolve2d(SPE, filt, boundary='symm', mode='same')
#sp_mean = W.mean(axis=1)
sp_mean = SPE.mean(axis=1)
SPE = np.divide(SPE, np.tile(sp_mean, (SPE.shape[1], 1)).T)
if len(filt_dim) > 0:
filt = np.ones(filt_dim)
filt = np.divide(filt, filt.sum())
SPE = scipy.signal.convolve2d(SPE, filt, boundary='symm', mode='same')
# get high gamma peaks
if len(band) > 0:
iband = np.where((freq >= band[0]) & (freq <= band[-1]))[0]
pow_band = SPE[iband,:].mean(axis=0)
thr = pow_band.mean() + pow_band.std()
idx = np.where(pow_band > thr)[0]
# plot normalized spectrogram, along with band
if pplot:
plt.ion()
plt.figure()
if len(band) > 0:
med = np.median(SPE.mean(axis=0))
ax1 = plt.subplot(211)
plt.pcolormesh(t, freq, SPE, vmin=0, vmax=vm*med, cmap='jet')
plt.subplot(212, sharex=ax1)
plt.plot(t,SPE[iband,:].mean(axis=0))
plt.plot(t[idx], pow_band[idx], '.')
plt.draw()
return SPE, t, freq[ifreq]
def recursive_spectrogram(ppath, name, sf=0.3, alpha=0.3, pplot=True):
"""
calculate EEG/EMG spectrogram in a way that can be implemented by a closed-loop system.
The spectrogram is temporally filtered using a recursive implementation of a lowpass filter
@Parameters:
ppath/name - mouse EEG recording
sf - smoothing factor along frequency axis
alpha - temporal lowpass filter time constant
pplot - if pplot==True, plot figure
@Return:
SE, SM - EEG, EMG spectrogram
"""
EEG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EEG.mat'))['EEG'])
EMG = np.squeeze(so.loadmat(os.path.join(ppath, name, 'EMG.mat'))['EMG'])
len_eeg = len(EEG)
fdt = 2.5
SR = get_snr(ppath, name)
# we calculate the powerspectrum for 5s windows
swin = int(np.round(SR) * 5.0)
# but we sample new data each 2.5 s
swinh = int(swin/2.0)
fft_win = int(swin / 5.0)
# number of 2.5s long samples
spoints = int(np.floor(len_eeg / swinh))
SE = np.zeros((int(fft_win/2+1), spoints))
SM = np.zeros((int(fft_win/2+1), spoints))
print("Starting calculating spectrogram for %s..." % name)
for i in range(2, spoints):
# we take the last two swinh windows (the new 2.5 s long sample and the one from
# the last iteration)
x = EEG[(i-2)*swinh:i*swinh]
[p, f] = power_spectrum(x.astype('float'), fft_win, 1.0/SR)
p = smooth_data(p, sf)
# recursive low pass filtering of spectrogram:
# the current state is an estimate of the current sample and the previous state
SE[:,i] = alpha*p + (1-alpha) * SE[:,i-1]
# and the same of EMG
x = EMG[(i-2)*swinh:i*swinh]
[p, f] = power_spectrum(x.astype('float'), fft_win, 1.0/SR)
p = smooth_data(p, sf)
SM[:,i] = alpha*p + (1-alpha) * SM[:,i-1]
if pplot:
# plot EEG spectrogram
t = np.arange(0, SM.shape[1])*fdt
plt.figure()
ax1 = plt.subplot(211)
im = np.where((f>=0) & (f<=30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im,:]), vmin=0, vmax=med*2)
plt.xticks(())
ix = list(range(0, 30, 10))
fi = f[im][::-1]
plt.yticks(ix, list(map(int, fi[ix])))
box_off(ax1)
plt.axis('tight')
plt.ylabel('Freq (Hz)')
# plot EMG amplitude
ax2 = plt.subplot(212)
im = np.where((f>=10) & (f<100))[0]
df = np.mean(np.diff(f))
# amplitude is the square root of the integral
ax2.plot(t, np.sqrt(SM[im,:].sum(axis=0)*df)/1000.0)
plt.xlim((0, t[-1]))
plt.ylabel('EMG Ampl (mV)')
plt.xlabel('Time (s)')
box_off(ax2)
plt.show(block=False)
return SE, SM, f
def recursive_sleepstate_rem(ppath, recordings, sf=0.3, alpha=0.3, past_mu=0.2, std_thdelta = 1.5, past_len=120, sdt=2.5, psave=False, xemg=False):
"""
predict a REM period only based on EEG/EMG history; the same algorithm is also used for
closed-loop REM sleep manipulation.
The algorithm uses for REM sleep detection a threshold on delta power, EMG power, and theta/delta power.
For theta/delta I use two thresholds: A hard (larger) threshold and a soft (lower) threshold. Initially,
theta/delta has to cross the hard threshold to initiate a REM period. Then, as long as,
theta/delta is above the soft threshold (and EMG power stays low) REM sleep continues.
@Parameters:
ppath base folder with recordings
recordings list of recordings
sf smoothing factor for each powerspectrum
alpha smoothing factor along time dimension
past_mu percentage (0 .. 1) of brain states that are allowed to have EMG power larger than threshold
during the last $past_len seconds
past_len window to calculate $past_mu
std_thdelta the hard theta/delta threshold is given by, mean(theta/delta) + $std_thdelta * std(theta/delta)
sdt time bin for brain sttate, typically 2.5s
psave if True, save threshold parameters to file.
"""
idf = re.split('_', recordings[0])[0]
# 02/05/2020 changed from int to float:
past_len = float(np.round(past_len/sdt))
# calculate spectrogram
(SE, SM) = ([],[])
for rec in recordings:
A,B, freq = recursive_spectrogram(ppath, rec, sf=sf, alpha=alpha)
SE.append(A)
SM.append(B)
# fuse lists SE and SM
SE = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SE))
if not xemg:
SM = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SM))
else:
SM = SE
# EEG, EMG bands
ntbins = SE.shape[1]
r_delta = [0.5, 4]
r_theta = [5,12]
# EMG band
r_mu = [300, 500]
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
pow_delta = np.sum(SE[i_delta,:], axis=0)
pow_theta = np.sum(SE[i_theta,:], axis=0)
pow_mu = np.sum(SM[i_mu,:], axis=0)
# theta/delta
th_delta = np.divide(pow_theta, pow_delta)
thr_th_delta1 = np.nanmean(th_delta) + std_thdelta*np.nanstd(th_delta)
thr_th_delta2 = np.nanmean(th_delta) + 0.0*np.nanstd(th_delta)
thr_delta = pow_delta.mean()
thr_mu = pow_mu.mean() + 0.5*np.nanstd(pow_mu)
### The actual algorithm for REM detection
rem_idx = np.zeros((ntbins,))
prem = 0 # whether or not we are in REM
for i in range(ntbins):
if prem == 0 and pow_delta[i] < thr_delta and pow_mu[i] < thr_mu:
### could be REM
if th_delta[i] > thr_th_delta1:
### we are potentially entering REM
if (i - past_len) >= 0:
sstart = int(i-past_len)
else:
sstart = 0
# count the percentage of brainstate bins with elevated EMG power
c_mu = np.sum( np.where(pow_mu[sstart:i]>thr_mu)[0] ) / (past_len*1.0)
if c_mu < past_mu:
### we are in REM
prem = 1 # turn laser on
rem_idx[i] = 1
# We are currently in REM; do we stay there?
if prem == 1:
### REM continues, if theta/delta is larger than soft threshold and if there's
### no EMG activation
if (th_delta[i] > thr_th_delta2) and (pow_mu[i] < thr_mu):
rem_idx[i] = 1
else:
prem = 0 #turn laser off
# for loop ends
# Determine which channel is EEG, EMG
ch_alloc = get_infoparam(os.path.join(ppath, recordings[0], 'info.txt'), 'ch_alloc')[0]
# plot the whole stuff:
# (1) spectrogram
# (2) EMG Power
# (3) Delta
# (4) TH_Delta
plt.figure()
t = np.arange(0, sdt*(ntbins-1)+sdt/2.0, sdt)
ax1 = plt.subplot(411)
im = np.where((freq>=0) & (freq<=30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im,:]), vmin=0, vmax=med*2)
plt.yticks(list(range(0, 31, 10)), list(range(30, -1, -10)))
plt.ylabel('Freq. (Hz)')
plt.axis('tight')
ax2 = plt.subplot(412)
ax2.plot(t, pow_mu, color='black')
ax2.plot(t, np.ones((len(t),))*thr_mu, color='red')
plt.ylabel('EMG Pow.')
plt.xlim((t[0], t[-1]))
ax3 = plt.subplot(413, sharex=ax2)
ax3.plot(t, pow_delta, color='black')
ax3.plot(t, np.ones((len(t),))*thr_delta, color='red')
plt.ylabel('Delta Pow.')
plt.xlim((t[0], t[-1]))
ax4 = plt.subplot(414, sharex=ax3)
ax4.plot(t, th_delta, color='black')
ax4.plot(t, np.ones((len(t),))*thr_th_delta1, color='red')
ax4.plot(t, np.ones((len(t),))*thr_th_delta2, color='pink')
ax4.plot(t, rem_idx*thr_th_delta1, color='blue')
plt.ylabel('Theta/Delta')
plt.xlabel('Time (s)')
plt.xlim((t[0], t[-1]))
plt.show(block=False)
# write config file
if psave:
cfile = os.path.join(ppath, idf + '_rem.txt')
fid = open(cfile, 'w')
fid.write(('IDF: %s'+os.linesep) % idf)
fid.write(('ch_alloc: %s'+os.linesep) % ch_alloc)
fid.write(('THR_DELTA: %.2f'+os.linesep) % thr_delta)
fid.write(('THR_MU: %.2f'+os.linesep) % thr_mu)
fid.write(('THR_TH_DELTA: %.2f %.2f'+os.linesep) % (thr_th_delta1, thr_th_delta2))
fid.write(('STD_THDELTA: %.2f'+os.linesep) % std_thdelta)
fid.write(('PAST_MU: %.2f'+os.linesep) % past_mu)
fid.write(('SF: %.2f'+os.linesep) % sf)
fid.write(('ALPHA: %.2f'+os.linesep) % alpha)
fid.write(('Bern: %.2f' + os.linesep) % 0.5)
if xemg:
fid.write(('XEMG: %d'+os.linesep) % 1)
else:
fid.write(('XEMG: %d' + os.linesep) % 0)
fid.close()
print('wrote file %s' % cfile)
def recursive_sleepstate_rem_control(ppath, recordings, past_len=120, sdt=2.5, delay=120):
"""
algorithm running laser control for REM sleep dependent activation/inhibtion.
$delay s after a detected REM sleep period, the laser is turned on for the same duration. If a new REM period starts,
the laser stops, but we keep track of the missing time. The next time is laser turns on again,
it stays on for the duration of the most recent REM period + the remaining time.
The algorithm for REM detection is the same as used forclosed-loop REM sleep manipulation.
The function reads in the required parameters from the configuration file (MOUSEID_rem.txt)
The algorithm uses for REM sleep detection a threshold on delta power, EMG power, and theta/delta power.
For theta/delta I use two thresholds: A hard (larger) threshold and a soft (lower) threshold. Initially,
theta/delta has to cross the hard threshold to initiate a REM period. Then, as long as,
theta/delta is above the soft threshold (and EMG power stays low) REM sleep continues.
@Parameters:
ppath base folder with recordings
recordings list of recordings
past_len window to calculate $past_mu
sdt time bin for brain sttate, typically 2.5s
delay delay to wait after a REM sleep periods ends, till the laser is turned on.
"""
idf = re.split('_', recordings[0])[0]
past_len = int(np.round(past_len/sdt))
# load parameters
cfile = os.path.join(ppath, idf + '_rem.txt')
params = load_sleep_params(ppath, cfile)
thr_th_delta1 = params['THR_TH_DELTA'][0]
thr_th_delta2 = params['THR_TH_DELTA'][1]
thr_delta = params['THR_DELTA'][0]
thr_mu = params['THR_MU'][0]
alpha = params['ALPHA'][0]
sf = params['SF'][0]
past_mu = params['PAST_MU'][0]
xemg = params['XEMG'][0]
# calculate spectrogram
(SE, SM) = ([], [])
for rec in recordings:
A, B, freq = recursive_spectrogram(ppath, rec, sf=sf, alpha=alpha)
SE.append(A)
SM.append(B)
# fuse lists SE and SM
SE = np.squeeze(reduce(lambda x, y: np.concatenate((x, y)), SE))
if not xemg:
SM = np.squeeze(reduce(lambda x, y: np.concatenate((x, y)), SM))
else:
SM = SE
# EEG, EMG bands
ntbins = SE.shape[1]
r_delta = [0.5, 4]
r_theta = [5, 12]
# EMG band
r_mu = [300, 500]
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
pow_delta = np.sum(SE[i_delta, :], axis=0)
pow_theta = np.sum(SE[i_theta, :], axis=0)
pow_mu = np.sum(SM[i_mu, :], axis=0)
th_delta = np.divide(pow_theta, pow_delta)
### The actual algorithm for REM detection
rem_idx = np.zeros((ntbins,))
prem = 0 # whether or not we are in REM
# NEW variables:
laser_idx = np.zeros((ntbins,))
delay = int(np.round(delay/sdt))
delay_count = 0
curr_rem_dur = 0
dur_count = 0
on_delay = False
laser_on = False
for i in range(ntbins):
if prem == 0 and pow_delta[i] < thr_delta and pow_mu[i] < thr_mu:
### could be REM
if th_delta[i] > thr_th_delta1:
### we are potentially entering REM
if (i - past_len) >= 0:
sstart = i - past_len
else:
sstart = 0
# count the percentage of brainstate bins with elevated EMG power
c_mu = np.sum(np.where(pow_mu[sstart:i] > thr_mu)[0]) / past_len
if c_mu < past_mu:
### we are in REM
prem = 1 # turn laser on
rem_idx[i] = 1
curr_rem_dur += 1 #NEW
# We are currently in REM; do we stay there?
if prem == 1:
### REM continues, if theta/delta is larger than soft threshold and if there's
### no EMG activation
if (th_delta[i] > thr_th_delta2) and (pow_mu[i] < thr_mu):
rem_idx[i] = 1
curr_rem_dur += 1
else:
prem = 0 # turn laser off
dur_count += curr_rem_dur #NEW
delay_count = delay #NEW
curr_rem_dur = 0 #NEW
on_delay = True #NEW
# NEW:
if on_delay:
if prem == 0:
delay_count -=1
if delay_count == 0:
laser_on = True
on_delay = False
if laser_on:
if prem == 0:
if dur_count >= 0:
dur_count -= 1
laser_idx[i] = 1
else:
laser_on = False
else:
laser_on = False
# plot the whole stuff:
# (1) spectrogram
# (2) EMG Power
# (3) Delta
# (4) TH_Delta
plt.figure()
t = np.arange(0, sdt*(ntbins-1)+sdt/2.0, sdt)
ax1 = plt.subplot(411)
im = np.where((freq>=0) & (freq<=30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im,:]), vmin=0, vmax=med*2)
plt.yticks(list(range(0, 31, 10)), list(range(30, -1, -10)))
plt.ylabel('Freq. (Hz)')
plt.axis('tight')
ax2 = plt.subplot(412)
ax2.plot(t, pow_mu, color='black')
ax2.plot(t, np.ones((len(t),))*thr_mu, color='red')
plt.ylabel('EMG Pow.')
plt.xlim((t[0], t[-1]))
ax3 = plt.subplot(413, sharex=ax2)
ax3.plot(t, pow_delta, color='black')
ax3.plot(t, np.ones((len(t),))*thr_delta, color='red')
plt.ylabel('Delta Pow.')
plt.xlim((t[0], t[-1]))
ax4 = plt.subplot(414, sharex=ax3)
ax4.plot(t, th_delta, color='black')
ax4.plot(t, np.ones((len(t),))*thr_th_delta1, color='red')
ax4.plot(t, np.ones((len(t),))*thr_th_delta2, color='pink')
ax4.plot(t, rem_idx*thr_th_delta1, color='green', label='REM')
ax4.plot(t, laser_idx * thr_th_delta1, color='blue', label='Laser')
plt.ylabel('Theta/Delta')
plt.xlabel('Time (s)')
plt.xlim((t[0], t[-1]))
plt.legend()
plt.show(block=False)
def load_sleep_params(path, param_file):
"""
load parameter file generated by &recursive_sleepstate_rem || &recursive_sleepstate_nrem
@Return:
Dictionary: Parameter --> Value
"""
fid = open(os.path.join(path, param_file), 'r')
lines = fid.readlines()
params = {}
for line in lines:
if re.match('^[\S_]+:', line):
a = re.split('\s+', line)
key = a[0][:-1]
params[key] = a[1:-1]
# transform number strings to floats
for k in params:
vals = params[k]
new_vals = []
for v in vals:
if re.match('^[\d\.]+$', v):
new_vals.append(float(v))
else:
new_vals.append(v)
params[k] = new_vals
return params
def recursive_sleepstate_nrem(ppath, recordings, sf=0.3, alpha=0.3, std_thdelta = 1.5, sdt=2.5, psave=False, xemg=False):
"""
predict NREMs period only based on EEG/EMG history; the same algorithm is also used for
closed-loop NREM sleep manipulation.
The algorithm uses for NREM sleep detection thresholds for delta power, EMG power, and theta/delta power.
For delta I use two thresholds: A hard (larger) threshold and a soft (lower) threshold. Initially,
theta/delta has to cross the hard threshold to initiate a NREM period. Then, as long as,
theta/delta is above the soft threshold (and EMG power stays low) REM sleep continues.
The values for hard and soft threshold are fitted using a Gaussian mixture model
:param ppath: base folder
:param recordings: list of recordings
:param sf: smoothing factor for each powerspectrum
:param alpha: spatial smoothing factor
:param std_thdelta: factor to set threshold for theta/delta
:param sdt: time step of brain state classification, typically 2.5 s
:param psave: save parameters to text file?
:param xemg: use EEG instead of EMG?
"""
# to fit Gaussian mixture model to delta power distributino
from sklearn import mixture
idf = re.split('_', recordings[0])[0]
# calculate spectrogram
(SE, SM) = ([],[])
for rec in recordings:
A,B, freq = recursive_spectrogram(ppath, rec, sf=sf, alpha=alpha)
SE.append(A)
SM.append(B)
# fuse lists SE and SM
SE = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SE))
if not xemg:
SM = np.squeeze(reduce(lambda x,y: np.concatenate((x,y)), SM))
else:
SM = SE
# EEG, EMG bands
ntbins = SE.shape[1]
r_delta = [0.5, 4]
r_theta = [5,12]
# EMG band
r_mu = [300, 500]
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
pow_delta = np.sum(SE[i_delta,:], axis=0)
pow_theta = np.sum(SE[i_theta,:], axis=0)
pow_mu = np.sum(SM[i_mu,:], axis=0)
# theta/delta
th_delta = np.divide(pow_theta, pow_delta)
thr_th_delta1 = np.nanmean(th_delta) + std_thdelta*np.nanstd(th_delta)
thr_th_delta2 = np.nanmean(th_delta) + 0.0*np.nanstd(th_delta)
thr_mu = pow_mu.mean() + 0.5*np.nanstd(pow_mu)
med_delta = np.median(pow_delta)
pow_delta_fit = pow_delta[np.where(pow_delta<=3*med_delta)]
# fit Gaussian mixture model to delta power
# see http://www.astroml.org/book_figures/chapter4/fig_GMM_1D.html
gm = mixture.GaussianMixture(n_components=2)
fit = gm.fit(pow_delta_fit.reshape(-1, 1))
means = np.squeeze(fit.means_)
x = np.arange(0, med_delta*3, 100)
plt.figure()
plt.hist(pow_delta_fit, 100, normed=True, histtype='stepfilled', alpha=0.4)
logprob = fit.score_samples(x.reshape(-1,1))
responsibilities = fit.predict_proba(x.reshape((-1,1)))
pdf = np.exp(logprob)
pdf_individual = responsibilities * pdf[:, np.newaxis]
plt.plot(x, pdf, '-k')
plt.plot(x, pdf_individual, '--k')
plt.xlim((0, med_delta*3))
plt.ylabel('p(x)')
plt.xlabel('x = Delta power')
# get point where curves cut each other
if means[0] < means[1]:
idx = np.where((x>= means[0]) & (x<= means[1]))[0]
else:
idx = np.where((x >= means[1]) & (x <= means[0]))[0]
imin = np.argmin(pdf[idx])
xcut = x[idx[0]+imin]
plt.plot(xcut, pdf[idx[0]+imin], 'ro')
ilow = np.argmin(np.abs(x-means[0]))
plt.plot(x[ilow], pdf[ilow], 'bo')
ihigh = np.argmin(np.abs(x-means[1]))
plt.plot(x[ihigh], pdf[ihigh], 'go')
plt.show(block=False)
# set parameters for hard and soft delta thresholds
tmp = np.array([x[ihigh], xcut, x[ilow]])
tmp.sort()
thr_delta1 = tmp[-1] # x[ihigh]; right peak of distribution
thr_delta2 = tmp[1] # trough of distribution
# NREM yes or no according to thresholds
# However, this variable does not directly control whether laser should
# be on or off; whether NREM sleep is really on or off is determined
# by nrem_idx; if pnrem_hidden == 1, then all threshold critera, but not
# sleep history criteria are fulfilled
pnrem_hidden = 0
# if nrem_idx[i] == 1, time point i is NREM
nrem_idx = np.zeros((ntbins,), dtype='int8')
# NREM stays on after thresholds are NOT fulfilled to avoid interruptions by microarousals
grace_period = int(20 / sdt)
# nrem_delay: NREM only starts with some delay
nrem_delay = int(10 / sdt)
grace_count = grace_period
delay_count = nrem_delay
for i in range(ntbins):
if pnrem_hidden == 0:
### Entering NREM:
# Delta power laser than high threshold
if pow_delta[i] > thr_delta1 and pow_mu[i] < thr_mu and th_delta[i] < thr_th_delta1:
### NOT-NREM -> NREM
pnrem_hidden = 1
nrem_idx[i] = 0
delay_count -= 1
# we are fully in NREM, that's why grace_count is reset:
grace_count = grace_period
else:
### NOT-NREM -> NOT-NREM
if grace_count > 0:
grace_count -= 1
nrem_idx[i] = 1
else:
nrem_idx[i] = 0
else:
### pnrem_hidden == 1
if pow_delta[i] > thr_delta2 and pow_mu[i] < thr_mu and th_delta[i] < thr_th_delta1:
if delay_count > 0:
delay_count -= 1
nrem_idx[i] = 0
else :
nrem_idx[i] = 1
else:
### Exit NREM -> NOT-NREM
# were are fully out of NREM, so delay_count can be reset:
delay_count = nrem_delay
pnrem_hidden = 0
if grace_count > 0:
grace_count -= 1
nrem_idx[i] = 1
#### figure ##############################################
plt.figure()
t = np.arange(0, sdt * (ntbins - 1) + sdt / 2.0, sdt)
ax1 = plt.subplot(411)
im = np.where((freq >= 0) & (freq <= 30))[0]
med = np.median(SE.max(axis=0))
ax1.imshow(np.flipud(SE[im, :]), vmin=0, vmax=med * 2, cmap='jet')
ax1.pcolorfast(t, freq[im], np.flipud(SE[im, :]), vmin=0, vmax=med * 2, cmap='jet')
plt.yticks(list(range(0, 31, 10)), list(range(30, -1, -10)))
plt.ylabel('Freq. (Hz)')
plt.axis('tight')
ax2 = plt.subplot(412, sharex=ax1)
ax2.plot(t, pow_mu, color='black')
ax2.plot(t, np.ones((len(t),)) * thr_mu, color='red')
plt.ylabel('EMG Pow.')
plt.xlim((t[0], t[-1]))
ax3 = plt.subplot(413, sharex=ax2)
ax3.plot(t, pow_delta, color='black')
ax3.plot(t, np.ones((len(t),)) * thr_delta1, color='red')
ax3.plot(t, np.ones((len(t),)) * thr_delta2, color=[1, 0.6, 0.6])
ax3.plot(t, nrem_idx * thr_delta1, color=[0.6, 0.6, 0.6])
plt.ylabel('Delta Pow.')
plt.xlim((t[0], t[-1]))
ax4 = plt.subplot(414, sharex=ax3)
ax4.plot(t, th_delta, color='black')
ax4.plot(t, np.ones((len(t),)) * thr_th_delta1, color='red')
plt.ylabel('Theta/Delta')
plt.xlabel('Time (s)')
plt.xlim((t[0], t[-1]))
plt.show(block=False)
# Determine which channel is EEG, EMG
ch_alloc = get_infoparam(os.path.join(ppath, recordings[0], 'info.txt'), 'ch_alloc')[0]
# write config file
if psave:
cfile = os.path.join(ppath, idf + '_nrem.txt')
fid = open(cfile, 'w')
fid.write(('IDF: %s' + os.linesep) % idf)
fid.write(('ch_alloc: %s' + os.linesep) % ch_alloc)
fid.write(('THR_DELTA: %.2f %.2f' + os.linesep) % (thr_delta1, thr_delta2))
fid.write(('THR_MU: %.2f' + os.linesep) % thr_mu)
fid.write(('THR_TH_DELTA: %.2f %.2f' + os.linesep) % (thr_th_delta1, thr_th_delta2))
fid.write(('STD_THDELTA: %.2f' + os.linesep) % std_thdelta)
fid.write(('SF: %.2f' + os.linesep) % sf)
fid.write(('ALPHA: %.2f' + os.linesep) % alpha)
if xemg:
fid.write(('XEMG: %d' + os.linesep) % 1)
else:
fid.write(('XEMG: %d' + os.linesep) % 0)
fid.close()
print('wrote file %s' % cfile)
def rem_online_analysis(ppath, recordings, backup='', single_mode=False, fig_file='', overlap=0):
"""
analyze results from closed-loop experiments
:param ppath: base folder
:param recordings: list of strings, recordinds
:param backup: string, potential second backup folder with recordings
:param single_mode: boolean, if True, average across all REM periods (irrespective of mouse)
and plot each single REM period as dot
:param overlap: float between 0 and 100; specifices percentage by which the online detected REM period has to
overlap with real (annotated) REM period to be further consided for analysis;
if overlap == 0, then any overlap counts, i.e. this parameter has no influence
:return: df, pd.DataFrame, with control and experimental REM durations as data columns
"""
if type(recordings) != list:
recordings = [recordings]
overlap = overlap / 100.0
paths = dict()
for rec in recordings:
if os.path.isdir(os.path.join(ppath, rec)):
paths[rec] = ppath
else:
paths[rec] = backup
mice = dict()
for rec in recordings:
idf = re.split('_', rec)[0]
if not idf in mice:
mice[idf] = 1
mice = list(mice.keys())
if len(mice) == 1:
single_mode=True
dur_exp = {m:[] for m in mice}
dur_ctr = {m:[] for m in mice}
for rec in recordings:
idf = re.split('_', rec)[0]
M,S = load_stateidx(paths[rec], rec)
sr = get_snr(paths[rec], rec)
nbin = int(np.round(sr)*2.5)
dt = (1.0/sr)*nbin
laser = load_laser(paths[rec], rec)
rem_trig = so.loadmat(os.path.join(paths[rec], rec, 'rem_trig_%s.mat'%rec), squeeze_me=True)['rem_trig']
laser = downsample_vec(laser, nbin)
laser[np.where(laser>0)] = 1
rem_trig = downsample_vec(rem_trig, nbin)
rem_trig[np.where(rem_trig>0)] = 1
laser_idx = np.where(laser==1)[0]
rem_idx = np.where(rem_trig==1)[0]
# REM sequences from offline analysis (assumed to be the
# "ground truth"
seq = get_sequences(np.where(M==1)[0])
for s in seq:
# check true REM sequences overlapping with online detected sequences
isect = np.intersect1d(s, rem_idx)
#print(len(isect)/ len(s))
# test if real REM period s overlaps with online detected REM periods and,
# if yes, make sure that the overlap is at least overlap *100 percent
if len(np.intersect1d(s, rem_idx)) > 0 and float(len(isect)) / len(s) >= overlap:
drn = (s[-1]-s[0]+1)*dt
# does the sequence overlap with laser?
if len(np.intersect1d(isect, laser_idx))>0:
dur_exp[idf].append(drn)
else:
dur_ctr[idf].append(drn)
data = {'exp':[], 'ctr':[]}
# if single_mode put all REM periods together,
# otherwise average across REM periods for each mouse
if len(mice) == 1 or single_mode==True:
for m in mice:
data['exp'] += dur_exp[m]
data['ctr'] += dur_ctr[m]
else:
for idf in dur_ctr:
dur_ctr[idf] = np.array(dur_ctr[idf]).mean()
dur_exp[idf] = np.array(dur_exp[idf]).mean()
data['exp'] = np.array(list(dur_exp.values()))
data['ctr'] = np.array(list(dur_ctr.values()))
df = pd.DataFrame({'ctr':pd.Series(data['ctr']), 'exp' : pd.Series(data['exp'])})
# plot everything
if not single_mode:
plt.ion()
plt.figure()
ax = plt.axes([0.2, 0.15, 0.3, 0.7])
df_mean = df.mean()
plt.bar([1], [df_mean['ctr']], color='grey', label='W/o Laser')
plt.bar([2], [df_mean['exp']], color='blue', label='With laser')
plt.xticks([1,2])
box_off(ax)
#ax.set_xticklabels(['ctr', 'exp'], rotation=30)
plt.ylabel('REM duration (s)')
for (a,b) in zip(df['ctr'], df['exp']):
plt.plot([1,2], [a,b], color='black')
plt.legend(bbox_to_anchor=(0., 1.0, 1., .102), loc=3, mode='expand', ncol=1, frameon=False)
else:
plt.figure()
ax = plt.axes([0.2, 0.15, 0.3, 0.7])
df_mean = df.mean()
plt.bar([1], [df_mean['ctr']], color='grey')
plt.bar([2], [df_mean['exp']], color='blue')
plt.xticks([1,2])
box_off(ax)
#ax.set_xticklabels(['ctr', 'exp'], rotation=30)
plt.ylabel('REM duration (s)')
a = df['ctr']
b = df['exp']
plt.plot(np.ones((len(a),)), a, '.', color='black', label='W/o Laser')
plt.plot(2*np.ones((len(b),)), b, '.', color='black', label='With laser')
plt.legend(bbox_to_anchor=(0., 1.0, 1., .102), loc=3, mode='expand', ncol=1, frameon=False)
plt.show()
if len(fig_file) > 0:
save_figure(fig_file)
return df
def online_homeostasis(ppath, recordings, backup='', mode=0, single_mode=False, pplot=True, overlap=0, ma_thr=0):
"""
Further analysis of data obtained from closed loop stimulation
Assume the sleep structure looks like this
R R R R W W N N N N N W W N N N N R R R R R
REM_pre -- inter REM ---- REM_post
REM_pre is the duration of the first REM period, inter-REM is everything between REM_pre and the
next REM period REM_post.
The function calculates the inter REM duration after REM periods with laser and after REM periods w/o laser
:param ppath: base folder
:param recordings: list of recording, or file listing
:param backup: backup folder for $ppath
:param mode: mode == 0, calculate complete inter REM duration
mode == 2, only calculate duration of wake in inter REM periods
mode == 3, only calculate duration of NREM in inter REM periods
:param single_mode: consider each single recording, instead of mice
:param overlap: percentage (number between 0 and 100). Defines the percentage
how much a true (offline annotated) REM period should overlap with laser
to be considered as REM sleep with laser.
Of note, REM periods w/o laser have to have 0 overlap with laser.
All remaining REM periods are discarded.
:param pplot: if True, plot figure; errorbars show 95% confidence intervals,
calculated using bootstrapping
:param ma:
:return: df, if single_mode == True $df is a pandas DataFrame:
REM iREM laser
mouse - mouse ID
REM - REM duration
iREM - inter REM duration after REM periods with laser
laser - 'y' or 'n'; depending on whether laser was on during REM sleep period (for "REM") or during the
preceding REM sleep period (for "iREM")
if single_mode == False, mouse is the data frame index
"""
if type(recordings) != list:
recordings = [recordings]
if overlap > 0:
overlap = overlap / 100
paths = dict()
for rec in recordings:
if os.path.isdir(os.path.join(ppath, rec)):
paths[rec] = ppath
else:
paths[rec] = backup
mice = dict()
for rec in recordings:
idf = re.split('_', rec)[0]
if not idf in mice:
mice[idf] = 1
mice = list(mice.keys())
if len(mice) == 1:
single_mode=True
remdur_exp = {m:[] for m in mice}
remdur_ctr = {m:[] for m in mice}
itdur_exp = {m:[] for m in mice}
itdur_ctr = {m:[] for m in mice}
for rec in recordings:
idf = re.split('_', rec)[0]
M = load_stateidx(paths[rec], rec)[0]
sr = get_snr(paths[rec], rec)
nbin = int(np.round(sr)*2.5)
dt = (1.0/sr)*nbin
if ma_thr>0:
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if len(s)*dt <= ma_thr:
M[s] = 3
laser = load_laser(paths[rec], rec)
rem_trig = so.loadmat(os.path.join(paths[rec], rec, 'rem_trig_%s.mat' % rec), squeeze_me=True)['rem_trig']
laser = downsample_vec(laser, nbin)
laser[np.where(laser>0)] = 1
rem_trig = downsample_vec(rem_trig, nbin)
rem_trig[np.where(rem_trig>0)] = 1
laser_idx = np.where(laser==1)[0]
rem_idx = np.where(rem_trig==1)[0]
# REM sequences from offline analysis (assumed to be the
# "ground truth"
seq = get_sequences(np.where(M==1)[0])
for (p,q) in zip(seq[0:-1], seq[1:]):
# check if true REM sequences do overlap with online detected sequences
# and only continue working with those:
if len(np.intersect1d(p, rem_idx)) > 0:
drn = (p[-1]-p[0]+1)*dt
it_M = M[p[-1]+1:q[0]]
if mode == 0:
it_drn = len(it_M)*dt
elif mode == 2:
it_drn = len(np.where(it_M==2)[0]) * dt
else:
it_drn = len(np.where(it_M == 3)[0]) * dt
# does the true REM sequence overlap with laser?
# by setting overlap to a value > 0, you can
# set a percentage how much the REM period should overlap with laser
# NEW 08/26/21
if len(np.intersect1d(p, laser_idx)) / len(p) > overlap:
remdur_exp[idf].append(drn)
itdur_exp[idf].append(it_drn)
elif len(np.intersect1d(p, laser_idx)) == 0:
remdur_ctr[idf].append(drn)
itdur_ctr[idf].append(it_drn)
else:
pass
# if single_mode put all REM periods together,
# otherwise average across REM periods for each mouse
if len(mice) == 1 or single_mode==True:
data = {'itexp':[], 'itctr':[], 'remexp':[], 'remctr':[]}
for m in mice:
data['itexp'] += itdur_exp[m]
data['itctr'] += itdur_ctr[m]
data['remexp'] += remdur_exp[m]
data['remctr'] += remdur_ctr[m]
df = pd.DataFrame({'REM': data['remexp']+data['remctr'], 'iREM':data['itexp']+data['itctr'], 'laser': ['y']*len(data['remexp']) + ['n']*len(data['remctr'])})
else:
for idf in mice:
itdur_ctr[idf] = np.array(itdur_ctr[idf]).mean()
itdur_exp[idf] = np.array(itdur_exp[idf]).mean()
remdur_ctr[idf] = np.array(remdur_ctr[idf]).mean()
remdur_exp[idf] = np.array(remdur_exp[idf]).mean()
data = {}
for s in ['itexp', 'itctr', 'remexp', 'remctr']:
data[s] = np.zeros((len(mice),))
i = 0
for m in mice:
data['itexp'][i] = itdur_exp[m]
data['itctr'][i] = itdur_ctr[m]
data['remexp'][i] = remdur_exp[m]
data['remctr'][i] = remdur_ctr[m]
i += 1
df = pd.DataFrame({'REM': np.concatenate((data['remexp'], data['remctr'])),
'iREM': np.concatenate((data['itexp'], data['itctr'])),
'laser': ['y']*len(mice) + ['n']*len(mice),
'mouse': mice+mice})
if pplot and not single_mode:
dfm = pd.melt(df, id_vars=['laser', 'mouse'], var_name='state')
sns.set_style('whitegrid')
plt.ion()
plt.figure()
sns.barplot(data=dfm, hue='laser', x='state', y='value', palette=['blue', 'gray'])
sns.swarmplot(data=dfm, hue='laser', x='state', y='value', dodge=True, color='black')
sns.despine()
plt.ylabel('Duration (s)')
if pplot and single_mode:
dfm = pd.melt(df, id_vars=['laser'], var_name='state')
plt.ion()
plt.figure()
sns.set(style="whitegrid")
#sns.swarmplot(data=df[['itctr', 'itexp']], color='black')
#sns.barplot(data=df[['itctr', 'itexp']], palette=['gray', 'blue'], errcolor='black')
sns.barplot(data=dfm, hue='laser', x='state', y='value', palette=['blue', 'gray'])
sns.swarmplot(data=dfm, hue='laser', x='state', y='value', dodge=True, color='black')
sns.despine()
plt.ylabel('Duration (s)')
return df
### FUNCTIONS USED BY SLEEP_STATE #####################################################
def get_sequences(idx, ibreak=1) :
"""
get_sequences(idx, ibreak=1)
idx - np.vector of indices
@RETURN:
seq - list of np.vectors
"""
diff = idx[1:] - idx[0:-1]
breaks = np.nonzero(diff>ibreak)[0]
breaks = np.append(breaks, len(idx)-1)
seq = []
iold = 0
for i in breaks:
r = list(range(iold, i+1))
seq.append(idx[r])
iold = i+1
return seq
def threshold_crossing(data, th, ilen, ibreak, m):
"""
seq = threshold_crossing(data, th, ilen, ibreak, m)
"""
if m>=0:
idx = np.where(data>=th)[0]
else:
idx = np.where(data<=th)[0]
# gather sequences
j = 0
seq = []
while (j <= len(idx)-1):
s = [idx[j]]
for k in range(j+1,len(idx)):
if (idx[k] - idx[k-1]-1) <= ibreak:
# add j to sequence
s.append(idx[k])
else:
break
if (s[-1] - s[0]+1) >= ilen and not(s[0] in [i[1] for i in seq]):
seq.append((s[0], s[-1]))
if j == len(idx)-1:
break
j=k
return seq
def closest_precessor(seq, i):
"""
find the preceding element in seq which is closest to i
helper function for sleep_state
"""
tmp = seq-i;
d = np.where(tmp<0)[0]
if len(d)>0:
id = seq[d[-1]];
else:
id = 0;
return id
def write_remidx(M, K, ppath, name, mode=1) :
"""
rewrite_remidx(idx, states, ppath, name)
replace the indices idx in the remidx file of recording name
with the assignment given in states
"""
if mode == 0 :
outfile = os.path.join(ppath, name, 'remidx_' + name + '.txt')
else :
outfile = os.path.join(ppath, name, 'remidx_' + name + '_corr.txt')
f = open(outfile, 'w')
s = ["%d\t%d\n" % (i,j) for (i,j) in zip(M[0,:],K)]
f.writelines(s)
f.close()
#######################################################################################
### MANIPULATING FIGURES ##############################################################
def set_fontsize(fs):
import matplotlib
matplotlib.rcParams.update({'font.size': fs})
def set_fontarial():
"""
set Arial as default font
"""
import matplotlib
matplotlib.rcParams['font.sans-serif'] = "Arial"
def save_figure(fig_file):
# alternative way of setting nice fonts:
#matplotlib.rcParams['pdf.fonttype'] = 42
#matplotlib.rcParams['ps.fonttype'] = 42
#matplotlib.pylab.savefig(fig_file, dpi=300)
#matplotlib.rcParams['text.usetex'] = False
#matplotlib.rcParams['text.usetex'] = True
plt.savefig(fig_file, bbox_inches="tight", dpi=200)
#matplotlib.rcParams['text.usetex'] = False
def box_off(ax):
"""
similar to Matlab's box off
"""
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
#######################################################################################
def sleep_state(ppath, name, th_delta_std=1, mu_std=0, sf=1, sf_delta=3, pwrite=0,
pplot=True, pemg=True, vmax=2.5, pspec_norm=False, use_idx=[]):
"""
automatic sleep state detection based on
delta, theta, sigma, gamma and EMG power.
New: use also sigma band: that's very helpful to classify pre-REM periods
as NREM; otherwise they tend to be classified as wake.
Gamma peaks nicely pick up during microarousals.
My strategy is the following:
I smooth delta band a lot to avoid strong fragmentation of sleep; but to
still pick up microarousals I use the gamma power.
spectrogram data has to be calculated before using calculate_spectrum
Each bin in the spectrogram gets assigned one of four states:
1-REM
2-Wake
3-NREM
0-undef
:param ppath: base folder
:param name: recording name
:param th_delta_std: threshold for theta/delta band is calculated as mean(theta/delta) + th_delta_std*std(theta/delta)
:param mu_std: threshold for EMG power is calculate as "mean(EMG) + mu_std * mean(EMG)
:param sf: smoothing factor for gamma and sigma power
:param sf_delta: smoothing factor for delta power
:param pwrite: if True, save sleep classification to file remidx_$name.txt
:param pplot: if True, plot figures
:param pemg: if True, use EMG as EMG, otherwise use EEG gamma power instead
:param vmax: float, set maximum of color range of EEG heatmap.
:param pspec_norm: boolean, if True, normalized EEG spectrogram by deviding each frequency band by its mean; only affects
plotting, no effect on sleep state calculation
:param use_idx: list, if not empty, use only given indices to calculate sleep state
:return:
"""
PRE_WAKE_REM = 30.0
# Minimum Duration and Break in
# high theta/delta, high emg, high delta, high sigma and gamma sequences
#
# duration[i,0] is the minimum duration of sequence of state i
# duration[i,1] is maximal break duration allowed in a sequence of state i
duration = np.zeros((5,2))
# high theta/delta
duration[0,:] = [5,15]
# high emg
duration[1,:] = [0, 5]
# high delta
duration[2,:] = [10, 10]
# high sigma
duration[3,:] = [10, 10]
# gamma
duration[4,:] = [0, 5]
# Frequency Bands/Ranges for delta, theta, and, gamma
r_delta = [0.5, 4]
r_sigma = [12, 20]
r_theta = [5,12]
# EMG band
r_mu = [50, 500]
if not pemg:
r_mu = [250, 500]
# high gamma power
r_gamma = [100, 150]
#load EEG and EMG spectrum, calculated by calculate_spectrum
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'))
if pemg:
Q = so.loadmat(os.path.join(ppath, name, 'msp_' + name + '.mat'))
else:
Q = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'))
SPEEG = np.squeeze(P['SP'])
if pemg == 1:
SPEMG = np.squeeze(Q['mSP'])
else:
SPEMG = np.squeeze(P['SP'])
if use_idx == []:
use_idx = range(0, SPEEG.shape[1])
freq = np.squeeze(P['freq'])
t = np.squeeze(P['t'])
dt = float(np.squeeze(P['dt']))
N = len(t)
duration = np.divide(duration,dt)
# get indices for frequency bands
i_delta = np.where((freq >= r_delta[0]) & (freq <= r_delta[1]))[0]
i_theta = np.where((freq >= r_theta[0]) & (freq <= r_theta[1]))[0]
i_mu = np.where((freq >= r_mu[0]) & (freq <= r_mu[1]))[0]
i_sigma = np.where((freq >= r_sigma[0]) & (freq <= r_sigma[1]))[0]
i_gamma = np.where((freq >= r_gamma[0]) & (freq <= r_gamma[1]))[0]
p_delta = smooth_data( SPEEG[i_delta,:].mean(axis=0), sf_delta )
p_theta = smooth_data( SPEEG[i_theta,:].mean(axis=0), 0 )
# now filtering for EMG to pick up microarousals
p_mu = smooth_data( SPEMG[i_mu,:].mean(axis=0), sf )
p_sigma = smooth_data( SPEEG[i_sigma,:].mean(axis=0), sf )
p_gamma = smooth_data( SPEEG[i_gamma,:].mean(axis=0), 0 )
th_delta = np.divide(p_theta, p_delta)
#th_delta = smooth_data(th_delta, 2);
seq = {}
seq['high_theta'] = threshold_crossing(th_delta, np.nanmean(th_delta[use_idx])+th_delta_std*np.nanstd(th_delta[use_idx]),
duration[0,1], duration[0,1], 1)
seq['high_emg'] = threshold_crossing(p_mu, np.nanmean(p_mu[use_idx])+mu_std*np.nanstd(p_mu[use_idx]),
duration[1,0], duration[1,1], 1)
seq['high_delta'] = threshold_crossing(p_delta, np.nanmean(p_delta[use_idx]), duration[2,0], duration[2,1], 1)
seq['high_sigma'] = threshold_crossing(p_sigma, np.nanmean(p_sigma[use_idx]), duration[3,0], duration[3,1], 1)
seq['high_gamma'] = threshold_crossing(p_gamma, np.nanmean(p_gamma[use_idx]), duration[4,0], duration[4,1], 1)
# Sleep-State Rules
idx = {}
for k in seq:
tmp = [list(range(i,j+1)) for (i,j) in seq[k]]
# now idea why this works to flatten a list
# idx[k] = sum(tmp, [])
# alternative that I understand:
if len(tmp) == 0:
idx[k] = np.array([])
else:
idx[k] = np.array(reduce(lambda x,y: x+y, tmp))
idx['low_emg'] = np.setdiff1d(np.arange(0,N), np.array(idx['high_emg']))
idx['low_delta'] = np.setdiff1d(np.arange(0,N), np.array(idx['high_delta']))
idx['low_theta'] = np.setdiff1d(np.arange(0,N), np.array(idx['high_theta']))
#REM Sleep: thdel up, emg down, delta down
a = np.intersect1d(idx['high_theta'], idx['low_delta'])
# non high_emg phases
b = np.setdiff1d(a, idx['high_emg'])
rem = get_sequences(b, duration[0,1])
rem_idx = reduce(lambda x,y: np.concatenate((x,y)), rem)
# SWS Sleep
# delta high, no theta, no emg
a = np.setdiff1d(idx['high_delta'], idx['high_emg']) # no emg activation
b = np.setdiff1d(a, idx['high_theta']) # no theta;
sws = get_sequences(b)
sws_idx = reduce(lambda x,y: np.concatenate((x,y)), sws)
#print a
# Wake
# low delta + high emg and not rem
a = np.unique(np.union1d(idx['low_delta'], idx['high_emg']))
b = np.setdiff1d(a, rem_idx)
wake = get_sequences(b)
wake_idx = reduce(lambda x,y: np.concatenate((x,y)), wake)
# sequences with low delta, high sigma and low emg are NREM
a = np.intersect1d(np.intersect1d(idx['high_sigma'], idx['low_delta']), idx['low_emg'])
a = np.setdiff1d(a, rem_idx)
sws_idx = np.unique(np.union1d(a, sws_idx))
wake_idx = np.setdiff1d(wake_idx, a)
#NREM sequences with high gamma are wake
a = np.intersect1d(sws_idx, idx['high_gamma'])
sws_idx = np.setdiff1d(sws_idx, a)
wake_idx = np.unique(np.union1d(wake_idx,a))
# Wake and Theta
wake_motion_idx = np.intersect1d(wake_idx, idx['high_theta'])
# Wake w/o Theta
wake_nomotion_idx = np.setdiff1d(wake_idx, idx['low_theta'])
# Are there overlapping sequences?
a = np.intersect1d(np.intersect1d(rem_idx, wake_idx), sws_idx)
# Are there undefined sequences?
undef_idx = np.setdiff1d(np.setdiff1d(np.setdiff1d(np.arange(0,N), rem_idx), wake_idx), sws_idx)
# Wake wins over SWS
sws_idx = np.setdiff1d(sws_idx, wake_idx)
# Special rules
# if there's a REM sequence directly following a short wake sequence (PRE_WAKE_REM),
# this wake sequence goes to SWS
# NREM to REM transitions are sometimes mistaken as quite wake periods
for rem_seq in rem:
if len(rem_seq) > 0:
irem_start = rem_seq[0]
# is there wake in the preceding bin?
if irem_start-1 in wake_idx:
# get the closest sws bin in the preceding history
isws_end = closest_precessor(sws_idx, irem_start)
if (irem_start - isws_end)*dt < PRE_WAKE_REM:
new_rem = np.arange(isws_end+1,irem_start)
rem_idx = np.union1d(rem_idx, new_rem)
wake_idx = np.setdiff1d(wake_idx, new_rem)
else:
new_wake = rem_seq
wake_idx = np.union1d(wake_idx, new_wake)
rem_idx = np.setdiff1d(rem_idx, new_wake)
# two different representations for the results:
S = {}
S['rem'] = rem_idx
S['nrem'] = sws_idx
S['wake'] = wake_idx
S['awake'] = wake_motion_idx
S['qwake'] = wake_nomotion_idx
M = np.zeros((N,))
if len(rem_idx) > 0:
M[rem_idx] = 1
if len(wake_idx) > 0:
M[wake_idx] = 2
if len(sws_idx) > 0:
M[sws_idx] = 3
if len(undef_idx) > 0:
M[undef_idx] = 0
# write sleep annotation to file
if pwrite:
outfile = os.path.join(ppath, name, 'remidx_' + name + '.txt')
print("writing annotation to %s" % outfile)
f = open(outfile, 'w')
s = ["%d\t%d\n" % (i,j) for (i,j) in zip(M,np.zeros((N,)))]
f.writelines(s)
f.close()
# nice plotting
plt.ion()
if pplot:
plt.figure(figsize=(18,9))
axes1=plt.axes([0.1, 0.9, 0.8, 0.05])
A = np.zeros((1,len(M)))
A[0,:] = M
cmap = plt.cm.jet
my_map = cmap.from_list('ha', [[0,0,0], [0,1,1],[0.5,0,1], [0.8, 0.8, 0.8]], 4)
#tmp = axes1.imshow(A, vmin=0, vmax=3)
tmp = axes1.pcolorfast(t, [0,1], A, vmin=0, vmax=3)
tmp.set_cmap(my_map)
axes1.axis('tight')
tmp.axes.get_xaxis().set_visible(False)
tmp.axes.get_yaxis().set_visible(False)
box_off(axes1)
# show spectrogram
axes2=plt.axes([0.1, 0.75, 0.8, 0.1], sharex=axes1)
ifreq = np.where(freq <= 30)[0]
med = np.median(SPEEG.max(axis=0))
if pspec_norm:
ifreq = np.where(freq <= 80)[0]
filt = np.ones((6, 1))
filt = filt / np.sum(filt)
SPEEG = scipy.signal.convolve2d(SPEEG, filt, mode='same')
spec_mean = SPEEG.mean(axis=1)
SPEEG = np.divide(SPEEG, np.repeat([spec_mean], SPEEG.shape[1], axis=0).T)
med = np.median(SPEEG.max(axis=0))
axes2.pcolorfast(t, freq[ifreq], SPEEG[ifreq, :], vmax = med*vmax, cmap='jet')
else:
axes2.pcolorfast(t, freq[ifreq], SPEEG[ifreq, :], vmax=med * vmax, cmap='jet')
axes2.axis('tight')
plt.ylabel('Freq (Hz)')
box_off(axes2)
# show delta power
axes3=plt.axes([0.1, 0.6, 0.8, 0.1], sharex=axes2)
axes3.plot(t,p_delta, color='gray')
plt.ylabel('Delta (a.u.)')
plt.xlim((t[0], t[-1]))
seq = get_sequences(S['nrem'])
#for s in seq:
# plt.plot(t[s],p_delta[s], color='red')
s = idx['high_delta']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_delta[s], color='red')
box_off(axes3)
axes4=plt.axes([0.1, 0.45, 0.8, 0.1], sharex=axes3)
axes4.plot(t,p_sigma, color='gray')
plt.ylabel('Sigma (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_sigma']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_sigma[s], color='red')
box_off(axes4)
axes5=plt.axes([0.1, 0.31, 0.8, 0.1], sharex=axes4)
axes5.plot(t,th_delta, color='gray')
plt.ylabel('Th/Delta (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_theta']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],th_delta[s], color='red')
box_off(axes5)
axes6=plt.axes([0.1, 0.17, 0.8, 0.1], sharex=axes5)
axes6.plot(t,p_gamma, color='gray')
plt.ylabel('Gamma (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_gamma']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_gamma[s], color='red')
box_off(axes6)
axes7=plt.axes([0.1, 0.03, 0.8, 0.1], sharex=axes6)
axes7.plot(t,p_mu, color='gray')
plt.xlabel('Time (s)')
plt.ylabel('EMG (a.u.)')
plt.xlim((t[0], t[-1]))
s = idx['high_emg']
seq = get_sequences(s)
for s in seq:
plt.plot(t[s],p_mu[s], color='red')
box_off(axes7)
plt.show()
# 2nd figure showing distribution of different bands
plt.figure(figsize=(20,3))
axes1 = plt.axes([0.05, 0.1, 0.13, 0.8])
plt.hist(p_delta, bins=100)
plt.plot(np.nanmean(p_delta), 10, 'ro')
plt.title('delta')
plt.ylabel('# Occurances')
box_off(axes1)
axes1 = plt.axes([0.25, 0.1, 0.13, 0.8])
plt.hist(th_delta, bins=100)
plt.plot(np.nanmean(th_delta)+th_delta_std*np.nanstd(th_delta), 10, 'ro')
plt.title('theta/delta')
box_off(axes1)
axes1 = plt.axes([0.45, 0.1, 0.13, 0.8])
plt.hist(p_sigma, bins=100)
plt.plot(np.nanmean(p_sigma), 10, 'ro')
plt.title('sigma')
box_off(axes1)
axes1 = plt.axes([0.65, 0.1, 0.13, 0.8])
plt.hist(p_gamma, bins=100)
plt.plot(np.nanmean(p_gamma), 10, 'ro')
plt.title('gamma')
box_off(axes1)
axes1 = plt.axes([0.85, 0.1, 0.13, 0.8])
plt.hist(p_mu, bins=100)
plt.plot(np.nanmean(p_mu)+np.nanstd(p_mu), 10, 'ro')
plt.title('EMG')
plt.show(block=False)
box_off(axes1)
plt.show()
return M,S
def plot_hypnograms(ppath, recordings, tbin=0, unit='h', ma_thr=20, title='', tstart=0, tend=-1):
"""
plot all hypnograms specified in @recordings
:param ppath: base folder
:param recordings: list of recordings
:param tbin: tbin for xticks
:param unit: time unit; h - hour, min - minute, s - second
:param ma_thr: float, wake periods shorter than $ma_thr are considered as microarousals and further converted to NREM
:param tstart: float, start time point (in seconds!) of hypnograms
:param tend: float, last shown time point (in seconds!)
:param title: optional title for figure
"""
recordings = recordings[::-1]
sr = get_snr(ppath, recordings[0])
nbin = int(np.round(sr) * 2.5)
dt_sec = (1.0 / sr) * nbin
istart = int(np.round(tstart/dt_sec))
dt = dt_sec
if unit == 'h':
dt /= 3600
elif unit == 'min':
dt /= 60
rec_len = dict()
irec = 0
ny = (1.0-0.2) / len(recordings)
dy = ny * 0.75
cmap = plt.cm.jet
my_map = cmap.from_list('brs', [[0, 0, 0], [0, 1, 1], [0.5, 0, 1], [0.8, 0.8, 0.8]], 4)
plt.ion()
plt.figure(figsize=(9,4))
axes = []
for rec in recordings:
M,K = load_stateidx(ppath, rec)
#kcut = np.where(K<0)[0]
#M = M[kcut]
#M[kcut] = 0
if tend == -1:
iend = len(M)
else:
iend = int(tend/dt_sec)
M = M[istart:iend]
if ma_thr>0:
seq = get_sequences(np.where(M==2)[0])
for s in seq:
if len(s)*dt_sec <= ma_thr:
M[s] = 3
rec_len[rec] = len(M)*dt
t = np.arange(0, len(M))*dt
ax = plt.axes([0.05, ny*irec+0.15, 0.75, dy])
tmp = ax.pcolorfast(t, [0, 1], np.array([M]), vmin=0, vmax=3, cmap=my_map)
box_off(ax)
ax.axis('tight')
tmp.axes.get_yaxis().set_visible(False)
if irec > 0:
tmp.axes.get_xaxis().set_visible(False)
if irec == 0:
plt.xlabel('Time (%s)' % unit)
irec += 1
axes.append(ax)
if len(title) > 0:
plt.title(title)
max_dur = max(rec_len.values())
if tbin > 0:
xtick = np.arange(0, max_dur, tbin)
for (ax, rec) in zip(axes, recordings):
ax.set_xlim([0, max_dur])
if tbin > 0:
ax.set_xticks(xtick)
ax.text(max_dur+max_dur*0.01, 0.5, rec)
plt.show()
def plot_swa(ppath, name, delta_win, alpha, band=[0.5, 4.5], swa_yrange=[]):
"""
plot slow wave (delta) activity during NREM
The top plot shows the hynogram.
The middle plot shows the delta power (irrespective of brain state) as line plot
The bottom plot shows for consecutive $delta_win seconds long bins, the
median delta power (SWA) during NREM, if the ration of NREM during the
corresponding bin >= $alpha
Example call:
dm=plot_swa(ppath, name, 30, 0.5, swa_yrange=[0, 0.012])
:param ppath, name: basefolder, recording name
:param delta_win: plot median swa value for each consecutive $delta_win seconds long window, if
:param alpha: the ratio of NREM in this window is larger than alpha (value between 0 and 1)
:param swa_yrange: tuple, minimun and maximum value of yrange for SWA
:return df: pd.DataFrame with SWA time points and corresponding median SWA values
"""
r_delta = band
sr = get_snr(ppath, name)
nbin = int(np.round(2.5*sr))
dt = nbin*(1.0/sr)
M,_ = load_stateidx(ppath, name)
t = np.arange(0, len(M))*dt
P = so.loadmat(os.path.join(ppath, name, 'sp_%s.mat' % name), squeeze_me=True)
SP = P['SP']
freq = P['freq']
df = freq[1]-freq[0]
idelta = np.where((freq>=r_delta[0]) & (freq<=r_delta[1]))[0]
pow_delta = SP[idelta,:].sum(axis=0)*df
# get NREM sequences contributing points for fitting
iwin = int(delta_win/dt)
#seq = get_sequences(nrem_idx, ibreak=int((delta_win/dt)*0.1))
delta_med = []
for j in range(0, len(M)-iwin, iwin):
s = range(j, j+iwin)
sc = j+int(iwin/2)
Mcut = M[s]
if (1.0*len(np.where(Mcut==3)[0])) / len(s) >= alpha:
i = np.where(Mcut==3)[0]
i = i+s[0]
a = np.median(pow_delta[i])
delta_med.append((t[sc],a))
df = pd.DataFrame(columns=['time', 'pow'], data=delta_med)
# generate figure
# show brainstate
plt.ion()
plt.figure(figsize=(10, 4))
axes_brs = plt.axes([0.1, 0.85, 0.8, 0.1])
cmap = plt.cm.jet
my_map = cmap.from_list('brs', [[0, 0, 0], [0, 1, 1], [0.6, 0, 1], [0.8, 0.8, 0.8]], 4)
tmp = axes_brs.pcolorfast(t, [0, 1], np.array([M]), vmin=0, vmax=3)
tmp.set_cmap(my_map)
axes_brs.axis('tight')
axes_brs.axes.get_xaxis().set_visible(False)
axes_brs.axes.get_yaxis().set_visible(False)
axes_brs.spines["top"].set_visible(False)
axes_brs.spines["right"].set_visible(False)
axes_brs.spines["bottom"].set_visible(False)
axes_brs.spines["left"].set_visible(False)
# plot delta power as function of time
c = 1000**2
axes_tdelta = plt.axes([0.1, 0.55, 0.8, 0.2], sharex=axes_brs)
plt.plot(t, pow_delta/c, 'k')
box_off(axes_tdelta)
axes_tdelta.axes.get_xaxis().set_visible(False)
axes_tdelta.spines["bottom"].set_visible(False)
plt.ylabel('SWA (mV$\mathrm{^2}$)')
# plot delta power medians
axes_delta = plt.axes([0.1, 0.12, 0.8, 0.35], sharex=axes_brs)
for (s,delta) in delta_med:
plt.plot(s, delta/c, 'ko')
print(t)
plt.xlim((t[0], t[-1]))
box_off(axes_delta)
plt.xlabel('Time (s)')
plt.ylabel('NREM SWA (mV$\mathrm{^2}$)')
if swa_yrange == []:
ymax = df['pow'].max()/c
plt.ylim([0, ymax+0.1*ymax])
else:
plt.ylim(swa_yrange)
plt.show()
return df
def laser_triggered_eeg(ppath, name, pre, post, f_max, pnorm=2, pplot=False, psave=False, tstart=0, tend=-1,
peeg2=False, vm=2.5, prune_trials=True, mu=[10, 200], trig_state=0, harmcs=0, iplt_level=1):
"""
calculate laser triggered, averaged EEG and EMG spectrum
:param ppath: base folder containing mouse recordings
:param name: recording
:param pre: time before laser
:param post: time after laser
:param f_max: calculate/plot frequencies up to frequency f_max
:param pnorm: normalization,
pnorm = 0, no normalization
pnorm = 1, normalize each frequency band by its average power
pnorm = 2, normalize each frequency band by the average power
during the preceding baseline period
:param vm: float to set saturation level of colormap
:param pplot: plot figure yes=True, no=False
:param psave: save the figure, yes=True, no = False
:param tstart: float, starting time point. Only lasers trials after tstart will be considered
:param tend: float, only laser trials up to tend will be considered; if tend==-1, use whole recording
:param peeg2: if True, use EEG channel 2
:param prune_trials: if True, throw out trials with EEG or EMG artifacts
:param mu: tuple; range used for EMG amplitude calculation
:param trig_state: int; if > 0, only use trials where brain is at laser onset in brainstate trig_state
1=REM, 2=Wake, 3=NREM
:param harmcs: if >0, interpolate all frequencies corresponding to multiples of harmcs by the average power
of the two neighboring frequencies.
:param iplt_level: options - 1 or 2. If 1 only take one neighboring frequency above and below the harmonic;
if 2, take 2 neighbors above and below, respectively
"""
def _interpolate_harmonics(SP, freq, f_max, harmcs, iplt_level):
df = freq[2]-freq[1]
for h in np.arange(harmcs, f_max, harmcs):
i = np.argmin(np.abs(freq - h))
if np.abs(freq[i] - h) < df and h != 60:
if iplt_level == 2:
SP[i,:] = (SP[i-2:i,:] + SP[i+1:i+3,:]).mean(axis=0) * 0.5
else:
SP[i,:] = (SP[i-1,:] + SP[i+1,:]) * 0.5
return SP
SR = get_snr(ppath, name)
NBIN = np.round(2.5*SR)
lsr = load_laser(ppath, name)
idxs, idxe = laser_start_end(lsr)
laser_dur = np.mean((idxe-idxs)/SR)
print('%s: Average laser duration: %f; Number of trials %d' % (name, laser_dur, len(idxs)))
# downsample EEG time to spectrogram time
idxs = [int(i/NBIN) for i in idxs]
idxe = [int(i/NBIN) for i in idxe]
#load EEG and EMG
P = so.loadmat(os.path.join(ppath, name, 'sp_' + name + '.mat'))
Q = so.loadmat(os.path.join(ppath, name, 'msp_' + name + '.mat'))
if not peeg2:
SPEEG = np.squeeze(P['SP'])
else:
SPEEG = np.squeeze(P['SP2'])
SPEMG = np.squeeze(Q['mSP'])
freq = np.squeeze(P['freq'])
t = np.squeeze(P['t'])
dt = float(np.squeeze(P['dt']))
ifreq = np.where(freq<=f_max)[0]
ipre = int(np.round(pre/dt))
ipost = int(np.round(post/dt))
speeg_mean = SPEEG.mean(axis=1)
spemg_mean = SPEMG.mean(axis=1)
# interpolate frequencies corresponding to harmonics of $harmcs
if harmcs > 0:
SPEEG = _interpolate_harmonics(SPEEG, freq, f_max, harmcs)
SPEMG = _interpolate_harmonics(SPEMG, freq, f_max, harmcs)
if tend > -1:
i = np.where((np.array(idxs)*dt >= tstart) & (np.array(idxs)*dt <= tend))[0]
else:
i = np.where(np.array(idxs)*dt >= tstart)[0]
idxs = [idxs[j] for j in i]
idxe = [idxe[j] for j in i]
skips = []
skipe = []
if prune_trials:
for (i,j) in zip(idxs, idxe):
A = SPEEG[0,i-ipre:i+ipost+1] / speeg_mean[0]
B = SPEMG[0,i-ipre:i+ipost+1] / spemg_mean[0]
k = np.where(A >= np.median(A)*50)[0]
l = np.where(B >= np.median(B)*500)[0]
if len(k) > 0 or len(l) > 0:
skips.append(i)
skipe.append(j)
print("%s: kicking out %d trials" % (name, len(skips)))
idxs_new = []
idxe_new = []
for (i,j) in zip(idxs, idxe):
if not i in skips:
idxs_new.append(i)
idxe_new.append(j)
idxs = idxs_new
idxe = idxe_new
# select trials where brain state is right before laser in trig_state
if trig_state > 0:
idxs_new = []
idxe_new = []
M = load_stateidx(ppath, name)[0]
for (i,j) in zip(idxs, idxe):
if i < len(M) and M[i] == trig_state:
idxs_new.append(i)
idxe_new.append(j)
idxs = idxs_new
idxe = idxe_new
# Spectrogram for EEG and EMG normalized by average power in each frequency band
if pnorm == 1:
SPEEG = np.divide(SPEEG, np.repeat(speeg_mean, len(t)).reshape(len(speeg_mean), len(t)))
SPEMG = np.divide(SPEMG, np.repeat(spemg_mean, len(t)).reshape(len(spemg_mean), len(t)))
speeg_parts = []
spemg_parts = []
for (i,j) in zip(idxs, idxe):
if i>=ipre and j+ipost < len(t):
eeg_part = SPEEG[ifreq,i-ipre:i+ipost+1]
speeg_parts.append(eeg_part)
spemg_parts.append(SPEMG[ifreq,i-ipre:i+ipost+1])
EEGLsr = np.array(speeg_parts).mean(axis=0)
EMGLsr = np.array(spemg_parts).mean(axis=0)
# smooth spectrogram
nfilt = 3
filt = np.ones((nfilt,nfilt))
filt = np.divide(filt, filt.sum())
EEGLsr = scipy.signal.convolve2d(EEGLsr, filt, boundary='symm', mode='same')
if pnorm == 2:
for i in range(EEGLsr.shape[0]):
EEGLsr[i,:] = np.divide(EEGLsr[i,:], np.sum(np.abs(EEGLsr[i,0:ipre]))/(1.0*ipre))
EMGLsr[i,:] = np.divide(EMGLsr[i,:], np.sum(np.abs(EMGLsr[i,0:ipre]))/(1.0*ipre))
# get time axis
dt = (1.0/SR)*NBIN
t = np.linspace(-ipre*dt, ipost*dt, ipre+ipost+1)
f = freq[ifreq]
if pplot:
# get rid of boxes around matplotlib plots
def box_off(ax):
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.ion()
plt.figure(figsize=(10,8))
ax = plt.axes([0.1, 0.55, 0.4, 0.35])
plt.pcolormesh(t,f,EEGLsr, vmin=0, vmax=np.median(EEGLsr)*vm, cmap='jet')
plt.plot([0,0], [0,f[-1]], color=(1,1,1))
plt.plot([laser_dur,laser_dur], [0,f[-1]], color=(1,1,1))
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Freq (Hz)')
box_off(ax)
plt.title('EEG', fontsize=12)
cbar = plt.colorbar()
if pnorm >0:
cbar.set_label('Rel. Power')
else:
cbar.set_label('Power uV^2s')
ax = plt.axes([0.62, 0.55, 0.35, 0.35])
ilsr = np.where((t>=0) & (t<=120))[0]
plt.plot(f,EEGLsr[:,0:ipre].mean(axis=1), color='gray', label='baseline', lw=2)
plt.plot(f,EEGLsr[:,ilsr].mean(axis=1), color='blue', label='laser', lw=2)
box_off(ax)
plt.xlabel('Freq. (Hz)')
plt.ylabel('Power (uV^2)')
#plt.legend(loc=0)
#plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, borderaxespad=0.)
ax = plt.axes([0.1, 0.1, 0.4, 0.35])
plt.pcolormesh(t,f,EMGLsr, cmap='jet')
plt.plot([0,0], [0,f[-1]], color=(1,1,1))
plt.plot([laser_dur,laser_dur], [0,f[-1]], color=(1,1,1))
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Freq (Hz)')
box_off(ax)
plt.title('EMG', fontsize=12)
cbar = plt.colorbar()
if pnorm >0:
cbar.set_label('Rel. Power')
else:
cbar.set_label('Power (uV^2s)')
ax = plt.axes([0.62, 0.1, 0.35, 0.35])
mf = np.where((f>=mu[0]) & (f <= mu[1]))[0]
df = f[1]-f[0]
# amplitude is square root of (integral over each frequency)
avg_emg = np.sqrt(EMGLsr[mf,:].sum(axis=0)*df)
m = np.max(avg_emg)*1.5
plt.plot([0,0], [0,np.max(avg_emg)*1.5], color=(0,0,0))
plt.plot([laser_dur,laser_dur], [0,np.max(avg_emg)*1.5], color=(0,0,0))
plt.xlim((t[0], t[-1]))
plt.ylim((0,m))
plt.plot(t,avg_emg, color='black', lw=2)
box_off(ax)
plt.xlabel('Time (s)')
plt.ylabel('EMG ampl. (uV)')
plt.show()
if psave:
img_file = os.path.join(ppath, name, 'fig_'+name+'_spec.png')
save_figure(img_file)
return EEGLsr, EMGLsr, freq[ifreq], t
def laser_triggered_eeg_avg(ppath, recordings, pre, post, f_max, laser_dur, pnorm=1, pplot=1, tstart=0, tend=-1,
vm=[], cb_ticks=[], mu=[10, 100], trig_state=0, harmcs=0, iplt_level=1, peeg2=False, fig_file=''):
"""
calculate average spectrogram for all recordings listed in @recordings; for averaging take
mouse identity into account
:param ppath: base folder
:param recordings: list of recordings
:param pre: time before laser onset
:param post: time after laser onset
:param f_max: maximum frequency shown for EEG spectrogram
:param laser_dur: duration of laser stimulation
:param pnorm: normalization,
pnorm = 0, no normalization
pnorm = 1, normalize each frequency band by its average power
pnorm = 2, normalize each frequency band by the average power
during the preceding baseline period
:param pplot: pplot==0 - no figure;
pplot==1 - conventional figure;
pplot==2 - pretty figure showing EEG spectrogram
along with EMG amplitude
note: the errorbar for the EMG amplitude is the S.E.M.
:param tstart: only consider laser trials with laser onset after tstart seconds
:param tend: only consider laser trials with laser onset before tend seconds
:param vm: saturation of heatmap for EEG spectrogram
:param cb_ticks: ticks for colorbar (only applies for pplot==2)
:param mu: frequencies for EMG amplitude calculation
:param trig_state: if > 0, only use trials where brain is at laser onset in brainstate trig_state
1=REM, 2=Wake, 3=NREM
:param peeg2: if True, use EEG2 instead of EEG
:param harmcs: if >0, interpolate all frequencies corresponding to multiples of harmcs by the average power
of the two neighboring frequencies.
:param iplt_level: options - 1 or 2. If 1 only take one neighboring frequency above and below the harmonic;
if 2, take 2 neighbors above and below, respectively
:param fig_file: if specified, save figure to given file
:return:
t, f, EEGSpec, EMGSpec, EEGLsr
t - time axis
f - frequency axis
EEGSpec - dict with mouse id -> 2D np.array(frequency x time)
EMGSpec - dict with mouse id -> 2D np.array(frequency x time)
EEGLsr - 2D np.array(frequency x time)
"""
EEGSpec = {}
EMGSpec = {}
mice = []
for rec in recordings:
idf = re.split('_', rec)[0]
if not(idf in mice):
mice.append(idf)
EEGSpec[idf] = []
EMGSpec[idf] = []
for rec in recordings:
idf = re.split('_', rec)[0]
EEG, EMG, f, t = laser_triggered_eeg(ppath, rec, pre, post, f_max, mu=mu, pnorm=pnorm, pplot=False,
psave=False, tstart=tstart, tend=tend, trig_state=trig_state,
peeg2=peeg2, harmcs=harmcs, iplt_level=iplt_level)
EEGSpec[idf].append(EEG)
EMGSpec[idf].append(EMG)
for idf in mice:
EEGSpec[idf] = | np.array(EEGSpec[idf]) | numpy.array |
import os
import tempfile
import numpy as np
import scipy.ndimage.measurements as meas
from functools import reduce
import warnings
import sys
sys.path.append(os.path.abspath(r'../lib'))
import NumCppPy as NumCpp # noqa E402
####################################################################################
def factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
####################################################################################
def test_seed():
np.random.seed(1)
####################################################################################
def test_abs():
randValue = np.random.randint(-100, -1, [1, ]).astype(np.double).item()
assert NumCpp.absScaler(randValue) == np.abs(randValue)
components = np.random.randint(-100, -1, [2, ]).astype(np.double)
value = complex(components[0], components[1])
assert np.round(NumCpp.absScaler(value), 9) == np.round(np.abs(value), 9)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert np.array_equal(NumCpp.absArray(cArray), np.abs(data))
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
data = np.random.randint(-100, 100, [shape.rows, shape.cols]) + \
1j * np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert np.array_equal(np.round(NumCpp.absArray(cArray), 9), np.round(np.abs(data), 9))
####################################################################################
def test_add():
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray1 = NumCpp.NdArray(shape)
cArray2 = NumCpp.NdArray(shape)
data1 = np.random.randint(-100, 100, [shape.rows, shape.cols])
data2 = np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray1.setArray(data1)
cArray2.setArray(data2)
assert np.array_equal(NumCpp.add(cArray1, cArray2), data1 + data2)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray.setArray(data)
value = np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(cArray, value), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray.setArray(data)
value = np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(value, cArray), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray1 = NumCpp.NdArrayComplexDouble(shape)
cArray2 = NumCpp.NdArrayComplexDouble(shape)
real1 = np.random.randint(1, 100, [shape.rows, shape.cols])
imag1 = np.random.randint(1, 100, [shape.rows, shape.cols])
data1 = real1 + 1j * imag1
real2 = np.random.randint(1, 100, [shape.rows, shape.cols])
imag2 = np.random.randint(1, 100, [shape.rows, shape.cols])
data2 = real2 + 1j * imag2
cArray1.setArray(data1)
cArray2.setArray(data2)
assert np.array_equal(NumCpp.add(cArray1, cArray2), data1 + data2)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
value = np.random.randint(-100, 100) + 1j * np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(cArray, value), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
value = np.random.randint(-100, 100) + 1j * np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(value, cArray), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray1 = NumCpp.NdArrayComplexDouble(shape)
cArray2 = NumCpp.NdArray(shape)
real1 = np.random.randint(1, 100, [shape.rows, shape.cols])
imag1 = np.random.randint(1, 100, [shape.rows, shape.cols])
data1 = real1 + 1j * imag1
data2 = np.random.randint(1, 100, [shape.rows, shape.cols])
cArray1.setArray(data1)
cArray2.setArray(data2)
assert np.array_equal(NumCpp.add(cArray1, cArray2), data1 + data2)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray1 = NumCpp.NdArray(shape)
cArray2 = NumCpp.NdArrayComplexDouble(shape)
data1 = np.random.randint(1, 100, [shape.rows, shape.cols])
real2 = np.random.randint(1, 100, [shape.rows, shape.cols])
imag2 = np.random.randint(1, 100, [shape.rows, shape.cols])
data2 = real2 + 1j * imag2
cArray1.setArray(data1)
cArray2.setArray(data2)
assert np.array_equal(NumCpp.add(cArray1, cArray2), data1 + data2)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray.setArray(data)
value = np.random.randint(-100, 100) + 1j * np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(cArray, value), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray.setArray(data)
value = np.random.randint(-100, 100) + 1j * np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(value, cArray), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
value = np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(cArray, value), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
value = np.random.randint(-100, 100)
assert np.array_equal(NumCpp.add(value, cArray), data + value)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray1 = NumCpp.NdArrayComplexDouble(shape)
cArray2 = NumCpp.NdArrayComplexDouble(shape)
real1 = np.random.randint(1, 100, [shape.rows, shape.cols])
imag1 = np.random.randint(1, 100, [shape.rows, shape.cols])
data1 = real1 + 1j * imag1
real2 = np.random.randint(1, 100, [shape.rows, shape.cols])
imag2 = np.random.randint(1, 100, [shape.rows, shape.cols])
data2 = real2 + 1j * imag2
cArray1.setArray(data1)
cArray2.setArray(data2)
assert np.array_equal(NumCpp.add(cArray1, cArray2), data1 + data2)
####################################################################################
def test_alen():
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(-100, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert NumCpp.alen(cArray) == shape.rows
####################################################################################
def test_all():
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(0, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert NumCpp.all(cArray, NumCpp.Axis.NONE).astype(bool).item() == np.all(data).item()
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
assert NumCpp.all(cArray, NumCpp.Axis.NONE).astype(bool).item() == np.all(data).item()
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(0, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert np.array_equal(NumCpp.all(cArray, NumCpp.Axis.ROW).flatten().astype(bool), np.all(data, axis=0))
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
assert np.array_equal(NumCpp.all(cArray, NumCpp.Axis.ROW).flatten().astype(bool), np.all(data, axis=0))
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(0, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert np.array_equal(NumCpp.all(cArray, NumCpp.Axis.COL).flatten().astype(bool), np.all(data, axis=1))
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
assert np.array_equal(NumCpp.all(cArray, NumCpp.Axis.COL).flatten().astype(bool), np.all(data, axis=1))
####################################################################################
def test_allclose():
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray1 = NumCpp.NdArray(shape)
cArray2 = NumCpp.NdArray(shape)
cArray3 = NumCpp.NdArray(shape)
tolerance = 1e-5
data1 = np.random.randn(shape.rows, shape.cols)
data2 = data1 + tolerance / 10
data3 = data1 + 1
cArray1.setArray(data1)
cArray2.setArray(data2)
cArray3.setArray(data3)
assert NumCpp.allclose(cArray1, cArray2, tolerance) and not NumCpp.allclose(cArray1, cArray3, tolerance)
####################################################################################
def test_amax():
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(0, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert NumCpp.amax(cArray, NumCpp.Axis.NONE).item() == np.max(data)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
assert NumCpp.amax(cArray, NumCpp.Axis.NONE).item() == np.max(data)
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(0, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert np.array_equal(NumCpp.amax(cArray, NumCpp.Axis.ROW).flatten(), np.max(data, axis=0))
shapeInput = np.random.randint(20, 100, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArrayComplexDouble(shape)
real = np.random.randint(1, 100, [shape.rows, shape.cols])
imag = np.random.randint(1, 100, [shape.rows, shape.cols])
data = real + 1j * imag
cArray.setArray(data)
assert np.array_equal(NumCpp.amax(cArray, NumCpp.Axis.ROW).flatten(), | np.max(data, axis=0) | numpy.max |
'''
XlPy/Tools/Xic_Picking/picking
______________________________
Tools to pick peaks from an extracted ion chromatogram.
:copyright: (c) 2015 The Regents of the University of California.
:license: GNU GPL, see licenses/GNU GPLv3.txt for more details.
'''
# load modules
import numpy as np
# load objects/functions
from collections import namedtuple
# OBJECTS
# -------
Intersect = namedtuple("Intersect", "above up down")
class Cluster(namedtuple("Cluster", "xicfit start end")):
'''Subclass with bound methods for facile data processing and scoring'''
# YIELDERS
def yield_distance(self):
'''Returns the euclidean distance from each anchor to the cluster'''
x = self.get_x()
min_ = x.min()
max_ = x.max()
for anchor in self.xicfit.anchors:
# add the minimum distance from the anchor to the cluster
if min_ < anchor < max_:
yield 0
elif anchor > max_:
yield anchor - max_
elif anchor < min_:
yield min_ - anchor
# GETTERS
def get_x(self):
return self.xicfit.x[self.start:self.end]
def get_y(self):
return self.xicfit.y[self.start:self.end]
def get_dotp(self, index):
return self.xicfit.get_meandotp(index, self.start, self.end)
def get_dotps(self):
return [self.get_dotp(i) for i in range(len(self.xicfit.isotopes))]
def get_masscorrelation(self, index):
return self.xicfit.get_masscorrelation(index, self.start, self.end)
def get_masscorrelations(self):
return [self.get_masscorrelation(i) for i in
range(len(self.xicfit.isotopes))]
# CLUSTERING
# ----------
def pad_clusters(length, *clusters):
'''Adds padding to each of the clusters'''
for cluster in clusters:
min_ = cluster.min()
max_ = cluster.max()
if min_ != 0 and max_ < length - 1:
yield np.r_[min_ - 1, cluster, max_ + 1]
elif min_ != 0:
yield np.r_[min_ - 1, cluster]
elif max_ < length - 1:
yield np.r_[cluster, max_ + 1]
else:
yield cluster
# INTERSECTIONS
# -------------
def getintersect(xicfit, valley=0.25, stddev=3, **kwds):
'''Returns the intersection indexes as a namedtuple'''
# get our two possible baselines
valley_level = xicfit.y.max() * valley
signal_to_noise = xicfit.baseline + stddev * xicfit.noise
# grab the minimum threshold, and find our intersections with the valley
threshold = min(valley_level, signal_to_noise)
above = xicfit.y > threshold
up, = np.where(above[1:] & ~above[:-1])
down, = np.where(~above[1:] & above[:-1])
return Intersect(above, up, down)
def splitvalley(xicfit, intersect):
'''Splits the array into series that are >= y.max() * valley'''
indexes, = | np.where(intersect.above) | numpy.where |
# coding:utf-8
import numpy as np
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from gplearn.genetic import SymbolicTransformer
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error
np.random.seed(7)
class GplearnDemo(object):
def __init__(self):
# data prepare
self.__boston = None
self.__boston_feature = None
self.__boston_label = None
self.__train_feature, self.__test_feature = [None for _ in range(2)]
self.__train_label, self.__test_label = [None for _ in range(2)]
self.__transformer = None
self.__gp_train_feature = None
self.__gp_test_feature = None
# model fit
self.__regressor = None
def data_prepare(self):
self.__boston = load_boston()
self.__boston_feature = pd.DataFrame(self.__boston.data, columns=self.__boston.feature_names)
self.__boston_label = pd.Series(self.__boston.target).to_frame("TARGET").squeeze()
self.__train_feature, self.__test_feature, self.__train_label, self.__test_label = (
train_test_split(
self.__boston_feature,
self.__boston_label,
test_size=0.5,
shuffle=True
)
)
# 不能有缺失值
self.__transformer = SymbolicTransformer(n_jobs=4)
self.__transformer.fit(self.__train_feature, self.__train_label)
self.__gp_train_feature = self.__transformer.transform(self.__train_feature)
self.__gp_test_feature = self.__transformer.transform(self.__test_feature)
def model_fit_predict(self):
self.__regressor = Ridge()
self.__regressor.fit(self.__train_feature, self.__train_label)
print(mean_squared_error(self.__test_label, self.__regressor.predict(self.__test_feature)))
self.__regressor = Ridge()
self.__regressor.fit( | np.hstack((self.__train_feature.values, self.__gp_train_feature)) | numpy.hstack |
# -*- coding:Utf-8 -*-
#from numpy import *
from __future__ import print_function
"""
.. currentmodule:: pylayers.antprop.loss
.. autosummary::
:members:
"""
import doctest
import os
import glob
import doctest
import logging
import numpy as np
from scipy import io
import matplotlib.pylab as plt
import pylayers.gis.gisutil as gu
import numpy.linalg as la
import pdb
import time
from numba import jit
def PL0(fGHz,GtdB=0,GrdB=0,R=1):
""" Path Loss at frequency fGHZ @ R
Parameters
----------
fGHz: float
frequency GHz
GtdB: float
transmitting antenna gain dB (default 0 dB)
GrdB: float
receiving antenna gain dB (default 0 dB)
R : float
distance in m
Returns
-------
PL0 : float
path @ R
Notes
-----
.. math:: PL_0 = -20 log_{10}(\\frac{\\lambda}{4\\pi}) - GtdB -GrdB
Examples
--------
>>> fGHz = 2.4
>>> PL = PL0(fGHz)
>>> assert (PL<41)&(PL>40),"something wrong"
"""
if not isinstance(fGHz,np.ndarray):
fGHz=np.array([fGHz])
ld = 0.3/fGHz
PL0 = -20*np.log10(ld/(4.0*np.pi*R))-GtdB-GrdB
return PL0
def Dgrid_points(points,Px):
""" distance point to grid
Parameters
----------
points : np.array
grid Np x 2 array
Px : np.array
point 2 x 1 array
Returns
-------
D: Euclidian distance matrix
"""
Dx = points[:,0] - Px[0]
Dy = points[:,1] - Px[1]
D = np.sqrt( Dx*Dx + Dy*Dy )
return(D)
def FMetisShad2(fGHz,r,D,sign=1):
""" F Metis shadowing function
Parameters
----------
fGHz : np.array(Nf)
frequency GHz
r : np.array(Nseg,)
distance between Tx and Rx
D : np.array(Nseg,Nscreen)
indirect distance between Tx and Rx (screen effect)
sign : np.array(Nseg,Nscreen)
== 1 : Shadowing NLOS situation
==-1 : No shadowing LOS situation
Returns
-------
F : np.array(Nseg,Nscreen,Nf)
Notes
-----
Provides an implementation of formula (6.6) in D1.4 of METIS project
See Also
--------
LossMetisShadowing
"""
lamda = 0.3/fGHz[None,None,:]
F = np.arctan(sign[:,:,None]*np.pi/2.*(np.sqrt((np.pi/lamda)*(D[:,:,None]-r[:,None,None])))) / np.pi
return(F)
def FMetisShad(fGHz,r,D,sign=1):
""" F Metis shadowing function
Parameters
----------
fGHz : float
frequency GHz
r : float
distance between Tx and Rx
D : float
indirect distance between Tx and Rx (screen effect)
sign : int
== 1 : Shadowing NLOS situation
==-1 : No shadowing LOS situation
Notes
-----
Provides an implementation of formula (6.6) in D1.4 of METIS project
See Also
--------
LossMetisShadowing
"""
lamda = 0.3/fGHz
F = np.arctan(sign*np.pi/2.*(np.sqrt((np.pi/lamda)*(D-r)))) / np.pi
return(F)
def LossMetisShadowing(fGHz,tx,rx,pg,uw,uh,w,h):
""" Calculate the Loss from
Parameters
----------
fGHz : float
tx : np.array (,3) of floats
transmiter coordinates
rx : np.array (,3) of floats
receiver coordinates
pg : np.array (,3) of floats
center of gravity of the screen
uw : np.array (,3) of floats
unitary vector along width dimension
uh : np.array (,3) of floats
unitary vector along height dimension
w : float
width in meters
h : float
height in meters
Returns
-------
Lsh : float
Loss in dB to add to the FS path Loss
Notes
-----
This function provides an implementation of formula 6.5 of D1.4 deliverable of METIS project
[Metis D1.4](Ahttps://www.metis2020.com/wp-content/uploads/METIS_D1.4_v3.pdf)
# geometry parametric issue : find M in [tx-rx] defined as M = alpha*rx + (1-alpha)tx where alpha in [0-1].
# if alpha = 0 then M = tx ; if alpha = 1 then M = rx.
# Besides, M is defined as M = pg + beta*uw + gamma*uh then alpha*rx + (1-alpha)tx = pg + beta*uw + gamma*uh
# [rx-tx , -uw, -uh]*[alpha,beta,gamma].T = pg - tx <==> Ax = b solved by la.solve ; x[0]=alpha, x[1]=beta and
TODO To be vectorized
"""
rxtx = rx - tx # LOS distance
# x[2]=gamma.
A = np.vstack((rxtx,-uw,-uh)).T
b = pg - tx
x = la.solve(A,b)
# condition of shadowing
condseg = ((x[0]>1) or (x[0]<0))
condw = ((x[1]>w/2.) or (x[1]<-w/2.))
condh = ((x[2]>h/2.) or (x[2]<-h/2.))
visi = condseg or condw or condh
if visi:
shad = -1
else:
shad = 1
r = np.dot(rxtx,rxtx)**0.5
w1 = pg + uw*w/2.
w2 = pg - uw*w/2.
h1 = pg + uh*h/2.
h2 = pg - uh*h/2.
Dtw1 = np.dot(tx-w1,tx-w1)**0.5
Drw1 = np.dot(rx-w1,rx-w1)**0.5
Dtw2 = np.dot(tx-w2,tx-w2)**0.5
Drw2 = np.dot(rx-w2,rx-w2)**0.5
Dth1 = np.dot(tx-h1,tx-h1)**0.5
Drh1 = np.dot(rx-h1,rx-h1)**0.5
Dth2 = np.dot(tx-h2,tx-h2)**0.5
Drh2 = np.dot(rx-h2,rx-h2)**0.5
D1w = Dtw1+Drw1
D1h = Dth1+Drh1
D2w = Dtw2+Drw2
D2h = Dth2+Drh2
if shad == 1:
signw1 = 1
signw2 = 1
signh1 = 1
signh2 = 1
else:
if condw:
if D1w>D2w:
signw1=1
signw2=-1
else:
signw1=-1
signw2=1
else:
signw1 = 1
signw2 = 1
if condh:
if D1h>D2h:
signh1=1
signh2=-1
else:
signh1=-1
signh2=1
else:
signh1 = 1
signh2 = 1
Fw1 = FMetisShad(fGHz,r,D1w,sign=signw1)
Fh1 = FMetisShad(fGHz,r,D1h,sign=signh1)
Fw2 = FMetisShad(fGHz,r,D2w,sign=signw2)
Fh2 = FMetisShad(fGHz,r,D2h,sign=signh2)
tmp = (Fh1+Fh2)*(Fw1+Fw2)
Lsh = -20*np.log10(1-tmp)
#return(Lsh,shad,tmp,Fw1,Fh1,Fw2,Fh2,condh,condw)
return(Lsh)
def LossMetisShadowing2(fGHz,tx,rx,pg,uw,uh,w,h):
""" Calculate the Loss from
Parameters
----------
fGHz : np.array(,Nf)
tx : np.array (3,Nseg) of floats
transmiter coordinates
rx : np.array (3,Nseg) of floats
receiver coordinates
pg : np.array (3,Nscreen) of floats
center of gravity of the screen
uw : np.array (3,Nscreen) of floats
unitary vector along width dimension
uh : np.array (3,Nscreen) of floats
unitary vector along height dimension
w : np.array (,Nscreen)
width in meters
h : np.array (,Nscreen)
height in meters
Returns
-------
Lsh : np.array (Nseg,Nscreen,Nf)
Loss in dB to add to the FS path Loss
Notes
-----
This function provides an implementation of formula 6.5 of D1.4 deliverable of METIS project
[Metis D1.4](Ahttps://www.metis2020.com/wp-content/uploads/METIS_D1.4_v3.pdf)
# geometry parametric issue : find M in [tx-rx] defined as M = alpha*rx + (1-alpha)tx where alpha in [0-1].
# if alpha = 0 then M = tx ; if alpha = 1 then M = rx.
# Besides, M is defined as M = pg + beta*uw + gamma*uh then alpha*rx + (1-alpha)tx = pg + beta*uw + gamma*uh
# [rx-tx , -uw, -uh]*[alpha,beta,gamma].T = pg - tx <==> Ax = b solved by la.solve ; x[0]=alpha, x[1]=beta and
"""
Nseg = tx.shape[1]
Nscreen = uw.shape[1]
rxtx = rx - tx # (3,Nseg) LOS distance
# A : (Nseg,Nscreen,3,3)
# b : (Nseg,Nscreen,3)
# rxtx.T (Nseg,3)
# uw.T (Nscreen, 3)
# uh.T (Nscreen, 3)
U = rxtx.T[:,None,:,None]
W = uw.T[None,:,:,None]
H = uh.T[None,:,:,None]
We = W + np.zeros(U.shape)
He = H + np.zeros(U.shape)
Ue = U + np.zeros(He.shape)
A = np.concatenate((Ue,-We,-He),axis=3)
#A = np.vstack((rxtx,-uw,-uh)).T
# pg.T Nscreen, 3
# tx.T Nseg,3
b = pg.T[None,:,:]-tx.T[:,None,:]
#b = pg - tx
x = la.solve(A,b)
# condition of shadowing
condseg = ((x[:,:,0]>1) + (x[:,:,0]<0))
condw = ((x[:,:,1]>w[None,:]/2.) + (x[:,:,1]<-w[None,:]/2.))
condh = ((x[:,:,2]>h[None,:]/2.) + (x[:,:,2]<-h[None,:]/2.))
visi = (condseg + condw + condh)%2
# if visi:
# shad = -1
# else:
# shad = 1
#shad = - visi
r = np.sum(rxtx*rxtx,axis=0)**0.5
w1 = pg + uw*w[None,:]/2.
w2 = pg - uw*w[None,:]/2.
h1 = pg + uh*h[None,:]/2.
h2 = pg - uh*h[None,:]/2.
Dtw1 = np.sum((tx[...,None]-w1[:,None,:])*(tx[...,None]-w1[:,None,:]),axis=0)**0.5
Drw1 = np.sum((rx[...,None]-w1[:,None,:])*(rx[...,None]-w1[:,None,:]),axis=0)**0.5
Dtw2 = np.sum((tx[...,None]-w2[:,None,:])*(tx[...,None]-w2[:,None,:]),axis=0)**0.5
Drw2 = np.sum((rx[...,None]-w2[:,None,:])*(rx[...,None]-w2[:,None,:]),axis=0)**0.5
Dth1 = np.sum((tx[...,None]-h1[:,None,:])*(tx[...,None]-h1[:,None,:]),axis=0)**0.5
Drh1 = np.sum((rx[...,None]-h1[:,None,:])*(rx[...,None]-h1[:,None,:]),axis=0)**0.5
Dth2 = | np.sum((tx[...,None]-h2[:,None,:])*(tx[...,None]-h2[:,None,:]),axis=0) | numpy.sum |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
from obspy.signal.util import next_pow_2
from gmprocess.waveform_processing.fft import compute_and_smooth_spectrum
from gmprocess.waveform_processing.spectrum import \
brune_f0, moment_from_magnitude
# Options for tapering noise/signal windows
TAPER_WIDTH = 0.05
TAPER_TYPE = 'hann'
TAPER_SIDE = 'both'
MIN_POINTS_IN_WINDOW = 10
def compute_snr_trace(tr, bandwidth, mag=None, check=None):
if tr.hasParameter('signal_split'):
# Split the noise and signal into two separate traces
split_prov = tr.getParameter('signal_split')
if isinstance(split_prov, list):
split_prov = split_prov[0]
split_time = split_prov['split_time']
noise = tr.copy().trim(endtime=split_time)
signal = tr.copy().trim(starttime=split_time)
noise.detrend('demean')
signal.detrend('demean')
# Taper both windows
noise.taper(max_percentage=TAPER_WIDTH,
type=TAPER_TYPE,
side=TAPER_SIDE)
signal.taper(max_percentage=TAPER_WIDTH,
type=TAPER_TYPE,
side=TAPER_SIDE)
# Check that there are a minimum number of points in the noise window
if noise.stats.npts < MIN_POINTS_IN_WINDOW:
# Fail the trace, but still compute the signal spectra
# ** only fail here if it hasn't already failed; we do not yet
# ** support tracking multiple fail reasons and I think it is
# ** better to know the FIRST reason if I have to pick one.
if not tr.hasParameter('failure'):
tr.fail('Failed SNR check; Not enough points in noise window.')
compute_and_smooth_spectrum(tr, bandwidth, 'signal')
return tr
# Check that there are a minimum number of points in the noise window
if signal.stats.npts < MIN_POINTS_IN_WINDOW:
# Fail the trace, but still compute the signal spectra
if not tr.hasParameter('failure'):
tr.fail(
'Failed SNR check; Not enough points in signal window.')
compute_and_smooth_spectrum(tr, bandwidth, 'signal')
return tr
nfft = max(next_pow_2(signal.stats.npts),
next_pow_2(noise.stats.npts))
compute_and_smooth_spectrum(tr, bandwidth, 'noise', noise, nfft)
compute_and_smooth_spectrum(tr, bandwidth, 'signal', signal, nfft)
# For both the raw and smoothed spectra, subtract the noise spectrum
# from the signal spectrum
tr.setCached(
'signal_spectrum', {
'spec': (tr.getCached('signal_spectrum')['spec'] -
tr.getCached('noise_spectrum')['spec']),
'freq': tr.getCached('signal_spectrum')['freq']
}
)
tr.setCached(
'smooth_signal_spectrum', {
'spec': (tr.getCached('smooth_signal_spectrum')['spec'] -
tr.getCached('smooth_noise_spectrum')['spec']),
'freq': tr.getCached('smooth_signal_spectrum')['freq']
}
)
smooth_signal_spectrum = tr.getCached('smooth_signal_spectrum')['spec']
smooth_noise_spectrum = tr.getCached('smooth_noise_spectrum')['spec']
snr = smooth_signal_spectrum / smooth_noise_spectrum
snr_dict = {
'snr': snr,
'freq': tr.getCached('smooth_signal_spectrum')['freq']
}
tr.setCached('snr', snr_dict)
else:
# We do not have an estimate of the signal split time for this trace
compute_and_smooth_spectrum(tr, bandwidth, 'signal')
if check is not None:
tr = snr_check(tr, mag, **check)
return tr
def compute_snr(st, bandwidth, mag=None, check=None):
"""Compute SNR dictionaries for a stream, looping over all traces.
Args:
st (StationStream):
Trace of data.
bandwidth (float):
Konno-Omachi smoothing bandwidth parameter.
check (dict):
If None, no checks performed.
Returns:
StationTrace with SNR dictionaries added as trace parameters.
"""
for tr in st:
# Do we have estimates of the signal split time?
compute_snr_trace(tr, bandwidth, mag=mag, check=check)
return st
def snr_check(tr, mag, threshold=3.0, min_freq='f0', max_freq=5.0, f0_options={
'stress_drop': 10, 'shear_vel': 3.7, 'ceiling': 2.0,
'floor': 0.1}):
"""
Check signal-to-noise ratio.
Requires noise/singal windowing to have succeeded.
Args:
tr (StationTrace):
Trace of data.
threshold (float):
Threshold SNR value.
min_freq (float or str):
Minimum frequency for threshold to be exeeded. If 'f0', then the
Brune corner frequency will be used.
max_freq (float):
Maximum frequency for threshold to be exeeded.
bandwidth (float):
Konno-Omachi smoothing bandwidth parameter.
f0_options (dict):
Dictionary of f0 options (see config file).
Returns:
trace: Trace with SNR check.
"""
if tr.hasCached('snr'):
snr_dict = tr.getCached('snr')
snr = np.array(snr_dict['snr'])
freq = np.array(snr_dict['freq'])
# If min_freq is 'f0', then compute Brune corner frequency
if min_freq == 'f0':
min_freq = brune_f0(
moment_from_magnitude(mag), f0_options['stress_drop'],
f0_options['shear_vel'])
if min_freq < f0_options['floor']:
min_freq = f0_options['floor']
if min_freq > f0_options['ceiling']:
min_freq = f0_options['ceiling']
# Check if signal criteria is met
mask = (freq >= min_freq) & (freq <= max_freq)
if | np.any(mask) | numpy.any |
# Copyright (c) 2020 PaddlePaddle 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.
"""
Verification for mean normalize demo.
"""
import prepare
import process_data
import numpy as np
# 0 for f_range, 1 for f_mean
# use decrypted global f_range and f_mean to rescaling local feature data
res = process_data.decrypt_data(prepare.data_path + 'result', (
2,
prepare.feat_width, ))
# reconstruct plaintext global data to verify
row, col = sum(prepare.sample_nums), prepare.feat_width
plain_mat = np.empty((row, col))
row = 0
for i, num in enumerate(prepare.sample_nums):
m = np.load(prepare.data_path + 'feature_data.' + str(i) + '.npy')
plain_mat[row:row + num] = m
row += num
def mean_normalize(f_mat):
"""
get plain text f_range & f_mean
"""
ma = | np.amax(f_mat, axis=0) | numpy.amax |
import unittest
import numpy as np
from nptest import nptest
class StatisticsTests(unittest.TestCase):
#region amin/amax
def test_amin_1(self):
a = np.arange(1,5).reshape((2,2))
print(a)
print("*****")
b = np.amin(a) # Minimum of the flattened array
print(b)
print("*****")
c = np.amin(a, axis=0) # Minima along the first axis
print(c)
print("*****")
d = np.amin(a, axis=1) # Minima along the second axis
print(d)
print("*****")
e = np.arange(5, dtype=float)
e[2] = np.NaN
f = np.amin(e)
print(f)
print("*****")
g = np.nanmin(b)
print(g)
def test_amin_2(self):
a = np.arange(30.25,46.25).reshape((4,4))
print(a)
print("*****")
b = np.amin(a) # Minimum of the flattened array
print(b)
print("*****")
c = np.amin(a, axis=0) # Minima along the first axis
print(c)
print("*****")
d = np.amin(a, axis=1) # Minima along the second axis
print(d)
print("*****")
e = | np.arange(5, dtype=float) | numpy.arange |
# -*- coding: utf-8 -*-
"""
Created on 2021/12/14 21:10:08
@File -> mutual_info.py
@Author: luolei
@Email: <EMAIL>
@Describe: 互信息和条件互信息计算
"""
from scipy.special import psi
import pandas as pd
import numpy as np
from . import DTYPES
from . import preprocess_values, deter_k, build_tree, query_neighbors_dist
from .entropy import Entropy
class MutualInfo(object):
"""
两个随机变量之间的互信息计算
1. X和Y均为'd': 直接离散计算互信息H(X) + H(Y) - H(X, Y)
2. X和Y均为'c': 采用Kraskov的方案
3. X和Y分别为'c'和'd': 采用Ross方案
4. X和Y分别为'd'和'c': 采用Ross方案
"""
def __init__(self, x: np.ndarray, y: np.ndarray, x_type: str, y_type: str):
assert len(x) == len(y)
for type_ in [x_type, y_type]:
assert type_ in DTYPES
self.x = preprocess_values(x, x_type)
self.y = preprocess_values(y, y_type)
self.x_type, self.y_type = x_type, y_type
@staticmethod
def _mi_cc(x, y, k: int = None):
"""计算连续变量之间的互信息
参考文献:
------
<NAME>, <NAME>, <NAME>: Estimating Mutual Information, 2003, Eqs. (23) & (30).
"""
N, _ = x.shape
k = deter_k(x) if k is None else k
assert k <= len(x) - 1
xy = np.c_[x, y]
tree = build_tree(xy, 'chebyshev')
nn_distc = query_neighbors_dist(tree, xy, k) # 获得了各样本第k近邻的距离
tree = build_tree(x, 'chebyshev')
nn_distc_x = nn_distc - 1e-12
Nx = tree.query_radius(x, nn_distc_x, count_only=True)
tree = build_tree(y, 'chebyshev')
nn_distc_y = nn_distc - 1e-12
Ny = tree.query_radius(y, nn_distc_y, count_only=True)
# return psi(N) + psi(k) - np.mean(psi(Nx) + psi(Ny))
return psi(k) - 1 / k + psi(N) - np.mean(psi(Nx) + psi(Ny))
@staticmethod
def _mi_cd(x, y, k: int = None):
"""
计算连续的X和离散的Y之间的互信息
参考文献:
------
<NAME>: Mutual Information between Discrete and Continuous Data Sets, 2014.
"""
N, _ = x.shape
assert (x.shape[1] >= 1) & (y.shape[1] == 1) # NOTE: 此处y必须为1维
y = y.flatten()
k = deter_k(x) if k is None else k
assert k <= N - 1
# 统计各类Y的总数.
classes = np.unique(y)
Nx_class = np.zeros_like(y)
for i in range(len(y)):
Nx_class[i] = np.sum(y == y[i])
# 逐类进行K近邻计算.
nn_distc_classes = | np.zeros_like(y, dtype=float) | numpy.zeros_like |
"""
Copyright (c) 2021 The authors of SCC 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.
"""
import time
from graphgrove.scc import SCC
from graphgrove import graph_builder
import numpy as np
class Cosine_SCC(object):
def __init__(self, k=25, num_rounds=50, thresholds=None, index_name='cosine_sgtree', cores=12, cc_alg=0, par_minimum=100000, verbosity=0, beam_size=100, hnsw_max_degree=200, hnsw_ef_search=200, hnsw_ef_construction=200):
self.k = k
self.num_rounds = num_rounds
self.thresholds = thresholds
self.index_name = index_name
self.cores = cores
if thresholds is None:
self.thresholds = | np.ones(num_rounds) | numpy.ones |
# note: documentation not written yet
import time
import numba
import numpy as np
from scipy import optimize
from scipy import interpolate
from types import SimpleNamespace
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style("whitegrid")
prop_cycle = plt.rcParams["axes.prop_cycle"]
colors = prop_cycle.by_key()["color"]
class AiyagariModel:
############
# 1. setup #
############
def __init__(self, name="", **kwargs):
self.name = name
self.setup_parameters()
self.update_parameters(kwargs)
self.setup_primitive_functions()
self.setup_misc()
def setup_parameters(self):
# a. model parameters
self.beta = 0.96 # discount factor
self.delta = 0.08 # depreciation rate
self.sigma = 4 # crra coefficient
self.alpha = 1 / 3 # cobb-douglas coeffient
# b. solution
self.tol_cfunc_inf = 1e-6 # tolerance for consumption function
self.cfunc_maxiter = (
2000
) # maximum number of iterations when finding consumption function
# income
self.unemp_p = 0.05 # unemployment probability
self.unemp_b = 0.15 # unemployment benefits
self.Nz = 2 # number of productivity states
self.grid_z = np.array([0.90, 1.10]) # productivity values
self.trans_p_z = np.array(
[[0.95, 0.05], [0.05, 0.95]]
) # transition probabilities
# end-of-period assets grid
self.Na = 200
self.a_min = 0
self.a_max = 20
self.a_phi = 1.1
# cash-on-hand grid
self.Nm = 500
self.m_max = 20
self.m_phi = 1.1
# c. simulation
self.seed = 2018
# d. steady state
self.ss_R_tol = 1e-7 # tolerance for finding interest rate
self.ss_a0 = 4.0 # initial cash-on-hand (homogenous)
self.ss_simN = 50000 # number of households
self.ss_simT = 2000 # number of time-periods
self.ss_sim_burnin = 1000 # burn-in periods before calculating average savings
# e. transition path
self.transN = 50000 # number of households
self.transT = 200 # number of periods
self.trans_maxiter = 200
self.trans_tol = 1e-4 # tolerance for convergence
def update_parameters(self, kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
def setup_primitive_functions(self):
eps = 1e-8
# a. utility function
if self.sigma == 1:
self.u = lambda c: np.log(np.fmax(c, eps))
else:
self.u = lambda c: np.fmax(c, eps) ** (1 - self.sigma) / (1 - self.sigma)
self.u_prime = lambda c: np.fmax(c, eps) ** (-self.sigma)
self.u_prime_inv = lambda x: x ** (-1 / self.sigma)
# b. production function
self.f = lambda k: np.fmax(k, eps) ** self.alpha
self.f_prime = lambda k: self.alpha * np.fmax(k, eps) ** (self.alpha - 1)
self.f_prime_inv = lambda x: (np.fmax(x, eps) / self.alpha) ** (
1 / (self.alpha - 1)
)
def setup_misc(self):
def nonlinspace(
min_val, max_val, num, phi
): # phi up, more points close to min_val
x = np.zeros(num)
x[0] = min_val
for i in range(1, num):
x[i] = x[i - 1] + (max_val - x[i - 1]) / (num - i) ** phi
return x
# a. grids
self.grid_a = nonlinspace(self.a_min, self.a_max, self.Na, self.a_phi)
self.grid_m = nonlinspace(0, self.m_max, self.Nm, self.m_phi)
# b. initial distribution of z
z_diag = np.diag(self.trans_p_z ** 1000)
self.ini_p_z = z_diag / np.sum(z_diag)
avg_z = np.sum(self.grid_z * self.ini_p_z)
self.grid_z = self.grid_z / avg_z # force mean one
# c. bounds on interst factor
self.R_high = 1 / self.beta + 0.005
self.R_low = 1 / self.beta - 0.005
# d. misc
self.c_transition_path = np.empty((1, 1, 1)) # raw allocate
######################
# 2. model functions #
######################
def R_func(self, k):
return 1 + self.f_prime(k) - self.delta
def w_func(self, k):
return self.f(k) - self.f_prime(k) * k
def w_from_R_func(self, R):
k = self.f_prime_inv(R - 1 + self.delta)
return self.w_func(k)
############
# 3. solve #
############
def solve_step(self, c_plus_interp, R, w):
c_func = []
for i_z in range(self.Nz):
# a. find next-period average marginal utility
avg_marg_u_plus = np.zeros(self.Na)
for i_zplus in range(self.Nz):
for u in [0, 1]:
# i. future cash-on-hand
if u == 0:
m_plus = R * self.grid_a + w * (
self.grid_z[i_zplus] - self.unemp_p * self.unemp_b
) / (1 - self.unemp_p)
else:
m_plus = R * self.grid_a + w * self.unemp_b
# ii. future consumption
c_plus = c_plus_interp[i_zplus](m_plus)
# iii. future marginal utility
marg_u_plus = self.u_prime(c_plus)
# iv. accumulate average marginal utility
weight = self.trans_p_z[i_z, i_zplus]
if u == 0:
weight *= 1 - self.unemp_p
else:
weight *= self.unemp_p
avg_marg_u_plus += weight * marg_u_plus
# b. find current consumption and cash-on-hand
c = self.u_prime_inv(R * self.beta * avg_marg_u_plus)
m = self.grid_a + c
m = np.insert(m, 0, 0) # add 0 in beginning
c = np.insert(c, 0, 0) # add 0 in beginning
# c. interpolate to common grid
c_raw_func = interpolate.RegularGridInterpolator(
[m], c, method="linear", bounds_error=False, fill_value=None
)
# d. construct interpolator at common grid
c_func_now = interpolate.RegularGridInterpolator(
[self.grid_m],
c_raw_func(self.grid_m),
method="linear",
bounds_error=False,
fill_value=None,
)
c_func.append(c_func_now)
return c_func
def solve_inf_horizon(self):
# a. initial guess (consume everything)
c_func_inf = []
for i_z in range(self.Nz):
# i. consume everything
m = self.grid_m
c = m
# ii. create linear interpolator
interp = interpolate.RegularGridInterpolator(
[m], c, method="linear", bounds_error=False, fill_value=None
)
# iii. append
c_func_inf.append(interp)
# b. solve household problem
diff_cfunc = np.inf
it = 0
while diff_cfunc > self.tol_cfunc_inf:
it += 1
# i. remember previous
c_func_inf_old = c_func_inf
# ii. solve one step further
c_func_inf = self.solve_step(c_func_inf_old, self.R_ss, self.w_ss)
# iii. maximum absolute difference
diff_cfunc = []
for i_z in range(self.Nz):
diff_cfunc.append(
np.amax(np.abs(c_func_inf_old[i_z].values - c_func_inf[i_z].values))
)
diff_cfunc = max(diff_cfunc)
# iv. do not reach 2000 iterations
if it > self.cfunc_maxiter:
break
# c. save interpolators
self.c_func_inf = c_func_inf
# d. save values
self.c_inf = np.empty((self.Nz, self.Nm))
for z in range(self.Nz):
self.c_inf[z, :] = c_func_inf[z].values
def solve_transition_path(self):
# a. allocate memory
self.c_func_transition_path = [None] * self.transT
self.c_transition_path = np.empty((self.transT, self.Nz, self.Nm))
# b. solve backwards along transition path
for t in reversed(range(self.transT)):
# i. solve
if t == self.transT - 1:
c_plus_func = self.c_func_inf
self.c_func_transition_path[t] = self.solve_step(
c_plus_func, self.R_ss, self.w_ss
)
else:
c_plus_func = self.c_func_transition_path[t + 1]
self.c_func_transition_path[t] = self.solve_step(
c_plus_func, self.sim_R[t + 1], self.sim_w[t + 1]
)
# ii. save values
for z in range(self.Nz):
self.c_transition_path[t, z, :] = self.c_func_transition_path[t][
z
].values
#############################
# 4. stationary equilibrium #
#############################
def check_supply_and_demand(self, R_ss_guess, a0, z0, print_results=False):
# a. prices
self.R_ss = R_ss_guess
self.w_ss = self.w_from_R_func(self.R_ss)
# b. solve infinite horizon problem
t0 = time.time()
self.solve_inf_horizon()
time_sol = time.time() - t0
# c. simulate
t0 = time.time()
# prices
self.ss_sim_R = self.R_ss * np.ones(self.ss_simT)
self.ss_sim_w = self.w_ss * np.ones(self.ss_simT)
# simulate
self.ss_sim_k, self.ss_sim_a, self.ss_sim_z = simulate(
a0,
z0,
self.ss_sim_R,
self.ss_sim_w,
self.ss_simN,
self.ss_simT,
self.grid_z,
self.grid_m,
self.c_inf,
self.trans_p_z,
self.unemp_p,
self.unemp_b,
self.c_transition_path,
0,
self.seed,
)
time_sim = time.time() - t0
# d. calculate difference
self.k_ss = np.mean(self.ss_sim_k[self.ss_sim_burnin :])
R_ss_implied = self.R_func(self.k_ss)
diff = R_ss_implied - R_ss_guess
# e. print results
if print_results:
print(
f" guess on R = {R_ss_guess:.5f} -> implied R = {R_ss_implied:.5f} (diff = {diff:8.5f})"
)
# print(f' time to solve = {time_sol:.1f}, time to simulate = {time_sim:.1f}')
return diff
def find_stationary_equilibrium(self, print_results=True):
print(f"find stationary equilibrium (R in [{self.R_low:.5f};{self.R_high:.5f}]")
# a. initial values
a0 = self.ss_a0 * np.ones(self.ss_simN)
z0 = np.zeros(self.ss_simN, dtype=np.int32)
z0[np.linspace(0, 1, self.ss_simN) > self.ini_p_z[0]] = 1
# b. find R_ss (first go)
self.R_ss = optimize.bisect(
self.check_supply_and_demand,
self.R_low,
self.R_high,
args=(a0, z0, print_results),
xtol=self.ss_R_tol * 100,
)
self.check_supply_and_demand(self.R_ss, a0, z0)
print(f" update initial distribution")
# b. find R_ss (second go)
a0 = | np.copy(self.ss_sim_a) | numpy.copy |
from typing import Union, Optional
import pytest
import scanpy as sc
import cellrank.external as cre
from anndata import AnnData
from cellrank.tl.kernels import ConnectivityKernel
from cellrank.external.kernels._utils import MarkerGenes
from cellrank.external.kernels._wot_kernel import LastTimePoint
import numpy as np
import pandas as pd
from scipy.sparse import spmatrix, csr_matrix
from pandas.core.dtypes.common import is_categorical_dtype
from matplotlib.cm import get_cmap
from matplotlib.colors import to_hex
class TestOTKernel:
def test_no_connectivities(self, adata_large: AnnData):
del adata_large.obsp["connectivities"]
terminal_states = np.full((adata_large.n_obs,), fill_value=np.nan, dtype=object)
ixs = np.where(adata_large.obs["clusters"] == "Granule immature")[0]
terminal_states[ixs] = "GI"
ok = cre.kernels.StationaryOTKernel(
adata_large,
terminal_states=pd.Series(terminal_states).astype("category"),
g=np.ones((adata_large.n_obs,), dtype=np.float64),
)
ok = ok.compute_transition_matrix(1, 0.001)
assert ok._conn is None
np.testing.assert_allclose(ok.transition_matrix.sum(1), 1.0)
def test_method_not_implemented(self, adata_large: AnnData):
terminal_states = np.full((adata_large.n_obs,), fill_value=np.nan, dtype=object)
ixs = np.where(adata_large.obs["clusters"] == "Granule immature")[0]
terminal_states[ixs] = "GI"
ok = cre.kernels.StationaryOTKernel(
adata_large,
terminal_states=pd.Series(terminal_states).astype("category"),
g=np.ones((adata_large.n_obs,), dtype=np.float64),
)
with pytest.raises(
NotImplementedError, match="Method `'unbal'` is not yet implemented."
):
ok.compute_transition_matrix(1, 0.001, method="unbal")
def test_no_terminal_states(self, adata_large: AnnData):
with pytest.raises(RuntimeError, match="Unable to initialize the kernel."):
cre.kernels.StationaryOTKernel(
adata_large,
g=np.ones((adata_large.n_obs,), dtype=np.float64),
)
def test_normal_run(self, adata_large: AnnData):
terminal_states = np.full((adata_large.n_obs,), fill_value=np.nan, dtype=object)
ixs = np.where(adata_large.obs["clusters"] == "Granule immature")[0]
terminal_states[ixs] = "GI"
ok = cre.kernels.StationaryOTKernel(
adata_large,
terminal_states=pd.Series(terminal_states).astype("category"),
g=np.ones((adata_large.n_obs,), dtype=np.float64),
)
ok = ok.compute_transition_matrix(1, 0.001)
assert isinstance(ok, cre.kernels.StationaryOTKernel)
assert isinstance(ok._transition_matrix, csr_matrix)
np.testing.assert_allclose(ok.transition_matrix.sum(1), 1.0)
assert isinstance(ok.params, dict)
@pytest.mark.parametrize("connectivity_kernel", (None, ConnectivityKernel))
def test_compute_projection(
self, adata_large: AnnData, connectivity_kernel: Optional[ConnectivityKernel]
):
terminal_states = np.full((adata_large.n_obs,), fill_value=np.nan, dtype=object)
ixs = np.where(adata_large.obs["clusters"] == "Granule immature")[0]
terminal_states[ixs] = "GI"
ok = cre.kernels.StationaryOTKernel(
adata_large,
terminal_states=pd.Series(terminal_states).astype("category"),
g=np.ones((adata_large.n_obs,), dtype=np.float64),
)
ok = ok.compute_transition_matrix(1, 0.001)
if connectivity_kernel is not None:
ck = connectivity_kernel(adata_large).compute_transition_matrix()
combined_kernel = 0.9 * ok + 0.1 * ck
combined_kernel.compute_transition_matrix()
else:
combined_kernel = ok
expected_error = (
r"<StationaryOTKernel> is not a kNN based kernel. The embedding projection "
r"only works for kNN based kernels."
)
with pytest.raises(AttributeError, match=expected_error):
combined_kernel.compute_projection()
class TestWOTKernel:
def test_no_connectivities(self, adata_large: AnnData):
del adata_large.obsp["connectivities"]
ok = cre.kernels.WOTKernel(
adata_large, time_key="age(days)"
).compute_transition_matrix()
assert ok._conn is None
np.testing.assert_allclose(ok.transition_matrix.sum(1), 1.0)
def test_invalid_solver_kwargs(self, adata_large: AnnData):
ok = cre.kernels.WOTKernel(adata_large, time_key="age(days)")
with pytest.raises(TypeError, match="unexpected keyword argument 'foo'"):
ok.compute_transition_matrix(foo="bar")
def test_inversion_updates_adata(self, adata_large: AnnData):
key = "age(days)"
ok = cre.kernels.WOTKernel(adata_large, time_key=key)
assert is_categorical_dtype(adata_large.obs[key])
assert adata_large.obs[key].cat.ordered
np.testing.assert_array_equal(ok.experimental_time, adata_large.obs[key])
orig_time = ok.experimental_time
ok = ~ok
inverted_time = ok.experimental_time
assert is_categorical_dtype(adata_large.obs[key])
assert adata_large.obs[key].cat.ordered
np.testing.assert_array_equal(ok.experimental_time, adata_large.obs[key])
np.testing.assert_array_equal(
orig_time.cat.categories, inverted_time.cat.categories
)
np.testing.assert_array_equal(orig_time.index, inverted_time.index)
with pytest.raises(AssertionError):
np.testing.assert_array_equal(orig_time, inverted_time)
@pytest.mark.parametrize("cmap", ["inferno", "viridis"])
def test_update_colors(self, adata_large: AnnData, cmap: str):
ckey = "age(days)_colors"
_ = cre.kernels.WOTKernel(adata_large, time_key="age(days)", cmap=cmap)
colors = adata_large.uns[ckey]
cmap = get_cmap(cmap)
assert isinstance(colors, np.ndarray)
assert colors.shape == (2,)
np.testing.assert_array_equal(colors, [to_hex(cmap(0)), to_hex(cmap(cmap.N))])
@pytest.mark.parametrize("cmat", [None, "Ms", "X_pca", "good_shape", "bad_shape"])
def test_cost_matrices(self, adata_large: AnnData, cmat: str):
ok = cre.kernels.WOTKernel(adata_large, time_key="age(days)")
if isinstance(cmat, str) and "shape" in cmat:
cost_matrices = {
(12.0, 35.0): np.random.normal(size=(73 + ("bad" in cmat), 127))
}
else:
cost_matrices = cmat
if cmat == "bad_shape":
with pytest.raises(ValueError, match=r"Expected cost matrix for time pair"):
ok.compute_transition_matrix(cost_matrices=cost_matrices)
else:
ok = ok.compute_transition_matrix(cost_matrices=cost_matrices)
param = ok.params["cost_matrices"]
if cmat == "Ms":
assert param == "layer:Ms"
elif cmat == "X_pca":
assert param == "obsm:X_pca"
elif cmat == "good_shape":
# careful, param is `nstr`, which does not equal anything
assert str(param) == "precomputed"
else:
assert param == "default"
@pytest.mark.parametrize("n_iters", [3, 5])
def test_growth_rates(self, adata_large: AnnData, n_iters: int):
ok = cre.kernels.WOTKernel(adata_large, time_key="age(days)")
ok = ok.compute_transition_matrix(growth_iters=n_iters)
assert isinstance(ok.growth_rates, pd.DataFrame)
np.testing.assert_array_equal(adata_large.obs_names, ok.growth_rates.index)
np.testing.assert_array_equal(
ok.growth_rates.columns, [f"g{i}" for i in range(n_iters + 1)]
)
np.testing.assert_array_equal(
adata_large.obs["estimated_growth_rates"], ok.growth_rates[f"g{n_iters}"]
)
assert ok.params["growth_iters"] == n_iters
@pytest.mark.parametrize("key_added", [None, "gr"])
def test_birth_death_process(self, adata_large: AnnData, key_added: Optional[str]):
np.random.seed(42)
adata_large.obs["foo"] = np.random.normal(size=(adata_large.n_obs,))
adata_large.obs["bar"] = np.random.normal(size=(adata_large.n_obs,))
ok = cre.kernels.WOTKernel(adata_large, time_key="age(days)")
gr = ok.compute_initial_growth_rates("foo", "bar", key_added=key_added)
if key_added is None:
assert isinstance(gr, pd.Series)
np.testing.assert_array_equal(gr.index, adata_large.obs_names)
else:
assert gr is None
assert "gr" in adata_large.obs
@pytest.mark.parametrize("ltp", list(LastTimePoint))
def test_last_time_point(self, adata_large: AnnData, ltp: LastTimePoint):
key = "age(days)"
ok = cre.kernels.WOTKernel(adata_large, time_key=key).compute_transition_matrix(
last_time_point=ltp,
conn_kwargs={"n_neighbors": 11},
threshold=None,
)
ixs = np.where(adata_large.obs[key] == 35.0)[0]
T = ok.transition_matrix[ixs, :][:, ixs].A
if ltp == LastTimePoint.UNIFORM:
np.testing.assert_allclose(T, np.ones_like(T) / float(len(ixs)))
elif ltp == LastTimePoint.DIAGONAL:
np.testing.assert_allclose(T, np.eye(len(ixs)))
elif ltp == LastTimePoint.CONNECTIVITIES:
adata_subset = adata_large[adata_large.obs[key] == 35.0]
sc.pp.neighbors(adata_subset, n_neighbors=11)
T_actual = (
ConnectivityKernel(adata_subset)
.compute_transition_matrix()
.transition_matrix.A
)
| np.testing.assert_allclose(T, T_actual) | numpy.testing.assert_allclose |
import numpy as np
import debug
import pytest
@pytest.fixture()
def logger(tmpdir):
path = tmpdir.join('out.zarr')
return debug.ZarrLogger(str(path))
def test_append(logger):
key = 'U'
arr = np.random.rand(100, 10)
logger.append(key, arr)
logger.append(key, arr)
assert logger.root[key].shape == (2, ) + arr.shape
with pytest.raises(ValueError):
logger.append(key, np.random.rand(10, 10))
# test scalar appending
key = 'time'
logger.append(key, np.array([1.0]))
logger.append(key, | np.array([1.0]) | numpy.array |
from IPython.core.display import HTML
HTML("""
<style>
.output_png {
display: table-cell;
text-align: center;
vertical-align: middle;
}
</style>
""")
# remove warnings
import warnings
warnings.filterwarnings('ignore')
# ---
from matplotlib import pyplot as plt
import matplotlib
matplotlib.style.use('ggplot')
import numpy as np
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.feature_selection import SelectFromModel
from sklearn.pipeline import make_pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.cross_validation import StratifiedKFold
from sklearn.grid_search import GridSearchCV
from sklearn.ensemble.gradient_boosting import GradientBoostingClassifier
from sklearn.cross_validation import cross_val_score
import pandas as pd
pd.options.display.max_columns = 100
pd.options.display.max_rows = 100
def combineData():
global data
global targets
# reading train data
train = pd.read_csv('train_title.csv')
# reading test data
test = pd.read_csv('test_title.csv')
# extracting and then removing the targets from the training data
targets = train.Survived
train.drop('Survived',1,inplace=True)
# merging train data and test data for future feature engineering
data = train.append(test)
data.reset_index(inplace=True)
data.drop('index',inplace=True,axis=1)
return data
# load the train data
data = combineData()
def main():
# combine train and test data to get more accurate result
# parse the different columns so we can model effectivly
parseAges()
parseNames()
parseEmbarked()
parseCabins()
parseSex()
parsePClass()
parseTickets()
parseFamilys()
scaleFeatures() # normalise all the features except the passengerId
train,test,targets = recoverVars()
#print data.info() USED FOR TESTING
# Tree based estimators to compute important features
clf = ExtraTreesClassifier(n_estimators=210)
clf = clf.fit(train, targets)
features = pd.DataFrame()
features['feature'] = train.columns
features['importance'] = clf.feature_importances_
# print features.sort(['importance'],ascending=False) TESTING FEATURES
model = SelectFromModel(clf, prefit=True)
train_new = model.transform(train)
test_new = model.transform(test)
#print train_new.shape TESTING
#print test_new.shape TESTING
# Modeling
forest = RandomForestClassifier(max_features='sqrt')
parameter_grid = {
'max_depth' : [4,5,6,7,8],
'n_estimators': [200,210,240,250],
'criterion': ['gini','entropy']
}
cross_validation = StratifiedKFold(targets, n_folds=5)
grid_search = GridSearchCV(forest,
param_grid=parameter_grid,
cv=cross_validation)
grid_search.fit(train_new, targets)
print('Best score: {}'.format(grid_search.best_score_))
print('Best parameters: {}'.format(grid_search.best_params_))
output = grid_search.predict(test_new).astype(int)
df_output = pd.DataFrame()
df_output['PassengerId'] = test['PassengerId']
df_output['Survived'] = output
df_output[['PassengerId','Survived']].to_csv('output.csv',index=False)
def get_titles():
global data
# we extract the title from each name
data['Title'] = data['Name'].map(lambda name:name.split(',')[1].split('.')[0].strip())
# a map of more aggregated titles
Title_Dictionary = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Royalty",
"Dona": "Royalty",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master",
"Lady" : "Royalty"
}
# we map each title
data['Title'] = data.Title.map(Title_Dictionary)
def parseAges():
global data
# a function that fills the missing values of the Age variable
def fillAges(row):
if row['Sex']=='female' and row['Pclass'] == 1:
if row['Title'] == 'Miss':
return 30
elif row['Title'] == 'Mrs':
return 45
elif row['Title'] == 'Officer':
return 49
elif row['Title'] == 'Royalty':
return 39
elif row['Sex']=='female' and row['Pclass'] == 2:
if row['Title'] == 'Miss':
return 20
elif row['Title'] == 'Mrs':
return 30
elif row['Sex']=='female' and row['Pclass'] == 3:
if row['Title'] == 'Miss':
return 18
elif row['Title'] == 'Mrs' or row['Title'] == 'Ms':
return 31
elif row['Sex']=='male' and row['Pclass'] == 1:
if row['Title'] == 'Master':
return 6
elif row['Title'] == 'Mr':
return 41.5
elif row['Title'] == 'Officer':
return 52
elif row['Title'] == 'Royalty':
return 40
elif row['Title'] == 'Dr':
return 41
elif row['Sex']=='male' and row['Pclass'] == 2:
if row['Title'] == 'Master':
return 2
elif row['Title'] == 'Mr':
return 30
elif row['Title'] == 'Officer':
return 41.5
elif row['Sex']=='male' and row['Pclass'] == 3:
if row['Title'] == 'Master':
return 6
elif row['Title'] == 'Mr':
return 26
data.Age = data.apply(lambda r : fillAges(r) if pd.isnull(r['Age']) else r['Age'], axis=1)
def parseNames():
global data
# we clean the Name variable
data.drop('Name',axis=1,inplace=True)
# encoding in dummy variable
titles_dummies = pd.get_dummies(data['Title'],prefix='Title')
data = pd.concat([data,titles_dummies],axis=1)
# removing the title variable
data.drop('Title',axis=1,inplace=True)
data.Fare.fillna(data.Fare.mean(),inplace=True) # replaces single fare with mean
def parseEmbarked():
global data
data.Embarked.fillna('S',inplace=True) # replace two missing embarked values
embarked_dummies = pd.get_dummies(data['Embarked'],prefix='Embarked')
data = pd.concat([data,embarked_dummies],axis=1)
data.drop('Embarked',axis=1,inplace=True)
def parseCabins():
global data
# replacing missing cabins with U (for Uknown)
data.Cabin.fillna('U',inplace=True)
# mapping each Cabin value with the cabin letter
data['Cabin'] = data['Cabin'].map(lambda c : c[0])
# dummy encoding ...
cabin_dummies = pd.get_dummies(data['Cabin'],prefix='Cabin')
data = pd.concat([data,cabin_dummies],axis=1)
data.drop('Cabin',axis=1,inplace=True)
def parseSex():
global data
# mapping string values to numerical one
data['Sex'] = data['Sex'].map({'male':1,'female':0})
def parsePClass():
global data
# encoding into 3 categories:
pclass_dummies = pd.get_dummies(data['Pclass'],prefix="Pclass")
# adding dummy variables
data = pd.concat([data,pclass_dummies],axis=1)
# removing "Pclass"
data.drop('Pclass',axis=1,inplace=True)
def parseTickets():
global data
# a function that extracts each prefix of the ticket, returns 'XXX' if no prefix (i.e the ticket is a digit)
def cleanTicket(ticket):
ticket = ticket.replace('.','')
ticket = ticket.replace('/','')
ticket = ticket.split()
ticket = map(lambda t : t.strip() , ticket)
ticket = filter(lambda t : not t.isdigit(), ticket)
if len(ticket) > 0:
return ticket[0]
else:
return 'XXX'
# Extracting dummy variables from tickets:
data['Ticket'] = data['Ticket'].map(cleanTicket)
tickets_dummies = pd.get_dummies(data['Ticket'],prefix='Ticket')
data = pd.concat([data, tickets_dummies],axis=1)
data.drop('Ticket',inplace=True,axis=1)
def parseFamilys():
global data
# introducing a new feature : the size of families (including the passenger)
data['FamilySize'] = data['Parch'] + data['SibSp'] + 1
# introducing other features based on the family size
data['Singleton'] = data['FamilySize'].map(lambda s : 1 if s == 1 else 0)
data['SmallFamily'] = data['FamilySize'].map(lambda s : 1 if 2<=s<=4 else 0)
data['LargeFamily'] = data['FamilySize'].map(lambda s : 1 if 5<=s else 0)
def scaleFeatures():
global data
features = list(data.columns)
features.remove('PassengerId')
data[features] = data[features].apply(lambda x: x/x.max(), axis=0)
def score(clf, X, y,scoring='accuracy'):
xval = cross_val_score(clf, X, y, cv = 5,scoring=scoring)
return | np.mean(xval) | numpy.mean |
#The main idea here that we try to approximate the light curve by Fourier series with different periods
#and choose that one, for which the sum of square deviations dots from the approximation is the smallest.
#Then programm build a light curve and phase curve. All dots that are stands out from the approximation
#is cutted off. Program writes in the file the pictures of phase curves and data with cutted points
Version = "V1.0.0"
"""==========================================="""
"""IMPORTING LIBRUARIES"""
"""==========================================="""
import scipy.optimize as spo #for the method of LS
import numpy as np #for math stuff
import matplotlib.pyplot as plt #for plotting
import time #to know time of calculations
import tkinter as tnk #graphic interface
import os #to work with directories
import decimal
import matplotlib.font_manager
import warnings
warnings.filterwarnings("ignore")
"""==========================================="""
"""Path to files"""
"""==========================================="""
path_file = os.getcwd() #constant for the path to the folder, where code is stored
"""==========================================="""
"""ERRORS"""
"""==========================================="""
def Error_1(): #function to display an error in Manual mode that is caused by inputting not correct value of T
window_error = tnk.Tk()
bcg_cl = '#ffff00'
window_error.title("Period D&P " + Version)
w = 550
h = 180
window_error.geometry(str(w) + 'x' + str(h))
window_error.config(bg=bcg_cl)
window_error.resizable(width=False, height=False)
lb_error = tnk.Label(window_error, font = ('Algerian', 19), text = 'Error #1', bg=bcg_cl)
lb_describtion_1 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = 'The program has not found minimum in periodogram', bg=bcg_cl)
lb_describtion_2 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = 'Please try another period or its error', bg=bcg_cl)
lb_error.place(x = 200, y = 30) #their place on the window
lb_describtion_1.place(x = 20, y = 80)
lb_describtion_2.place(x = 90, y = 110)
window_error.mainloop()
def Error_2(File, Number_error): #function to display an error that arrive due to absense of some files
window_error = tnk.Tk()
bcg_cl = '#9999FF'
window_error.title("Period D&P " + Version)
w = 850
h = 180
window_error.geometry(str(w) + 'x' + str(h))
window_error.config(bg=bcg_cl)
window_error.resizable(width=False, height=False)
if Number_error == 1:
error_text = 'The program has not found ' + File
lb_error = tnk.Label(window_error, font = ('Algerian', 24), text = 'Error #2.1', bg=bcg_cl)
if Number_error == 2:
error_text = 'Problem while reading ' + File
lb_error = tnk.Label(window_error, font = ('Algerian', 24), text = 'Error #2.2', bg=bcg_cl)
lb_describtion_1 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = error_text, bg=bcg_cl)
lb_describtion_2 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = 'Please check and repeat', bg=bcg_cl)
lb_error.place(x = 350, y = 30)
lb_describtion_1.place(x = 20, y = 80)
lb_describtion_2.place(x = 240, y = 110)
window_error.mainloop()
"""==========================================="""
"""TRIGONOMETRIC POLYNOMIAL FUNCTIONS"""
"""==========================================="""
def sin(t, pp, n): #approximation of function by Fourie series (t -> x_data, pp - parameters)
x = np.zeros(len(t))
x += pp[0]
for i in range(n):
x += pp[2*i+2]*np.sin(2*np.pi*t*(i+1)/pp[1]+pp[2*i+3]) # x = SUM( A*sin(2*pi*n*t/T + phi))
return x
def sin1(t, pp, n): #the same as sin(), but give you not array, but a value
y = pp[0]
for i in range(n):
y += pp[2*i+2]*np.sin(2*np.pi*t/pp[1]*(i+1)+pp[2*i+3])
return y
def Trend(t, pp):
y = pp[0] + pp[1] * t
return y
def Polymom(t, pp, n):
y = pp[0]
for i in range(1, n+1):
y+= pp[i]*(t**i)
return y
"""==========================================="""
"""READING DATA FROM FILE"""
"""==========================================="""
def read_data(name): #function to read raw data
Name = path_file + '/data/' + name #data is stored in the same sirectory in the folder "data"
try:
Data = np.loadtxt(Name)
x = np.array(Data[:,0])
y = np.array(Data[:,1])
y_err = np.array(Data[:,2])
Error_program = 0
except FileNotFoundError:
Error_program = 1
x = 0
y = 0
y_err = 0
except ValueError:
Error_program = 2
x = 0
y = 0
y_err = 0
return x, y, y_err, Error_program
"""==========================================="""
"""READING PARAMETERS AND TASKS FROM FILE"""
"""==========================================="""
def read_parametrs(Parametrs_file): #function to read parameters for work
try:
parametrs = np.loadtxt(Parametrs_file)
n_app_T = int(parametrs[0]) #number of additions in Fourie series in function Approximation T
n_approximation = int(parametrs[1]) #number of additions in Fourie series in function becoming perfect
edge_appr_T = float(parametrs[2]) #to cut minimum in periodogram
TT_min_par = float(parametrs[3]) #the minimum value of period in Periodogram
Presize_appr_T = float(parametrs[4]) #the distance between points in the Periodogram
ratio = float(parametrs[5]) #size of Phase picture (x:y)
dpi_picture = int(parametrs[6]) #quality of picture
dots_size = int(parametrs[7]) #size of dots ob phase curves
Start_phase = float(parametrs[8]) #start phase of observation
Error_program = 0
return n_app_T, n_approximation, edge_appr_T, TT_min_par, Presize_appr_T, ratio, dpi_picture, dots_size, Start_phase, Error_program
except FileNotFoundError:
Error_program = 1
return 0,0,0,0,0,0,0,0,0,Error_program
except ValueError:
Error_program = 2
return 0,0,0,0,0,0,0,0,0,Error_program
def read_task(task_file):
try:
Task = np.genfromtxt(task_file, dtype='str')
for value in Task:
if not len(value.split('.')) == 2:
raise ValueError
Error_program_task = 0
except FileNotFoundError:
Error_program_task = 1
except ValueError:
Error_program_task = 2
return Task, Error_program_task
"""==========================================="""
"""CALCULATING PRESIZE VALUE OF PERIOD"""
"""==========================================="""
def first_approximation(Tappr, A0, x, y, y_err, n_approximation, name, n_app_T, ans_start, dpi_picture, dots_size, ratio, I):
p0 = np.ones(2*n_approximation + 2) #start conditions
p0[0] = ans_start[0] #first = ideal from periodogram
p0[1] = Tappr
if(n_approximation > n_app_T): #set conditions the same as the best in ApproximationT
for i in range(2*n_app_T):
p0[i+2] = ans_start[i+1]
else:
for i in range(2*n_approximation + 2):
p0[i+2] = ans_start[i]
fun = lambda pp: (y - sin(x, pp, n_approximation))/y_err #core of least squares
ans = spo.leastsq(fun, p0, full_output=1)
sigma = np.sum((y - sin(x, ans[0], n_approximation))**2)/len(x)
error = np.sqrt(np.diag(ans[1]*sigma))
T_ideal = ans[0][1]
error_T = error[1]
ans_ideal = ans[0] #ideal parametrs
order_Error = -int(np.log10(error_T))+1 #evaluate order of Error
save_path = path_file + '/Results/' + name + '/' #save results in the folder "Results"
fig = plt.figure(2 + I * 6) #plot dots and curve
plt.gca().invert_yaxis() #to invert y axis
fig.set_size_inches(20, 7)
plt.rc('xtick', labelsize=20) #size of tics
plt.rc('ytick', labelsize=20)
plt.plot(x, y, '.b') #blue dots
plt.xlabel('BJD', fontsize = 20) #name of axis
plt.ylabel('$\Delta$T, mmag', fontsize = 20)
plt.title('Light curve', fontsize = 20)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.savefig(save_path + name + " light curve.png", dpi = 300) #without approximation
xx = np.linspace(min(x), max(x), len(x)) #to plot approximation on the parts, where are not data
plt.plot(xx, sin(xx, ans_ideal, n_approximation), '-r')
plt.savefig(save_path + name + " light curve with approximation.png", dpi = dpi_picture) #with approximation
plt.close()
return ans_ideal, np.round(T_ideal, order_Error)
def remove_trends(x, y, y_err, ans_ideal, name, n_approximation, dpi_picture, dots_size, ratio, I):
y_new = y.copy()
sigma = np.sqrt(np.sum((y - sin(x, ans_ideal, n_approximation))**2)/len(x))
key = True
for index in range(len(x)):
Condition = np.abs(y[index] - sin1(x[index], ans_ideal, n_approximation)) > (3*sigma)
if key and Condition:
Index1 = index
key = False
if (not key) and (not Condition):
Index2 = index
key = True
if (Index2 - Index1) > 2: #removing trend
y_trend = y[Index1:(Index2+1)]
y_err_trend = y_err[Index1:(Index2+1)]
x_trend = x[Index1:(Index2+1)]
trend = y_trend - sin(x_trend, ans_ideal, n_approximation)
p0 = [1, 1]
fun = lambda pp: (trend - Trend(x_trend, pp))/y_err_trend
ans = spo.leastsq(fun, p0, full_output=1)
y_new[Index1:(Index2+1)] -= Trend(x_trend, ans[0])
save_path = path_file + '/Results/' + name + '/' #save results in the folder "Results"
fig = plt.figure(3 + I*6) #plot dots and curve
plt.gca().invert_yaxis()
fig.set_size_inches(20, 7)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.plot(x, y, '.g')
plt.plot(x, y_new, '.b')
xx = np.linspace(min(x), max(x), len(x)) #to plot approximation on the parts, where are not data
plt.plot(xx, sin(xx, ans_ideal, n_approximation), '-r')
plt.xlabel('BJD', fontsize = 20)
plt.ylabel('$\Delta$T, mmag', fontsize = 20)
plt.title('Light curve (trends)', fontsize = 20)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.savefig(save_path + name + " light curve no trends.png", dpi = 300)
#without approximation
return y
def remove_linear(x, y, y_err):
number = 10
key = 0
for i in range(10):
key += np.sign(y[1] - y[0])
key = np.round(key/10)
key1 = 0
for i in range(1, len(x)):
if not np.sign(y[i] - y[i-1]) == key:
key1 += 1
if key1 == 150:
break
if i > number:
x_new = x[i:]
y_new = y[i:]
y_err_new = y_err[i:]
return x_new, y_new, y_err_new
else:
return x, y, y_err
def remove_trends_2(x, y, y_err, ans_ideal, name, ftype, n_approximation, dpi_picture, dots_size, ratio, I):
n = 3
start = [] #cutting in parts
end = []
start.append(0)
delta = x[1] - x[0]
for i in range(len(x)-1):
if (x[i+1] - x[i]) > 100*delta:
end.append(i)
start.append(i+1)
end.append(len(x)-1)
save_path = path_file + '/Results/' + name + '/'
fig, axs = plt.subplots(4, 1)
fig.subplots_adjust(hspace=0)
fig.set_size_inches(30, 30)
plt.rc('ytick', labelsize=30)
axs[0].set_title('Light curve (trends) - ' + name, fontsize = 35)
xx = np.linspace(np.min(x), np.max(x), len(x))
axs[0].plot(x, y, '.g')
#axs[0].plot(xx, sin(xx, ans_ideal, n_approximation), '.r')
plt.rc('xtick', labelsize=30)
for i in range(4):
axs[i].set_ylabel('$\Delta$T, mmag', fontsize = 30)
axs[i].invert_yaxis()
X_new = np.array([])
Y_new = np.array([])
Y_err_new = np.array([])
for i in range(len(start)):
x_part = x[start[i]:end[i]].copy()
y_part = y[start[i]:end[i]].copy()
y_err_part = y_err[start[i]:end[i]].copy()
x_part, y_part, y_err_part = remove_linear(x_part, y_part, y_err_part) # ?????????????
if len(x_part) > n+1:
p0 = 0.1 * np.ones(n+1)
fun = lambda pp: (y_part - sin(x_part, ans_ideal, n_approximation) - Polymom(x_part, pp, n)) / y_err_part
ans = spo.leastsq(fun, p0, full_output=1)
xx = np.linspace(np.min(x_part), np.max(x_part), len(x_part))
axs[1].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
axs[1].plot(xx, Polymom(xx, ans[0], n), '.r')
y_part -= Polymom(x_part, ans[0], n)
axs[2].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
else:
axs[1].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
axs[2].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
X_new = np.concatenate((X_new, x_part))
Y_new = np.concatenate((Y_new, y_part))
Y_err_new = np.concatenate((Y_err_new, y_err_part))
x = X_new.copy()
y = Y_new.copy()
y_err = Y_err_new.copy()
sigma = np.sqrt(np.sum((y - sin(x, ans_ideal, n_approximation))**2) / len(x) )
axs[2].axhline(y = 3*sigma)
axs[2].axhline(y = -3*sigma)
Condition = abs(y - sin1(x, ans_ideal, n_approximation)) < 3*sigma
x, y, y_err = x[Condition], y[Condition], y_err[Condition]
p0 = ans_ideal
fun = lambda pp: (y - sin(x, pp, n_approximation))/y_err
ans = spo.leastsq(fun, p0, full_output=1)
sigma = np.sum((y - sin(x, ans[0], n_approximation))**2)/len(x)
error = np.sqrt(np.diag(ans[1]*sigma))
order_Error = -int(np.log10(error[1]))+1 # evaluate order of Error
Mean = np.mean(y)
SS_res = np.sum((y - sin(x, ans[0], n_approximation))**2)
SS_tot = np.sum((y - Mean)**2)
R_2 = 1 - SS_res/SS_tot
chi_2 = np.sum(((y - sin(x, ans[0], n_approximation))**2)/y_err**2)/( len(x) - (2*n_approximation + 1))
def sin_chi(t):
pp = ans[0]
z = np.zeros(len(x))
z += pp[0]
for i in range(n_approximation):
z += pp[2*i+2] * np.sin(2*np.pi*x*(i+1)/t + pp[2*i+3])
chi_2_new = np.sum(((y - z)**2)/y_err**2)/( len(x) - (2*n_approximation + 1))
return (chi_2_new - chi_2 - 1)
root = spo.fsolve(sin_chi, ans[0][1])
xx = np.linspace(np.min(x), np.max(x), len(x))
#axs[3].plot(xx, sin(xx, ans[0], n_approximation), '.r')
axs[3].plot(x, y, '.g')
plt.xlabel('BJD', fontsize = 20)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.savefig(save_path + name + " light curve trends.png", dpi = 300)
NName = name + "_detrended." + ftype #save data in the same file type
completeName = os.path.join(save_path, NName)
with open(completeName, 'w+') as f:
for i in range(len(x)):
f.write(str(x[i]) + ' ' + str(y[i]) + ' ' + str(y_err[i]) + '\n')
return x, y, y_err, np.round(ans[0][1], order_Error), np.round(error[1], order_Error), ans[0][1]-root[0], R_2, chi_2, ans[0]
def phase_curve(T_ideal, answ, x, y, y_err, n_approximation, name, ftype, ratio, dpi_picture, dots_size, Start_phase, key_number, I):
d = decimal.Decimal(str(T_ideal))
if key_number == 1:
order_Error = -d.as_tuple().exponent
else:
order_Error = -d.as_tuple().exponent-1
Number_periods = (x - x[0])/T_ideal #To build phase curve
Number_periods = Number_periods.astype(int)
I_max = np.argmax(y)
X_E = (x - x[0])/T_ideal - Number_periods
X_E -= X_E[I_max]
X_E[X_E < 0] += 1
save_path = path_file + '/Results/' + name + '/'
B = max(y) - min(y)
hfont = {'fontname':'Helvetica'}
fig = plt.figure(4 + I * 6)
plt.gca().invert_yaxis()
fig.set_size_inches(ratio*7, 7)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
strin = 'Phase (P = ' + str(np.round(Start_phase + x[I_max], order_Error)) + ' +' + str(np.round(T_ideal, order_Error)) + '*E)'
plt.xlabel(strin, fontsize = 20, **hfont)
plt.ylabel('$\Delta$T, mmag', fontsize = 20, **hfont)
plt.plot(X_E, y, color = 'green', linestyle = '', marker = '.', markersize = dots_size)
plt.text(0, (np.min(y) + 1/30*B), name, fontsize = 20, **hfont)
if key_number == 1:
plt.savefig(save_path + name + "phase curve first.png", dpi = dpi_picture)
else:
plt.savefig(save_path + name + "phase curve.png", dpi = dpi_picture)
plt.close()
NName = name + " phase curve." + ftype #save data in the same file type
completeName = os.path.join(save_path, NName)
with open(completeName, 'w+') as f:
for i in range(len(x)):
f.write(str(X_E[i]) + ' ' + str(y[i]) + ' ' + str(y_err[i]) + '\n')
"""==========================================="""
"""COMPUTING APPROXIMATE VALUE OF PERIOD"""
"""==========================================="""
def Approximation_T(x, y, y_err, A, n_app_T, edge_appr_T, T_max, T_min, Presize_appr_T, name, dpi_picture, I):
N_N = int(T_max/Presize_appr_T) #number of dots in this area
X_min = 0 #just for fun(do not change)
def sin2(t, T_Tt, pp, nn): #approximation of function that take x data, period and parametrs and give the approximation function
x = np.zeros(len(t)) #make array x lenth of x-data and full zero
x += pp[0]
for i in range(nn): #additions in Fourie series
x += pp[2*i + 1]*np.sin(2*np.pi*t/T_Tt*(i+1)+pp[2*i+2])
return x #return tha value of approximation function
def sigma(xx, yy, yy_err, T_Tt, p00, nn): #function to find the sum of squares for each T
fun = lambda pp: (yy - sin2(xx, T_Tt, pp, nn))/yy_err #core of least squares
ans = spo.leastsq(fun, p00, full_output=1)
Sigma = np.sum((yy-sin2(xx, T_Tt, ans[0], nn))**2)/(len(x)*(len(x)-1)) #ans[0] - parametrs: amplitudes and phases
return Sigma, ans[0]
p0 = np.ones(2*n_app_T+1)
p0[0], p0[1] = 0, A #main amplitude
x_sigma = np.linspace(T_min, T_max, N_N)
y_sigma = np.zeros(N_N)
for i in range(len(x_sigma)): #for each dot
if(x_sigma[i] == T_min):
y_sigma[i], PP0 = sigma(x, y, y_err, x_sigma[i], p0, n_app_T) #find y and ideal parametrs
else:
y_sigma[i], PP0 = sigma(x, y, y_err, x_sigma[i], PP0, n_app_T) #start condition = ideal for previous
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
fig = plt.figure(1 + I * 6)
fig.set_size_inches(20, 6)
save_path = path_file + '/Results/' + name + '/'
plt.xlabel('Period', fontsize = 20)
plt.ylabel('Sigma', fontsize = 20)
plt.plot(x_sigma, y_sigma, color = '#FF0000', ls = '-', lw = 2)
plt.savefig(save_path + name + "periodogram.png", dpi = dpi_picture)
plt.close()
value_error = False
if ((np.min(y_sigma)/np.max(y_sigma)) < 0.3):
value_error = True #there is no true minimum
if value_error:
Index = | np.argmin(y_sigma) | numpy.argmin |
'''
Created: 2022/02/11
Maintainer: <NAME> <<EMAIL>>
adapted from https://github.com/ethz-asl/robotcar_tools/blob/master/python/interpolate_poses.py
LICENSE: MIT
'''
import transformations as tfs
import numpy as np
import argparse
import bisect
import transformations as tfs
def main(kf_pose_fname, timestamps_fname):
kf_pose = np.genfromtxt(kf_pose_fname)
timestamps = np.genfromtxt(timestamps_fname)
timestamps = np.squeeze(timestamps[:, 1]) * 1e6
pose_timestamps = kf_pose[:, 0] * 1e6
abs_poses = kf_pose[:, 1:]
interpolated_pose = interpolate_poses(pose_timestamps.astype(np.int64).tolist(), abs_poses,
timestamps.astype(np.int64).tolist(), int(timestamps[0]))
np.savetxt(kf_pose_fname.replace(".txt", "_interp.txt"), np.array(interpolated_pose), fmt="%1.6f")
def interpolate_poses(pose_timestamps, abs_poses, requested_timestamps, origin_timestamp):
"""Interpolate between absolute poses.
Args:
pose_timestamps (list[int]): Timestamps of supplied poses. Must be in ascending order.
abs_poses (list[numpy.matrixlib.defmatrix.matrix]): SE3 matrices representing poses at the timestamps specified.
requested_timestamps (list[int]): Timestamps for which interpolated timestamps are required.
origin_timestamp (int): UNIX timestamp of origin frame. Poses will be reported relative to this frame.
Returns:
list[numpy.matrixlib.defmatrix.matrix]: SE3 matrix representing interpolated pose for each requested timestamp.
Raises:
ValueError: if pose_timestamps and abs_poses are not the same length
ValueError: if pose_timestamps is not in ascending order
"""
requested_timestamps.insert(0, origin_timestamp)
requested_timestamps = np.array(requested_timestamps)
pose_timestamps = np.array(pose_timestamps)
if len(pose_timestamps) != len(abs_poses):
raise ValueError('Must supply same number of timestamps as poses')
abs_quaternions = np.zeros((4, len(abs_poses)))
abs_positions = np.zeros((3, len(abs_poses)))
for i, pose in enumerate(abs_poses):
if i > 0 and pose_timestamps[i - 1] >= pose_timestamps[i]:
raise ValueError('Pose timestamps must be in ascending order')
abs_quaternions[:, i] = pose[
3:] # np.roll(pose[3:], -1) uncomment this if the quaternion is saved as [w, x, y, z]
abs_positions[:, i] = pose[:3]
upper_indices = [bisect.bisect(pose_timestamps, pt) for pt in requested_timestamps]
lower_indices = [u - 1 for u in upper_indices]
if max(upper_indices) >= len(pose_timestamps):
upper_indices = [min(i, len(pose_timestamps) - 1) for i in upper_indices]
fractions = (requested_timestamps - pose_timestamps[lower_indices]) // \
(pose_timestamps[upper_indices] - pose_timestamps[lower_indices])
quaternions_lower = abs_quaternions[:, lower_indices]
quaternions_upper = abs_quaternions[:, upper_indices]
d_array = (quaternions_lower * quaternions_upper).sum(0)
linear_interp_indices = np.nonzero(d_array >= 1)
sin_interp_indices = np.nonzero(d_array < 1)
scale0_array = np.zeros(d_array.shape)
scale1_array = np.zeros(d_array.shape)
scale0_array[linear_interp_indices] = 1 - fractions[linear_interp_indices]
scale1_array[linear_interp_indices] = fractions[linear_interp_indices]
theta_array = np.arccos( | np.abs(d_array[sin_interp_indices]) | numpy.abs |
import numpy as np
from os import listdir
from matplotlib import pyplot as plt
def apply_spectrum(data, pca, numinput=256, power=1.0):
colored = data.dot(np.diag(np.power(pca.sValues[:numinput], power)))
return colored/colored.std()
def get_params_and_errors(net, toy, nunits=256, folder='.',
filestart='toy', ds=1.0):
filelist = listdir(folder)
goodfiles = []
firing_rates = []
gains = []
errors = []
modfit = []
peaks = []
peakmodfits = []
exceptions = []
for file in filelist:
dsflag = False
if 'ds' in file:
dsflag = file.split('ds')[1].startswith(str(ds))
if file.endswith('.pickle') and file.startswith(filestart) and dsflag:
file = folder+file
try:
net.load(file)
except BaseException as ee:
exceptions.append(file)
continue
try:
fit = np.load(file + 'fit.npy')
except FileNotFoundError:
fit = net.modfits
ok = net.nunits == nunits
directtest = toy.test_fit(net.Q)
ok = ok and not (directtest - fit[-1]) > 0.01 and fit[-1] != 0
if ok:
modfit.append(fit[-1])
err = np.mean(net.errorhist[-1000:])
goodfiles.append(file)
errors.append(err)
firing_rates.append(net.p)
gains.append(net.gain)
peaks.append(np.min(net.errorhist))
peakmodfits.append(np.max(fit))
else:
exceptions.append(file)
print('Errors on ', str(len(exceptions)), ' files')
if len(goodfiles) == 0:
if len(exceptions) == 0:
raise FileNotFoundError('No valid files found.')
raise BaseException(exceptions[0])
return (goodfiles, firing_rates, gains, errors, peaks, modfit, peakmodfits)
def hp_scatter(firing_rates, gains, modfits, fig=None, ax=None):
if fig is None:
fig = plt.figure()
if ax is None:
ax = fig.add_subplot(111)
modfits = [0 if np.isnan(mf) else mf for mf in modfits]
sc = ax.scatter(firing_rates, gains, c=modfits, cmap='viridis', s=200)
ax.set_xlabel('Firing rate p')
ax.set_ylabel('Gain')
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlim([np.min(firing_rates)*0.8, np.max(firing_rates)*1.2])
ax.set_ylim([np.min(gains)*0.8, np.max(gains)*1.2])
fig.colorbar(sc, ax=ax)
def err_hp_scatter(firing_rates, gains, errors, fig=None, ax=None):
if fig is None:
fig = plt.figure()
if ax is None:
ax = fig.add_subplot(111)
goodfr = [firing_rates[ii] for ii in range(len(errors)) if errors[ii] < 1.0]
goodg = [gains[ii] for ii in range(len(errors)) if errors[ii] < 1.0]
badfr = [firing_rates[ii] for ii in range(len(errors)) if errors[ii] >= 1.0 or np.isnan(errors[ii])]
badg = [gains[ii] for ii in range(len(errors)) if errors[ii] >= 1.0 or np.isnan(errors[ii])]
errors = [er for er in errors if er < 1.0]
sc = ax.scatter(goodfr, goodg, c=errors, cmap='viridis_r', s=200)
fig.colorbar(sc, ax=ax)
ax.set_xlabel('Firing rate p')
ax.set_ylabel('Gain')
ax.scatter(badfr, badg, c='r', s=50, marker='x')
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlim([ | np.min(firing_rates) | numpy.min |
"""Rangeland Production Model."""
import os
import logging
import tempfile
import shutil
from builtins import range
import re
import math
import pickle
import numpy
import pandas
from osgeo import ogr
from osgeo import osr
from osgeo import gdal
import pygeoprocessing
from rangeland_production import utils
from rangeland_production import validation
LOGGER = logging.getLogger('rangeland_production.forage')
# we only have these types of soils
SOIL_TYPE_LIST = ['clay', 'silt', 'sand']
# temporary directory to store intermediate files
PROCESSING_DIR = None
# user-supplied crude protein of vegetation
CRUDE_PROTEIN = None
# state variables and parameters take their names from Century
# _SITE_STATE_VARIABLE_FILES contains state variables that are a
# property of the site, including:
# carbon in each soil compartment
# (structural, metabolic, som1, som2, som3) and layer (1=surface, 2=soil)
# e.g., som2c_2 = carbon in soil som2;
# N and P in each soil layer and compartment (1=N, 2=P)
# e.g., som2e_1_1 = N in surface som2, som2e_1_2 = P in surface som2;
# water in each soil layer, asmos_<layer>
# state variables fully described in this table:
# https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
_SITE_STATE_VARIABLE_FILES = {
'metabc_1_path': 'metabc_1.tif',
'metabc_2_path': 'metabc_2.tif',
'som1c_1_path': 'som1c_1.tif',
'som1c_2_path': 'som1c_2.tif',
'som2c_1_path': 'som2c_1.tif',
'som2c_2_path': 'som2c_2.tif',
'som3c_path': 'som3c.tif',
'strucc_1_path': 'strucc_1.tif',
'strucc_2_path': 'strucc_2.tif',
'strlig_1_path': 'strlig_1.tif',
'strlig_2_path': 'strlig_2.tif',
'metabe_1_1_path': 'metabe_1_1.tif',
'metabe_2_1_path': 'metabe_2_1.tif',
'som1e_1_1_path': 'som1e_1_1.tif',
'som1e_2_1_path': 'som1e_2_1.tif',
'som2e_1_1_path': 'som2e_1_1.tif',
'som2e_2_1_path': 'som2e_2_1.tif',
'som3e_1_path': 'som3e_1.tif',
'struce_1_1_path': 'struce_1_1.tif',
'struce_2_1_path': 'struce_2_1.tif',
'metabe_1_2_path': 'metabe_1_2.tif',
'metabe_2_2_path': 'metabe_2_2.tif',
'plabil_path': 'plabil.tif',
'secndy_2_path': 'secndy_2.tif',
'parent_2_path': 'parent_2.tif',
'occlud_path': 'occlud.tif',
'som1e_1_2_path': 'som1e_1_2.tif',
'som1e_2_2_path': 'som1e_2_2.tif',
'som2e_1_2_path': 'som2e_1_2.tif',
'som2e_2_2_path': 'som2e_2_2.tif',
'som3e_2_path': 'som3e_2.tif',
'struce_1_2_path': 'struce_1_2.tif',
'struce_2_2_path': 'struce_2_2.tif',
'asmos_1_path': 'asmos_1.tif',
'asmos_2_path': 'asmos_2.tif',
'asmos_3_path': 'asmos_3.tif',
'asmos_4_path': 'asmos_4.tif',
'asmos_5_path': 'asmos_5.tif',
'asmos_6_path': 'asmos_6.tif',
'asmos_7_path': 'asmos_7.tif',
'asmos_8_path': 'asmos_8.tif',
'asmos_9_path': 'asmos_9.tif',
'avh2o_3_path': 'avh2o_3.tif',
'minerl_1_1_path': 'minerl_1_1.tif',
'minerl_2_1_path': 'minerl_2_1.tif',
'minerl_3_1_path': 'minerl_3_1.tif',
'minerl_4_1_path': 'minerl_4_1.tif',
'minerl_5_1_path': 'minerl_5_1.tif',
'minerl_6_1_path': 'minerl_6_1.tif',
'minerl_7_1_path': 'minerl_7_1.tif',
'minerl_8_1_path': 'minerl_8_1.tif',
'minerl_9_1_path': 'minerl_9_1.tif',
'minerl_10_1_path': 'minerl_10_1.tif',
'minerl_1_2_path': 'minerl_1_2.tif',
'minerl_2_2_path': 'minerl_2_2.tif',
'minerl_3_2_path': 'minerl_3_2.tif',
'minerl_4_2_path': 'minerl_4_2.tif',
'minerl_5_2_path': 'minerl_5_2.tif',
'minerl_6_2_path': 'minerl_6_2.tif',
'minerl_7_2_path': 'minerl_7_2.tif',
'minerl_8_2_path': 'minerl_8_2.tif',
'minerl_9_2_path': 'minerl_9_2.tif',
'minerl_10_2_path': 'minerl_10_2.tif',
'snow_path': 'snow.tif',
'snlq_path': 'snlq.tif',
}
# _PFT_STATE_VARIABLES contains state variables that are a
# property of a PFT, including:
# carbon, nitrogen, and phosphorous in aboveground biomass
# where 1=N, 2=P
# e.g. aglivc = C in aboveground live biomass,
# aglive_1 = N in aboveground live biomass;
# carbon, nitrogen, and phosphorous in aboveground standing dead
# biomass, stdedc and stdede;
# carbon, nitrogen and phosphorous in belowground live biomass,
# aglivc and aglive
# state variables fully described in this table:
# https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
_PFT_STATE_VARIABLES = [
'aglivc', 'bglivc', 'stdedc', 'aglive_1', 'bglive_1',
'stdede_1', 'aglive_2', 'bglive_2', 'stdede_2', 'avh2o_1',
'crpstg_1', 'crpstg_2',
]
# intermediate parameters that do not change between timesteps,
# including field capacity and wilting point of each soil layer,
# coefficients describing effect of soil texture on decomposition
# rates
_PERSISTENT_PARAMS_FILES = {
'afiel_1_path': 'afiel_1.tif',
'afiel_2_path': 'afiel_2.tif',
'afiel_3_path': 'afiel_3.tif',
'afiel_4_path': 'afiel_4.tif',
'afiel_5_path': 'afiel_5.tif',
'afiel_6_path': 'afiel_6.tif',
'afiel_7_path': 'afiel_7.tif',
'afiel_8_path': 'afiel_8.tif',
'afiel_9_path': 'afiel_9.tif',
'awilt_1_path': 'awilt_1.tif',
'awilt_2_path': 'awilt_2.tif',
'awilt_3_path': 'awilt_3.tif',
'awilt_4_path': 'awilt_4.tif',
'awilt_5_path': 'awilt_5.tif',
'awilt_6_path': 'awilt_6.tif',
'awilt_7_path': 'awilt_7.tif',
'awilt_8_path': 'awilt_8.tif',
'awilt_9_path': 'awilt_9.tif',
'wc_path': 'wc.tif',
'eftext_path': 'eftext.tif',
'p1co2_2_path': 'p1co2_2.tif',
'fps1s3_path': 'fps1s3.tif',
'orglch_path': 'orglch.tif',
'fps2s3_path': 'fps2s3.tif',
'rnewas_1_1_path': 'rnewas_1_1.tif',
'rnewas_2_1_path': 'rnewas_2_1.tif',
'rnewas_1_2_path': 'rnewas_1_2.tif',
'rnewas_2_2_path': 'rnewas_2_2.tif',
'rnewbs_1_1_path': 'rnewbs_1_1.tif',
'rnewbs_1_2_path': 'rnewbs_1_2.tif',
'rnewbs_2_1_path': 'rnewbs_2_1.tif',
'rnewbs_2_2_path': 'rnewbs_2_2.tif',
'vlossg_path': 'vlossg.tif',
}
# site-level values that are updated once per year
_YEARLY_FILES = {
'annual_precip_path': 'annual_precip.tif',
'baseNdep_path': 'baseNdep.tif',
}
# pft-level values that are updated once per year
_YEARLY_PFT_FILES = ['pltlig_above', 'pltlig_below']
# intermediate values for each plant functional type that are shared
# between submodels, but do not need to be saved as output
_PFT_INTERMEDIATE_VALUES = [
'h2ogef_1', 'tgprod_pot_prod',
'cercrp_min_above_1', 'cercrp_min_above_2',
'cercrp_max_above_1', 'cercrp_max_above_2',
'cercrp_min_below_1', 'cercrp_min_below_2',
'cercrp_max_below_1', 'cercrp_max_below_2',
'tgprod', 'rtsh', 'flgrem', 'fdgrem']
# intermediate site-level values that are shared between submodels,
# but do not need to be saved as output
_SITE_INTERMEDIATE_VALUES = [
'amov_1', 'amov_2', 'amov_3', 'amov_4', 'amov_5', 'amov_6', 'amov_7',
'amov_8', 'amov_9', 'amov_10', 'snowmelt', 'bgwfunc', 'diet_sufficiency']
# fixed parameters for each grazing animal type are adapted from the GRAZPLAN
# model as described by Freer et al. 2012, "The GRAZPLAN animal biology model
# for sheep and cattle and the GrazFeed decision support tool"
_FREER_PARAM_DICT = {
'b_indicus': {
'CN1': 0.0115,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.025,
'CI2': 1.7,
'CI8': 62,
'CI9': 1.7,
'CI15': 0.5,
'CI19': 0.416,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00078,
'CR5': 0.6,
'CR6': 0.00074,
'CR7': 0.5,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.375,
'CL1': 4,
'CL2': 30,
'CL3': 0.6,
'CL5': 0.94,
'CL6': 3.1,
'CL15': 0.032,
'CM1': 0.09,
'CM2': 0.31,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.0025,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CP1': 285,
'CP4': 0.33,
'CP5': 1.8,
'CP6': 2.42,
'CP7': 1.16,
'CP8': 4.11,
'CP9': 343.5,
'CP10': 0.0164,
'CP15': 0.07,
},
'b_taurus': {
'CN1': 0.0115,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.025,
'CI2': 1.7,
'CI8': 62,
'CI9': 1.7,
'CI15': 0.5,
'CI19': 0.416,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00078,
'CR5': 0.6,
'CR6': 0.00074,
'CR7': 0.5,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.375,
'CL1': 4,
'CL2': 30,
'CL3': 0.6,
'CL5': 0.94,
'CL6': 3.1,
'CL15': 0.032,
'CM1': 0.09,
'CM2': 0.36,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.0025,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CP1': 285,
'CP4': 0.33,
'CP5': 1.8,
'CP6': 2.42,
'CP7': 1.16,
'CP8': 4.11,
'CP9': 343.5,
'CP10': 0.0164,
'CP15': 0.07,
},
'indicus_x_taurus': {
'CN1': 0.0115,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.025,
'CI2': 1.7,
'CI8': 62,
'CI9': 1.7,
'CI15': 0.5,
'CI19': 0.416,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00078,
'CR5': 0.6,
'CR6': 0.00074,
'CR7': 0.5,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.375,
'CL1': 4,
'CL2': 30,
'CL3': 0.6,
'CL5': 0.94,
'CL6': 3.1,
'CL15': 0.032,
'CM1': 0.09,
'CM2': 0.335,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.0025,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CP1': 285,
'CP4': 0.33,
'CP5': 1.8,
'CP6': 2.42,
'CP7': 1.16,
'CP8': 4.11,
'CP9': 343.5,
'CP10': 0.0164,
'CP15': 0.07,
},
'sheep': {
'CN1': 0.0157,
'CN2': 0.27,
'CN3': 0.4,
'CI1': 0.04,
'CI2': 1.7,
'CI8': 28,
'CI9': 1.4,
'CI12': 0.15,
'CI13': 0.02,
'CI14': 0.002,
'CI20': 1.5,
'CR1': 0.8,
'CR2': 0.17,
'CR3': 1.7,
'CR4': 0.00112,
'CR5': 0.6,
'CR6': 0.00112,
'CR7': 0,
'CR12': 0.8,
'CR13': 0.35,
'CK1': 0.5,
'CK2': 0.02,
'CK3': 0.85,
'CK5': 0.4,
'CK6': 0.02,
'CK8': 0.133,
'CL0': 0.486,
'CL1': 2,
'CL2': 22,
'CL3': 1,
'CL5': 0.94,
'CL6': 4.7,
'CL15': 0.045,
'CM1': 0.09,
'CM2': 0.26,
'CM3': 0.00008,
'CM4': 0.84,
'CM6': 0.02,
'CM7': 0.9,
'CM16': 0.0026,
'CRD1': 0.3,
'CRD2': 0.25,
'CRD4': 0.007,
'CRD5': 0.005,
'CRD6': 0.35,
'CRD7': 0.1,
'CA1': 0.05,
'CA2': 0.85,
'CA3': 5.5,
'CA4': 0.178,
'CA6': 1,
'CA7': 0.6,
'CW1': 24,
'CW2': 0.004,
'CW3': 0.7,
'CW5': 0.25,
'CW6': 0.072,
'CW7': 1.35,
'CW8': 0.016,
'CW9': 1,
'CW12': 0.025,
'CP1': 150,
'CP4': 0.33,
'CP5': 1.43,
'CP6': 3.38,
'CP7': 0.91,
'CP8': 4.33,
'CP9': 4.37,
'CP10': 0.965,
'CP15': 0.1,
},
}
# Target nodata is for general rasters that are positive, and _IC_NODATA are
# for rasters that are any range
_TARGET_NODATA = -1.0
_IC_NODATA = float(numpy.finfo('float32').min)
# SV_NODATA is for state variables
_SV_NODATA = -1.0
def execute(args):
"""InVEST Forage Model.
[model description]
Parameters:
args['workspace_dir'] (string): path to target output workspace.
args['results_suffix'] (string): (optional) string to append to any
output file names
args['starting_month'] (int): what month to start reporting where
the range 1..12 is equivalent to Jan..Dec.
args['starting_year'] (int): what year to start runs. this value is
used to notate outputs in the form [month_int]_[year]
args['n_months'] (int): number of months to run model, the model run
will start reporting in `args['starting_month']`.
args['aoi_path'] (string): path to polygon vector indicating the
desired spatial extent of the model. This has the effect of
clipping the computational area of the input datasets to be the
area intersected by this polygon.
args['management_threshold'] (float): biomass in kg/ha required to be
left standing at each model step after offtake by grazing animals
args['proportion_legume_path'] (string): path to raster containing
fraction of pasture that is legume, by weight
args['bulk_density_path'] (string): path to bulk density raster.
args['ph_path'] (string): path to soil pH raster.
args['clay_proportion_path'] (string): path to raster representing
per-pixel proportion of soil component that is clay
args['silt_proportion_path'] (string): path to raster representing
per-pixel proportion of soil component that is silt
args['sand_proportion_path'] (string): path to raster representing
per-pixel proportion of soil component that is sand
args['precip_dir'] (string): path to a directory containing monthly
precipitation rasters. The model requires at least 12 months of
precipitation and expects to find a precipitation file input for
every month of the simulation, so the number of precipitation
files should be the maximum of 12 and `n_months`. The file name of
each precipitation raster must end with the year, followed by an
underscore, followed by the month number. E.g., Precip_2016_1.tif
for January of 2016.
args['min_temp_dir'] (string): path to a directory containing monthly
minimum temperature rasters. The model requires one minimum
temperature raster for each month of the year, or each month that
the model is run, whichever is smaller. The file name of each
minimum temperature raster must end with the month number. E.g.,
Min_temperature_1.tif for January.
args['max_temp_dir'] (string): path to a directory containing monthly
maximum temperature rasters. The model requires one maximum
temperature raster for each month of the year, or each month that
the model is run, whichever is smaller. The file name of each
maximum temperature raster must end with the month number. E.g.,
Max_temperature_1.tif for January.
args['site_param_table'] (string): path to csv file giving site
parameters. This file must contain a column named "site" that
contains unique integers. These integer values correspond to site
type identifiers which are values in the site parameter spatial
index raster. Other required fields for this table are site and
"fixed" parameters from the Century model, i.e., the parameters
in the Century input files site.100 and fix.100.
args['site_param_spatial_index_path'] (string): path to a raster file
that indexes site parameters, indicating which set of site
parameter values should apply at each pixel in the raster. The
raster should be composed of integers that correspond to values in
the field "site" in `site_param_table`.
args['veg_trait_path'] (string): path to csv file giving vegetation
traits for each plant functional type available for grazing. This
file must contain a column named "PFT" that contains unique
integers. These integer values correspond to PFT identifiers of
veg spatial composition rasters. Other required fields for this
table are vegetation input parameters from the Century model, for
example maximum intrinsic growth rate, optimum temperature for
production, minimum C/N ratio, etc.
args['veg_spatial_composition_path_pattern'] (string): path to
vegetation rasters, one per plant functional type available for
grazing, where <PFT> can be replaced with an integer that is
indexed in the veg trait csv.
Example: if this value is given as `./vegetation/pft_<PFT>.tif`
and the directory `./vegetation/` contains these files:
"pft_1.tif"
"pft_12.tif"
"pft_50.tif",
then the "PFT" field in the vegetation trait table must contain
the values 1, 12, and 50.
args['animal_trait_path'] (string): path to csv file giving animal
traits for each animal type - number - duration combination. This
table must contain a column named "animal_id" that contains unique
integers. These integer values correspond to features in the
animal management layer.
Other required fields in this table are:
type (allowable values: b_indicus, b_taurus,
indicus_x_taurus, sheep, camelid, hindgut_fermenter)
sex (allowable values: entire_m, castrate, breeding_female,
NA)
age (days)
weight (kg)
SRW (standard reference weight, kg; the weight of a mature
female in median condition)
SFW (standard fleece weight, kg; the average weight of fleece
of a mature adult; for sheep only)
birth_weight (kg)
grz_months (a string of integers, separated by ','; months of
the simulation when animals are present,
relative to `starting_month`. For example, if `n_months`
is 3, and animals are present during the entire simulation
period, `grz_months` should be "1,2,3")
args['animal_grazing_areas_path'] (string): path to animal vector
inputs giving the location of grazing animals. Must have a field
named "animal_id", containing unique integers that correspond to
the values in the "animal_id" column of the animal trait csv, and
a field named "num_animal" giving the number of animals grazing
inside each polygon feature.
args['initial_conditions_dir'] (string): optional input, path to
directory containing initial conditions. If this directory is not
supplied, a site_initial_table and pft_initial_table must be
supplied. If supplied, this directory must contain a series of
rasters with initial values for each PFT and for the site.
Required rasters for each PFT:
initial variables that are a property of PFT in the table
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
e.g., aglivc_<PFT>.tif
Required for the site:
initial variables that are a property of site in the table
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
args['site_initial_table'] (string): optional input, path to table
containing initial conditions for each site state variable. If an
initial conditions directory is not supplied, this table must be
supplied. This table must contain a value for each site code and
each state variable listed in the following table:
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
args['pft_initial_table'] (string): optional input, path to table
containing initial conditions for each plant functional type state
variable. If an initial conditions directory is not supplied, this
table must be supplied. This table must contain a value for each
plant functional type index and each state variable listed in the
following table:
https://docs.google.com/spreadsheets/d/1TGCDOJS4nNsJpzTWdiWed390NmbhQFB2uUoMs9oTTYo/edit?usp=sharing
args['save_sv_rasters'] (boolean): optional input, default false.
Should rasters containing all state variables be saved for each
model time step?
args['animal_density'] (string): optional input, density of grazing
animals in animals per hectare.
args['crude_protein'] (float): optional input, crude protein
concentration of forage for the purposes of animal diet selection.
Should be a value between 0-1. If included, this value is
substituted for N content of forage when calculating digestibility
and "ingestibility" of forage, and protein content of the diet, for
grazing animals.
Returns:
None.
"""
LOGGER.info("model execute: %s", args)
starting_month = int(args['starting_month'])
starting_year = int(args['starting_year'])
n_months = int(args['n_months'])
try:
delete_sv_folders = not args['save_sv_rasters']
except KeyError:
delete_sv_folders = True
try:
global CRUDE_PROTEIN
CRUDE_PROTEIN = args['crude_protein']
except KeyError:
pass
try:
animal_density_path = args['animal_density']
except KeyError:
args['animal_density'] = None
# this set will build up the integer months that are used so we can index
# them with temperature later
temperature_month_set = set()
# this dict will be used to build the set of input rasters associated with
# a reasonable lookup ID so we can have a nice dataset to align for raster
# stack operations
base_align_raster_path_id_map = {}
precip_dir_list = [
os.path.join(args['precip_dir'], f) for f in
os.listdir(args['precip_dir'])]
for month_index in range(n_months):
month_i = (starting_month + month_index - 1) % 12 + 1
temperature_month_set.add(month_i)
year = starting_year + (starting_month + month_index - 1) // 12
year_month_match = re.compile(
r'.*[^\d]%d_%d\.[^.]+$' % (year, month_i))
file_list = [
month_file_path for month_file_path in precip_dir_list if
year_month_match.match(month_file_path)]
if len(file_list) == 0:
raise ValueError(
"No precipitation data found for year %d, month %d" %
(year, month_i))
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for year %d, month %d: %s" %
(year, month_i, file_list))
base_align_raster_path_id_map[
'precip_{}'.format(month_index)] = file_list[0]
# the model requires 12 months of precipitation data to calculate
# atmospheric N deposition and potential production from annual precip
n_precip_months = int(args['n_months'])
if n_precip_months < 12:
m_index = int(args['n_months'])
while n_precip_months < 12:
month_i = (starting_month + m_index - 1) % 12 + 1
year = starting_year + (starting_month + m_index - 1) // 12
year_month_match = re.compile(
r'.*[^\d]%d_%d\.[^.]+$' % (year, month_i))
file_list = [
month_file_path for month_file_path in precip_dir_list if
year_month_match.match(month_file_path)]
if len(file_list) == 0:
break
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for year %d, month %d: %s" %
(year, month_i, file_list))
base_align_raster_path_id_map[
'precip_%d' % m_index] = file_list[0]
n_precip_months = n_precip_months + 1
m_index = m_index + 1
if n_precip_months < 12:
raise ValueError("At least 12 months of precipitation data required")
# collect monthly temperature data
min_temp_dir_list = [
os.path.join(args['min_temp_dir'], f) for f in
os.listdir(args['min_temp_dir'])]
for month_i in temperature_month_set:
month_file_match = re.compile(r'.*[^\d]%d\.[^.]+$' % month_i)
file_list = [
month_file_path for month_file_path in min_temp_dir_list if
month_file_match.match(month_file_path)]
if len(file_list) == 0:
raise ValueError(
"No minimum temperature data found for month %d" % month_i)
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for month %d: %s" %
(month_i, file_list))
base_align_raster_path_id_map[
'min_temp_%d' % month_i] = file_list[0]
max_temp_dir_list = [
os.path.join(args['max_temp_dir'], f) for f in
os.listdir(args['max_temp_dir'])]
for month_i in temperature_month_set:
month_file_match = re.compile(r'.*[^\d]%d\.[^.]+$' % month_i)
file_list = [
month_file_path for month_file_path in max_temp_dir_list if
month_file_match.match(month_file_path)]
if len(file_list) == 0:
raise ValueError(
"No maximum temperature data found for month %d" % month_i)
if len(file_list) > 1:
raise ValueError(
"Ambiguous set of files found for month %d: %s" %
(month_i, file_list))
base_align_raster_path_id_map[
'max_temp_%d' % month_i] = file_list[0]
# lookup to provide path to soil percent given soil type
for soil_type in SOIL_TYPE_LIST:
base_align_raster_path_id_map[soil_type] = (
args['%s_proportion_path' % soil_type])
if not os.path.exists(base_align_raster_path_id_map[soil_type]):
raise ValueError(
"Couldn't find %s for %s" % (
base_align_raster_path_id_map[soil_type], soil_type))
base_align_raster_path_id_map['bulk_d_path'] = args['bulk_density_path']
base_align_raster_path_id_map['ph_path'] = args['ph_path']
# make sure site initial conditions and parameters exist for each site
# identifier
base_align_raster_path_id_map['site_index'] = (
args['site_param_spatial_index_path'])
n_bands = pygeoprocessing.get_raster_info(
args['site_param_spatial_index_path'])['n_bands']
if n_bands > 1:
raise ValueError(
'Site spatial index raster must contain only one band')
site_datatype = pygeoprocessing.get_raster_info(
args['site_param_spatial_index_path'])['datatype']
if site_datatype not in [1, 2, 3, 4, 5]:
raise ValueError('Site spatial index raster must be integer type')
# get unique values in site param raster
site_index_set = set()
for offset_map, raster_block in pygeoprocessing.iterblocks(
(args['site_param_spatial_index_path'], 1)):
site_index_set.update(numpy.unique(raster_block))
site_nodata = pygeoprocessing.get_raster_info(
args['site_param_spatial_index_path'])['nodata'][0]
if site_nodata in site_index_set:
site_index_set.remove(site_nodata)
site_param_table = utils.build_lookup_from_csv(
args['site_param_table'], 'site')
missing_site_index_list = list(
site_index_set.difference(site_param_table.keys()))
if missing_site_index_list:
raise ValueError(
"Couldn't find parameter values for the following site " +
"indices: %s\n\t" + ", ".join(missing_site_index_list))
# make sure plant functional type parameters exist for each pft raster
pft_dir = os.path.dirname(args['veg_spatial_composition_path_pattern'])
pft_basename = os.path.basename(
args['veg_spatial_composition_path_pattern'])
files = [
f for f in os.listdir(pft_dir) if os.path.isfile(
os.path.join(pft_dir, f))]
pft_regex = re.compile(pft_basename.replace('<PFT>', r'(\d+)'))
pft_matches = [
m for m in [pft_regex.search(f) for f in files] if m is not None]
pft_id_set = set([int(m.group(1)) for m in pft_matches])
for pft_i in pft_id_set:
pft_path = args['veg_spatial_composition_path_pattern'].replace(
'<PFT>', '%d' % pft_i)
base_align_raster_path_id_map['pft_%d' % pft_i] = pft_path
veg_trait_table = utils.build_lookup_from_csv(
args['veg_trait_path'], 'PFT')
missing_pft_trait_list = pft_id_set.difference(veg_trait_table.keys())
if missing_pft_trait_list:
raise ValueError(
"Couldn't find trait values for the following plant functional " +
"types: %s\n\t" + ", ".join(missing_pft_trait_list))
frtcindx_set = set([
pft_i['frtcindx'] for pft_i in veg_trait_table.values()])
if frtcindx_set.difference(set([0, 1])):
raise ValueError("frtcindx parameter contains invalid values")
base_align_raster_path_id_map['proportion_legume_path'] = args[
'proportion_legume_path']
# track separate state variable files for each PFT
pft_sv_dict = {}
for pft_i in pft_id_set:
for sv in _PFT_STATE_VARIABLES:
pft_sv_dict['{}_{}_path'.format(
sv, pft_i)] = '{}_{}.tif'.format(sv, pft_i)
# make sure animal traits exist for each feature in animal management
# layer
anim_id_list = []
driver = ogr.GetDriverByName('ESRI Shapefile')
datasource = driver.Open(args['animal_grazing_areas_path'], 0)
layer = datasource.GetLayer()
for feature in layer:
anim_id_list.append(feature.GetField('animal_id'))
input_animal_trait_table = utils.build_lookup_from_csv(
args['animal_trait_path'], 'animal_id')
missing_animal_trait_list = set(
anim_id_list).difference(input_animal_trait_table.keys())
if missing_animal_trait_list:
raise ValueError(
"Couldn't find trait values for the following animal " +
"ids: %s\n\t" + ", ".join(missing_animal_trait_list))
# if animal density is supplied, align inputs to match its resolution
# otherwise, match resolution of precipitation rasters
if args['animal_density']:
target_pixel_size = pygeoprocessing.get_raster_info(
args['animal_density'])['pixel_size']
base_align_raster_path_id_map['animal_density'] = args[
'animal_density']
else:
target_pixel_size = pygeoprocessing.get_raster_info(
base_align_raster_path_id_map['precip_0'])['pixel_size']
LOGGER.info(
"pixel size of aligned inputs: %s", target_pixel_size)
# temporary directory for intermediate files
global PROCESSING_DIR
PROCESSING_DIR = os.path.join(args['workspace_dir'], "temporary_files")
if not os.path.exists(PROCESSING_DIR):
os.makedirs(PROCESSING_DIR)
# set up a dictionary that uses the same keys as
# 'base_align_raster_path_id_map' to point to the clipped/resampled
# rasters to be used in raster calculations for the model.
aligned_raster_dir = os.path.join(
args['workspace_dir'], 'aligned_inputs')
if os.path.exists(aligned_raster_dir):
shutil.rmtree(aligned_raster_dir)
os.makedirs(aligned_raster_dir)
aligned_inputs = dict([(key, os.path.join(
aligned_raster_dir, 'aligned_%s' % os.path.basename(path)))
for key, path in base_align_raster_path_id_map.items()])
# align all the base inputs to be the minimum known pixel size and to
# only extend over their combined intersections
source_input_path_list = [
base_align_raster_path_id_map[k] for k in sorted(
base_align_raster_path_id_map.keys())]
aligned_input_path_list = [
aligned_inputs[k] for k in sorted(aligned_inputs.keys())]
pygeoprocessing.align_and_resize_raster_stack(
source_input_path_list, aligned_input_path_list,
['near'] * len(source_input_path_list),
target_pixel_size, 'intersection',
base_vector_path_list=[args['aoi_path']],
vector_mask_options={'mask_vector_path': args['aoi_path']})
_check_pft_fractional_cover_sum(aligned_inputs, pft_id_set)
file_suffix = utils.make_suffix_string(args, 'results_suffix')
# create animal trait spatial index raster from management polygon
aligned_inputs['animal_index'] = os.path.join(
aligned_raster_dir, 'animal_spatial_index.tif')
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], aligned_inputs['animal_index'],
gdal.GDT_Int32, [_TARGET_NODATA], fill_value_list=[_TARGET_NODATA])
pygeoprocessing.rasterize(
args['animal_grazing_areas_path'], aligned_inputs['animal_index'],
option_list=["ATTRIBUTE=animal_id"])
# create uniform animal density raster, if not supplied as input
if not args['animal_density']:
aligned_inputs['animal_density'] = os.path.join(
aligned_raster_dir, 'animal_density.tif')
_animal_density(aligned_inputs, args['animal_grazing_areas_path'])
# Initialization
sv_dir = os.path.join(args['workspace_dir'], 'state_variables_m-1')
os.makedirs(sv_dir)
initial_conditions_dir = None
try:
initial_conditions_dir = args['initial_conditions_dir']
except KeyError:
pass
if initial_conditions_dir:
# check that a raster for each required state variable is supplied
missing_initial_values = []
# set _SV_NODATA from initial rasters
state_var_nodata = set([])
# align initial state variables to resampled inputs
resample_initial_path_map = {}
for sv in _SITE_STATE_VARIABLE_FILES:
sv_path = os.path.join(
initial_conditions_dir, _SITE_STATE_VARIABLE_FILES[sv])
state_var_nodata.update(
set([pygeoprocessing.get_raster_info(sv_path)['nodata'][0]]))
resample_initial_path_map[sv] = sv_path
if not os.path.exists(sv_path):
missing_initial_values.append(sv_path)
for pft_i in pft_id_set:
for sv in _PFT_STATE_VARIABLES:
sv_key = '{}_{}_path'.format(sv, pft_i)
sv_path = os.path.join(
initial_conditions_dir, '{}_{}.tif'.format(sv, pft_i))
state_var_nodata.update(
set([pygeoprocessing.get_raster_info(sv_path)['nodata']
[0]]))
resample_initial_path_map[sv_key] = sv_path
if not os.path.exists(sv_path):
missing_initial_values.append(sv_path)
if missing_initial_values:
raise ValueError(
"Couldn't find the following required initial values: " +
"\n\t".join(missing_initial_values))
if len(state_var_nodata) > 1:
raise ValueError(
"Initial state variable rasters contain >1 nodata value")
global _SV_NODATA
_SV_NODATA = list(state_var_nodata)[0]
# align initial values with inputs
initial_path_list = (
[aligned_inputs['precip_0']] +
[resample_initial_path_map[key] for key in sorted(
resample_initial_path_map.keys())])
aligned_initial_path_list = (
[os.path.join(PROCESSING_DIR, 'aligned_input_template.tif')] +
[os.path.join(
sv_dir, os.path.basename(resample_initial_path_map[key])) for
key in sorted(resample_initial_path_map.keys())])
pygeoprocessing.align_and_resize_raster_stack(
initial_path_list, aligned_initial_path_list,
['near'] * len(initial_path_list),
target_pixel_size, 'intersection',
base_vector_path_list=[args['aoi_path']], raster_align_index=0,
vector_mask_options={'mask_vector_path': args['aoi_path']})
sv_reg = dict(
[(key, os.path.join(sv_dir, os.path.basename(path)))
for key, path in resample_initial_path_map.items()])
else:
# create initialization rasters from tables
try:
site_initial_conditions_table = utils.build_lookup_from_csv(
args['site_initial_table'], 'site')
except KeyError:
raise ValueError(
"If initial conditions rasters are not supplied, initial " +
"conditions tables must be supplied")
missing_site_index_list = list(
site_index_set.difference(site_initial_conditions_table.keys()))
if missing_site_index_list:
raise ValueError(
"Couldn't find initial conditions values for the following " +
"site indices: %s\n\t" + ", ".join(missing_site_index_list))
try:
pft_initial_conditions_table = utils.build_lookup_from_csv(
args['pft_initial_table'], 'PFT')
except KeyError:
raise ValueError(
"If initial conditions rasters are not supplied, initial " +
"conditions tables must be supplied")
missing_pft_index_list = pft_id_set.difference(
pft_initial_conditions_table.keys())
if missing_pft_index_list:
raise ValueError(
"Couldn't find initial condition values for the following "
"plant functional types: %s\n\t" + ", ".join(
missing_pft_index_list))
sv_reg = initial_conditions_from_tables(
aligned_inputs, sv_dir, pft_id_set, site_initial_conditions_table,
pft_initial_conditions_table)
# calculate persistent intermediate parameters that do not change during
# the simulation
persist_param_dir = os.path.join(
args['workspace_dir'], 'intermediate_parameters')
utils.make_directories([persist_param_dir])
pp_reg = utils.build_file_registry(
[(_PERSISTENT_PARAMS_FILES, persist_param_dir)], file_suffix)
# calculate derived animal traits that do not change during the simulation
freer_parameter_df = pandas.DataFrame.from_dict(
_FREER_PARAM_DICT, orient='index')
freer_parameter_df['type'] = freer_parameter_df.index
animal_trait_table = calc_derived_animal_traits(
input_animal_trait_table, freer_parameter_df)
# calculate maximum potential intake of each animal type
for animal_id in animal_trait_table.keys():
revised_animal_trait_dict = calc_max_intake(
animal_trait_table[animal_id])
animal_trait_table[animal_id] = revised_animal_trait_dict
# calculate field capacity and wilting point
LOGGER.info("Calculating field capacity and wilting point")
_afiel_awilt(
aligned_inputs['site_index'], site_param_table,
sv_reg['som1c_2_path'], sv_reg['som2c_2_path'], sv_reg['som3c_path'],
aligned_inputs['sand'], aligned_inputs['silt'],
aligned_inputs['clay'], aligned_inputs['bulk_d_path'], pp_reg)
# calculate other persistent parameters
LOGGER.info("Calculating persistent parameters")
_persistent_params(
aligned_inputs['site_index'], site_param_table,
aligned_inputs['sand'], aligned_inputs['clay'], pp_reg)
# calculate required ratios for decomposition of structural material
LOGGER.info("Calculating required ratios for structural decomposition")
_structural_ratios(
aligned_inputs['site_index'], site_param_table, sv_reg, pp_reg)
# make yearly directory for values that are updated every twelve months
year_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
year_reg = dict(
[(key, os.path.join(year_dir, path)) for key, path in
_YEARLY_FILES.items()])
for pft_i in pft_id_set:
for file in _YEARLY_PFT_FILES:
year_reg['{}_{}'.format(file, pft_i)] = os.path.join(
year_dir, '{}_{}.tif'.format(file, pft_i))
# make monthly directory for monthly intermediate parameters that are
# shared between submodels, but do not need to be saved as output
month_temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
month_reg = {}
for pft_i in pft_id_set:
for val in _PFT_INTERMEDIATE_VALUES:
month_reg['{}_{}'.format(
val, pft_i)] = os.path.join(
month_temp_dir, '{}_{}.tif'.format(val, pft_i))
for val in _SITE_INTERMEDIATE_VALUES:
month_reg[val] = os.path.join(month_temp_dir, '{}.tif'.format(val))
output_dir = os.path.join(args['workspace_dir'], "output")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# provisional state variable registry contains provisional biomass in
# absence of grazing
provisional_sv_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
provisional_sv_reg = utils.build_file_registry(
[(_SITE_STATE_VARIABLE_FILES, provisional_sv_dir),
(pft_sv_dict, provisional_sv_dir)], file_suffix)
intermediate_sv_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
# Main simulation loop
# for each step in the simulation
for month_index in range(n_months):
if (month_index % 12) == 0:
# Update yearly quantities
_yearly_tasks(
aligned_inputs, site_param_table, veg_trait_table, month_index,
pft_id_set, year_reg)
current_month = (starting_month + month_index - 1) % 12 + 1
current_year = starting_year + (starting_month + month_index - 1) // 12
# track state variables from previous step
prev_sv_reg = sv_reg
for animal_id in animal_trait_table.keys():
if animal_trait_table[animal_id]['sex'] == 'breeding_female':
revised_animal_trait_dict = update_breeding_female_status(
animal_trait_table[animal_id], month_index)
animal_trait_table[animal_id] = revised_animal_trait_dict
revised_animal_trait_dict = calc_max_intake(
animal_trait_table[animal_id])
animal_trait_table[animal_id] = revised_animal_trait_dict
# enforce absence of grazing as zero biomass removed
for pft_i in pft_id_set:
pygeoprocessing.new_raster_from_base(
aligned_inputs['pft_{}'.format(pft_i)],
month_reg['flgrem_{}'.format(pft_i)], gdal.GDT_Float32,
[_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['pft_{}'.format(pft_i)],
month_reg['fdgrem_{}'.format(pft_i)], gdal.GDT_Float32,
[_TARGET_NODATA], fill_value_list=[0])
# populate provisional_sv_reg with provisional biomass in absence of
# grazing
_potential_production(
aligned_inputs, site_param_table, current_month, month_index,
pft_id_set, veg_trait_table, prev_sv_reg, pp_reg, month_reg)
_root_shoot_ratio(
aligned_inputs, site_param_table, current_month, pft_id_set,
veg_trait_table, prev_sv_reg, year_reg, month_reg)
_soil_water(
aligned_inputs, site_param_table, veg_trait_table, current_month,
month_index, prev_sv_reg, pp_reg, pft_id_set, month_reg,
provisional_sv_reg)
_decomposition(
aligned_inputs, current_month, month_index, pft_id_set,
site_param_table, year_reg, month_reg, prev_sv_reg, pp_reg,
provisional_sv_reg)
_death_and_partition(
'stded', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg,
provisional_sv_reg)
_death_and_partition(
'bgliv', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg,
provisional_sv_reg)
_shoot_senescence(
pft_id_set, veg_trait_table, prev_sv_reg, month_reg, current_month,
provisional_sv_reg)
intermediate_sv_reg = copy_intermediate_sv(
pft_id_set, provisional_sv_reg, intermediate_sv_dir)
delta_agliv_dict = _new_growth(
pft_id_set, aligned_inputs, site_param_table, veg_trait_table,
month_reg, current_month, provisional_sv_reg)
_apply_new_growth(delta_agliv_dict, pft_id_set, provisional_sv_reg)
# estimate grazing offtake by animals relative to provisional biomass
# at an intermediate step, after senescence but before new growth
_calc_grazing_offtake(
aligned_inputs, args['aoi_path'], args['management_threshold'],
intermediate_sv_reg, pft_id_set, aligned_inputs['animal_index'],
animal_trait_table, veg_trait_table, current_month, month_reg)
# estimate actual biomass production for this step, integrating impacts
# of grazing
sv_dir = os.path.join(
args['workspace_dir'], 'state_variables_m%d' % month_index)
utils.make_directories([sv_dir])
sv_reg = utils.build_file_registry(
[(_SITE_STATE_VARIABLE_FILES, sv_dir),
(pft_sv_dict, sv_dir)], file_suffix)
_potential_production(
aligned_inputs, site_param_table, current_month, month_index,
pft_id_set, veg_trait_table, prev_sv_reg, pp_reg, month_reg)
_root_shoot_ratio(
aligned_inputs, site_param_table, current_month, pft_id_set,
veg_trait_table, prev_sv_reg, year_reg, month_reg)
_soil_water(
aligned_inputs, site_param_table, veg_trait_table, current_month,
month_index, prev_sv_reg, pp_reg, pft_id_set, month_reg, sv_reg)
_decomposition(
aligned_inputs, current_month, month_index, pft_id_set,
site_param_table, year_reg, month_reg, prev_sv_reg, pp_reg, sv_reg)
_death_and_partition(
'stded', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg, sv_reg)
_death_and_partition(
'bgliv', aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg, sv_reg)
_shoot_senescence(
pft_id_set, veg_trait_table, prev_sv_reg, month_reg, current_month,
sv_reg)
delta_agliv_dict = _new_growth(
pft_id_set, aligned_inputs, site_param_table, veg_trait_table,
month_reg, current_month, sv_reg)
_animal_diet_sufficiency(
sv_reg, pft_id_set, aligned_inputs, animal_trait_table,
veg_trait_table, current_month, month_reg)
_grazing(
aligned_inputs, site_param_table, month_reg, animal_trait_table,
pft_id_set, sv_reg)
_apply_new_growth(delta_agliv_dict, pft_id_set, sv_reg)
_leach(aligned_inputs, site_param_table, month_reg, sv_reg)
_write_monthly_outputs(
aligned_inputs, provisional_sv_reg, sv_reg, month_reg, pft_id_set,
current_year, current_month, output_dir, file_suffix)
# summary results
summary_output_dir = os.path.join(output_dir, 'summary_results')
os.makedirs(summary_output_dir)
summary_shp_path = os.path.join(
summary_output_dir,
'grazing_areas_results_rpm{}.shp'.format(file_suffix))
create_vector_copy(
args['animal_grazing_areas_path'], summary_shp_path)
field_pickle_map, field_header_order_list = aggregate_and_pickle_results(
output_dir, summary_shp_path)
_add_fields_to_shapefile(
field_pickle_map, field_header_order_list, summary_shp_path)
# clean up
shutil.rmtree(persist_param_dir)
shutil.rmtree(PROCESSING_DIR)
if delete_sv_folders:
for month_index in range(-1, n_months):
shutil.rmtree(
os.path.join(
args['workspace_dir'],
'state_variables_m%d' % month_index))
def raster_multiplication(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_path_nodata):
"""Multiply raster1 by raster2.
Multiply raster1 by raster2 element-wise. In any pixel where raster1 or
raster2 is nodata, the result is nodata. The result is always of float
datatype.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_multiply_op(raster1, raster2):
"""Multiply two rasters."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_path_nodata
result[valid_mask] = raster1[valid_mask] * raster2[valid_mask]
return result
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_multiply_op, target_path, gdal.GDT_Float32,
target_path_nodata)
def raster_division(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_path_nodata):
"""Divide raster1 by raster2.
Divide raster1 by raster2 element-wise. In any pixel where raster1 or
raster2 is nodata, the result is nodata. The result is always of float
datatype.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_divide_op(raster1, raster2):
"""Divide raster1 by raster2."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
raster1 = raster1.astype(numpy.float32)
raster2 = raster2.astype(numpy.float32)
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_path_nodata
error_mask = ((raster1 != 0) & (raster2 == 0.) & valid_mask)
zero_mask = ((raster1 == 0.) & (raster2 == 0.) & valid_mask)
nonzero_mask = ((raster2 != 0.) & valid_mask)
result[error_mask] = target_path_nodata
result[zero_mask] = 0.
result[nonzero_mask] = raster1[nonzero_mask] / raster2[nonzero_mask]
return result
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_divide_op, target_path, gdal.GDT_Float32,
target_path_nodata)
def raster_list_sum(
raster_list, input_nodata, target_path, target_nodata,
nodata_remove=False):
"""Calculate the sum per pixel across rasters in a list.
Sum the rasters in `raster_list` element-wise, allowing nodata values
in the rasters to propagate to the result or treating nodata as zero. If
nodata is treated as zero, areas where all inputs are nodata will be nodata
in the output.
Parameters:
raster_list (list): list of paths to rasters to sum
input_nodata (float or int): nodata value in the input rasters
target_path (string): path to location to store the result
target_nodata (float or int): nodata value for the result raster
nodata_remove (bool): if true, treat nodata values in input
rasters as zero. If false, the sum in a pixel where any input
raster is nodata is nodata.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_sum_op(*raster_list):
"""Add the rasters in raster_list without removing nodata values."""
invalid_mask = numpy.any(
numpy.isclose(numpy.array(raster_list), input_nodata), axis=0)
for r in raster_list:
numpy.place(r, numpy.isclose(r, input_nodata), [0])
sum_of_rasters = numpy.sum(raster_list, axis=0)
sum_of_rasters[invalid_mask] = target_nodata
return sum_of_rasters
def raster_sum_op_nodata_remove(*raster_list):
"""Add the rasters in raster_list, treating nodata as zero."""
invalid_mask = numpy.all(
numpy.isclose(numpy.array(raster_list), input_nodata), axis=0)
for r in raster_list:
numpy.place(r, numpy.isclose(r, input_nodata), [0])
sum_of_rasters = numpy.sum(raster_list, axis=0)
sum_of_rasters[invalid_mask] = target_nodata
return sum_of_rasters
if nodata_remove:
pygeoprocessing.raster_calculator(
[(path, 1) for path in raster_list], raster_sum_op_nodata_remove,
target_path, gdal.GDT_Float32, target_nodata)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in raster_list], raster_sum_op,
target_path, gdal.GDT_Float32, target_nodata)
def raster_sum(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_nodata, nodata_remove=False):
"""Add raster 1 and raster2.
Add raster1 and raster2, allowing nodata values in the rasters to
propagate to the result or treating nodata as zero.
Parameters:
raster1 (string): path to one raster operand
raster1_nodata (float or int): nodata value in raster1
raster2 (string): path to second raster operand
raster2_nodata (float or int): nodata value in raster2
target_path (string): path to location to store the sum
target_nodata (float or int): nodata value for the result raster
nodata_remove (bool): if true, treat nodata values in input
rasters as zero. If false, the sum in a pixel where any
input raster is nodata is nodata.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_sum_op(raster1, raster2):
"""Add raster1 and raster2 without removing nodata values."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_nodata
result[valid_mask] = raster1[valid_mask] + raster2[valid_mask]
return result
def raster_sum_op_nodata_remove(raster1, raster2):
"""Add raster1 and raster2, treating nodata as zero."""
numpy.place(raster1, numpy.isclose(raster1, raster1_nodata), [0])
numpy.place(raster2, numpy.isclose(raster2, raster2_nodata), [0])
result = raster1 + raster2
return result
if nodata_remove:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_sum_op_nodata_remove, target_path, gdal.GDT_Float32,
target_nodata)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_sum_op, target_path, gdal.GDT_Float32,
target_nodata)
def raster_difference(
raster1, raster1_nodata, raster2, raster2_nodata, target_path,
target_nodata, nodata_remove=False):
"""Subtract raster2 from raster1.
Subtract raster2 from raster1 element-wise, allowing nodata values in the
rasters to propagate to the result or treating nodata as zero.
Parameters:
raster1 (string): path to raster from which to subtract raster2
raster1_nodata (float or int): nodata value in raster1
raster2 (string): path to raster which should be subtracted from
raster1
raster2_nodata (float or int): nodata value in raster2
target_path (string): path to location to store the difference
target_nodata (float or int): nodata value for the result raster
nodata_remove (bool): if true, treat nodata values in input
rasters as zero. If false, the difference in a pixel where any
input raster is nodata is nodata.
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
def raster_difference_op(raster1, raster2):
"""Subtract raster2 from raster1 without removing nodata values."""
valid_mask = (
(~numpy.isclose(raster1, raster1_nodata)) &
(~numpy.isclose(raster2, raster2_nodata)))
result = numpy.empty(raster1.shape, dtype=numpy.float32)
result[:] = target_nodata
result[valid_mask] = raster1[valid_mask] - raster2[valid_mask]
return result
def raster_difference_op_nodata_remove(raster1, raster2):
"""Subtract raster2 from raster1, treating nodata as zero."""
numpy.place(raster1, numpy.isclose(raster1, raster1_nodata), [0])
numpy.place(raster2, numpy.isclose(raster2, raster2_nodata), [0])
result = raster1 - raster2
return result
if nodata_remove:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_difference_op_nodata_remove, target_path, gdal.GDT_Float32,
target_nodata)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [raster1, raster2]],
raster_difference_op, target_path, gdal.GDT_Float32,
target_nodata)
def reclassify_nodata(target_path, new_nodata_value):
"""Reclassify the nodata value of a raster to a new value.
Convert all areas of nodata in the target raster to the new nodata
value, which must be an integer.
Parameters:
target_path (string): path to target raster
new_nodata_value (integer): new value to set as nodata
Side effects:
modifies the raster indicated by `target_path`
Returns:
None
"""
def reclassify_op(target_raster):
reclassified_raster = numpy.copy(target_raster)
reclassify_mask = (target_raster == previous_nodata_value)
reclassified_raster[reclassify_mask] = new_nodata_value
return reclassified_raster
fd, temp_path = tempfile.mkstemp(dir=PROCESSING_DIR)
shutil.copyfile(target_path, temp_path)
previous_nodata_value = pygeoprocessing.get_raster_info(
target_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(temp_path, 1)], reclassify_op, target_path, gdal.GDT_Float32,
new_nodata_value)
# clean up
os.close(fd)
os.remove(temp_path)
def weighted_state_variable_sum(
sv, sv_reg, aligned_inputs, pft_id_set, weighted_sum_path):
"""Calculate weighted sum of state variable across plant functional types.
To sum a state variable across PFTs within a grid cell, the state variable
must be weighted by the fractional cover of each PFT inside the grid cell.
First multiply the state variable by its fractional cover, and then add up
the weighted products.
Parameters:
sv (string): state variable to be summed across plant functional types
sv_reg (dict): map of key, path pairs giving paths to state variables,
including sv, the state variable to be summed
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fractional cover of each plant
functional type
pft_id_set (set): set of integers identifying plant functional types
weighted_sum_path (string): path to raster that should contain the
weighted sum across PFTs
Side effects:
modifies or creates the raster indicated by `weighted_sum_path`
Returns:
None
"""
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for pft_i in pft_id_set:
val = '{}_weighted'.format(sv)
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
weighted_path_list = []
for pft_i in pft_id_set:
target_path = temp_val_dict['{}_weighted_{}'.format(sv, pft_i)]
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
raster_multiplication(
sv_reg['{}_{}_path'.format(sv, pft_i)], _SV_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
target_path, _TARGET_NODATA)
weighted_path_list.append(target_path)
raster_list_sum(
weighted_path_list, _TARGET_NODATA, weighted_sum_path, _TARGET_NODATA,
nodata_remove=True)
# clean up temporary files
shutil.rmtree(temp_dir)
def _check_pft_fractional_cover_sum(aligned_inputs, pft_id_set):
"""Check the sum of fractional cover across plant functional types.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including fractional cover of each plant
functional type
pft_id_set (set): set of integers identifying plant functional types
Raises:
ValueError if the pixel-wise sum of fractional cover values across
plant functional types exceeds 1
Returns:
None
"""
with tempfile.NamedTemporaryFile(
prefix='cover_sum', dir=PROCESSING_DIR) as cover_sum_temp_file:
cover_sum_path = cover_sum_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
# initialize sum to zero
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], cover_sum_path, gdal.GDT_Float32,
[_TARGET_NODATA], fill_value_list=[0])
for pft_i in pft_id_set:
shutil.copyfile(cover_sum_path, operand_temp_path)
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
raster_sum(
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
operand_temp_path, _TARGET_NODATA,
cover_sum_path, _TARGET_NODATA)
# get maximum sum of fractional cover
max_cover = 0.
for offset_map, raster_block in pygeoprocessing.iterblocks(
(cover_sum_path, 1)):
valid_mask = (raster_block != _TARGET_NODATA)
if raster_block[valid_mask].size > 0:
max_cover = max(max_cover, numpy.amax(raster_block[valid_mask]))
if max_cover > 1:
raise ValueError(
"Fractional cover across plant functional types exceeds 1")
# clean up
os.remove(cover_sum_path)
def initial_conditions_from_tables(
aligned_inputs, sv_dir, pft_id_set, site_initial_conditions_table,
pft_initial_conditions_table):
"""Generate initial state variable registry from initial conditions tables.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including site spatial index raster and
fractional cover of each plant functional type
sv_dir (string): path to directory where initial state variable rasters
should be stored
pft_id_set (set): set of integers identifying plant functional types
site_initial_conditions_table (dict): map of site spatial index to
dictionaries that contain initial values for site-level state
variables
pft_initial_conditions_table (dict): map of plant functional type index
to dictionaries that contain initial values for plant functional
type-level state variables
Returns:
initial_sv_reg, map of key, path pairs giving paths to initial state
variable rasters
"""
def full_masked(pft_cover, fill_val):
"""Create a constant raster masked by pft fractional cover.
Parameters:
pft_cover (numpy.ndarray): input, fractional cover of the plant
functional type
fill_val (float): constant value with which to fill raster in areas
where fractional cover > 0
Returns:
full_masked, a raster containing `fill_val` in areas where
`pft_cover` > 0
"""
valid_mask = (
(~numpy.isclose(pft_cover, _SV_NODATA)) &
(pft_cover > 0))
full_masked = numpy.empty(pft_cover.shape, dtype=numpy.float32)
full_masked[:] = _SV_NODATA
full_masked[valid_mask] = fill_val
return full_masked
initial_sv_reg = {}
# site-level state variables
# check for missing state variable values
required_site_state_var = set(
[sv_key[:-5] for sv_key in _SITE_STATE_VARIABLE_FILES.keys()])
for site_code in site_initial_conditions_table.keys():
missing_site_state_var = required_site_state_var.difference(
site_initial_conditions_table[site_code].keys())
if missing_site_state_var:
raise ValueError(
"The following state variables were not found in the site " +
"initial conditions table: \n\t" + "\n\t".join(
missing_site_state_var))
for sv_key, basename in _SITE_STATE_VARIABLE_FILES.items():
state_var = sv_key[:-5]
site_to_val = dict(
[(site_code, float(table[state_var])) for (
site_code, table) in
site_initial_conditions_table.items()])
target_path = os.path.join(sv_dir, basename)
initial_sv_reg[sv_key] = target_path
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _SV_NODATA)
# PFT-level state variables
for pft_i in pft_id_set:
# check for missing values
missing_pft_state_var = set(_PFT_STATE_VARIABLES).difference(
pft_initial_conditions_table[pft_i].keys())
if missing_pft_state_var:
raise ValueError(
"The following state variables were not found in the plant " +
"functional type initial conditions table: \n\t" + "\n\t".join(
missing_pft_state_var))
for state_var in _PFT_STATE_VARIABLES:
fill_val = pft_initial_conditions_table[pft_i][state_var]
pft_cover_path = aligned_inputs['pft_{}'.format(pft_i)]
target_path = os.path.join(
sv_dir, '{}_{}.tif'.format(state_var, pft_i))
sv_key = '{}_{}_path'.format(state_var, pft_i)
initial_sv_reg[sv_key] = target_path
pygeoprocessing.raster_calculator(
[(pft_cover_path, 1), (fill_val, 'raw')],
full_masked, target_path, gdal.GDT_Float32, _SV_NODATA)
return initial_sv_reg
def _calc_ompc(
som1c_2_path, som2c_2_path, som3c_path, bulkd_path, edepth_path,
ompc_path):
"""Estimate total soil organic matter.
Total soil organic matter is the sum of soil carbon across
slow, active, and passive compartments, weighted by bulk
density and total modeled soil depth. Lines 220-222, Prelim.f
Parameters:
som1c_2_path (string): path to active organic soil carbon raster
som2c_2_path (string): path to slow organic soil carbon raster
som3c_path (string): path to passive organic soil carbon raster
bulkd_path (string): path to bulk density of soil raster
edepth (string): path to depth of soil raster
ompc_path (string): path to result, total soil organic matter
Side effects:
modifies or creates the raster indicated by `ompc_path`
Returns:
None
"""
def ompc_op(som1c_2, som2c_2, som3c, bulkd, edepth):
"""Estimate total soil organic matter.
Total soil organic matter is the sum of soil carbon across
slow, active, and passive compartments, weighted by bulk
density and total modeled soil depth. Lines 220-222, Prelim.f
Parameters:
som1c_2_path (string): state variable, active organic soil carbon
som2c_2_path (string): state variable, slow organic soil carbon
som3c_path (string): state variable, passive organic soil carbon
bulkd_path (string): input, bulk density of soil
edepth_path (string): parameter, depth of soil for this
calculation
Returns:
ompc, total soil organic matter weighted by bulk
density.
"""
ompc = numpy.empty(som1c_2.shape, dtype=numpy.float32)
ompc[:] = _TARGET_NODATA
valid_mask = (
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som2c_2, _SV_NODATA)) &
(~numpy.isclose(som3c, _SV_NODATA)) &
(~numpy.isclose(bulkd, bulkd_nodata)) &
(edepth != _IC_NODATA))
ompc[valid_mask] = (
(som1c_2[valid_mask] + som2c_2[valid_mask] +
som3c[valid_mask]) * 1.724 /
(10000. * bulkd[valid_mask] * edepth[valid_mask]))
return ompc
bulkd_nodata = pygeoprocessing.get_raster_info(bulkd_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
som1c_2_path, som2c_2_path, som3c_path,
bulkd_path, edepth_path]],
ompc_op, ompc_path, gdal.GDT_Float32, _TARGET_NODATA)
def _calc_afiel(
sand_path, silt_path, clay_path, ompc_path, bulkd_path, afiel_path):
"""Calculate field capacity for one soil layer.
Parameters:
sand_path (string): path to proportion sand in soil raster
silt_path (string): path to proportion silt in soil raster
clay_path (string): path to proportion clay in soil raster
ompc_path (string): path to estimated total soil organic matter raster
bulkd_path (string): path to bulk density of soil raster
afiel_path (string): path to result raster, field capacity for this
soil layer
Side effects:
creates the raster indicated by `afiel_path`
Returns:
None
"""
def afiel_op(sand, silt, clay, ompc, bulkd):
"""Calculate field capacity for one soil layer.
Field capacity, maximum soil moisture retention capacity,
from <NAME> Larson 1979, 'Estimating soil and water
retention characteristics from particle size distribution,
organic matter percent and bulk density'. Water Resources
Research 15:1633.
Parameters:
sand_path (string): input, proportion sand in soil
silt_path (string): input, proportion silt in soil
clay_path (string): input, proportion clay in soil
ompc_path (string): derived, estimated total soil organic matter
bulkd_path (string): input, bulk density of soil
Returns:
afiel, field capacity for this soil layer
"""
afiel = numpy.empty(sand.shape, dtype=numpy.float32)
afiel[:] = _TARGET_NODATA
valid_mask = (
(~numpy.isclose(sand, sand_nodata)) &
(~numpy.isclose(silt, silt_nodata)) &
(~numpy.isclose(clay, clay_nodata)) &
(ompc != _TARGET_NODATA) &
(~numpy.isclose(bulkd, bulkd_nodata)))
afiel[valid_mask] = (
0.3075 * sand[valid_mask] + 0.5886 * silt[valid_mask] +
0.8039 * clay[valid_mask] + 2.208E-03 * ompc[valid_mask] +
-0.1434 * bulkd[valid_mask])
return afiel
sand_nodata = pygeoprocessing.get_raster_info(sand_path)['nodata'][0]
silt_nodata = pygeoprocessing.get_raster_info(silt_path)['nodata'][0]
clay_nodata = pygeoprocessing.get_raster_info(clay_path)['nodata'][0]
bulkd_nodata = pygeoprocessing.get_raster_info(bulkd_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sand_path, silt_path, clay_path, ompc_path, bulkd_path]],
afiel_op, afiel_path, gdal.GDT_Float32, _TARGET_NODATA)
def _calc_awilt(
sand_path, silt_path, clay_path, ompc_path, bulkd_path, awilt_path):
"""Calculate wilting point for one soil layer.
Wilting point, minimum soil water required by plants before
wilting, from Gupta and Larson 1979, 'Estimating soil and
water retention characteristics from particle size distribution,
organic matter percent and bulk density'. Water Resources
Research 15:1633.
Parameters:
sand_path (string): path to proportion sand in soil raster
silt_path (string): path to proportion silt in soil raster
clay_path (string): path to proportion clay in soil raster
ompc_path (string): path to estimated total soil organic matter raster
bulkd_path (string): path to bulk density of soil raster
awilt_path (string): path to result raster, wilting point for this
soil layer
Side effects:
creates the raster indicated by `awilt_path`
Returns:
None
"""
def awilt_op(sand, silt, clay, ompc, bulkd):
"""Calculate wilting point for one soil layer.
Wilting point, minimum soil water required by plants before
wilting, from Gupta and Larson 1979, 'Estimating soil and
water retention characteristics from particle size distribution,
organic matter percent and bulk density'. Water Resources
Research 15:1633.
Parameters:
sand_path (string): input, proportion sand in soil
silt_path (string): input, proportion silt in soil
clay_path (string): input, proportion clay in soil
ompc_path (string): derived, estimated total soil organic matter
bulkd_path (string): input, bulk density of soil
Returns:
awilt, wilting point for this soil layer
"""
awilt = numpy.empty(sand.shape, dtype=numpy.float32)
awilt[:] = _TARGET_NODATA
valid_mask = (
(~numpy.isclose(sand, sand_nodata)) &
(~numpy.isclose(silt, silt_nodata)) &
(~numpy.isclose(clay, clay_nodata)) &
(ompc != _TARGET_NODATA) &
(~numpy.isclose(bulkd, bulkd_nodata)))
awilt[valid_mask] = (
-0.0059 * sand[valid_mask] + 0.1142 * silt[valid_mask] +
0.5766 * clay[valid_mask] + 2.228E-03 * ompc[valid_mask] +
0.02671 * bulkd[valid_mask])
return awilt
sand_nodata = pygeoprocessing.get_raster_info(sand_path)['nodata'][0]
silt_nodata = pygeoprocessing.get_raster_info(silt_path)['nodata'][0]
clay_nodata = pygeoprocessing.get_raster_info(clay_path)['nodata'][0]
bulkd_nodata = pygeoprocessing.get_raster_info(bulkd_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sand_path, silt_path, clay_path, ompc_path, bulkd_path]],
awilt_op, awilt_path, gdal.GDT_Float32, _TARGET_NODATA)
def _afiel_awilt(
site_index_path, site_param_table, som1c_2_path, som2c_2_path,
som3c_path, sand_path, silt_path, clay_path, bulk_d_path, pp_reg):
"""Calculate field capacity and wilting point for each soil layer.
Computations based on Gupta and Larson 1979, 'Estimating soil and water
retention characteristics from particle size distribution, organic
matter percent and bulk density'. Water Resources Research 15:1633.
Field capacity is calculated for -0.33 bar; wilting point is
calculated for water content at -15 bars.
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters including 'edepth' field
som1c_2_path (string): path to the state variable 'som1c_2',
active organic soil carbon
som2c_2_path (string): path to the state variable 'som2c_2',
slow organic soil carbon
som3c_path (string): path to the state variable 'som3c',
passive organic soil carbon
sand_path (string): path to raster containing proportion sand in soil
silt_path (string): path to raster containing proportion silt in soil
clay_path (string): path to raster containing proportion clay in soil
bulk_d_path (string): path to raster containing bulk density of soil
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation
Modifies the rasters pp_reg['afiel_<layer>'] and pp_reg['awilt_<layer>']
for all soil layers.
Returns:
None
"""
def decrement_ompc(ompc_orig_path, ompc_dec_path):
"""Decrease estimated organic matter to 85% of its value.
In each subsequent soil layer, estimated organic matter is decreased
by 15%, to 85% of its previous value.
Parameters:
ompc_orig_path (string): path to estimated soil organic matter
raster
ompc_dec_path (string): path to result raster, estimated soil
organic matter decreased to 85% of its previous value
Side effects:
modifies or creates the raster indicated by `ompc_dec_path`
Returns:
None
"""
def decrement_op(ompc_orig):
"""Reduce organic matter to 85% of its previous value."""
ompc_dec = numpy.empty(ompc_orig.shape, dtype=numpy.float32)
ompc_dec[:] = _TARGET_NODATA
valid_mask = (ompc_orig != _TARGET_NODATA)
ompc_dec[valid_mask] = ompc_orig[valid_mask] * 0.85
return ompc_dec
pygeoprocessing.raster_calculator(
[(ompc_orig_path, 1)], decrement_op, ompc_dec_path,
gdal.GDT_Float32, _TARGET_NODATA)
# temporary intermediate rasters for calculating field capacity and
# wilting point
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
edepth_path = os.path.join(temp_dir, 'edepth.tif')
ompc_path = os.path.join(temp_dir, 'ompc.tif')
site_to_edepth = dict(
[(site_code, float(table['edepth'])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_edepth, edepth_path, gdal.GDT_Float32,
_IC_NODATA)
# estimate total soil organic matter
_calc_ompc(
som1c_2_path, som2c_2_path, som3c_path, bulk_d_path, edepth_path,
ompc_path)
# calculate field capacity and wilting point for each soil layer,
# decreasing organic matter content by 85% with each layer
for lyr in range(1, 10):
afiel_path = pp_reg['afiel_{}_path'.format(lyr)]
awilt_path = pp_reg['awilt_{}_path'.format(lyr)]
_calc_afiel(
sand_path, silt_path, clay_path, ompc_path, bulk_d_path,
afiel_path)
_calc_awilt(
sand_path, silt_path, clay_path, ompc_path, bulk_d_path,
awilt_path)
ompc_dec_path = os.path.join(temp_dir, 'ompc{}.tif'.format(lyr))
decrement_ompc(ompc_path, ompc_dec_path)
ompc_path = ompc_dec_path
# clean up temporary files
shutil.rmtree(temp_dir)
def _persistent_params(
site_index_path, site_param_table, sand_path, clay_path, pp_reg):
"""Calculate persistent parameters.
The calculated values do not change over the course of the simulation.
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
sand_path (string): path to raster containing proportion sand in soil
clay_path (string): path to raster containing proportion clay in soil
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation.
Modifies the persistent parameter rasters indexed by the following
keys:
pp_reg['wc_path']
pp_reg['eftext_path']
pp_reg['p1co2_2_path']
pp_reg['fps1s3_path']
pp_reg['fps2s3_path']
pp_reg['orglch_path']
pp_reg['vlossg_path']
Returns:
None
"""
sand_nodata = pygeoprocessing.get_raster_info(sand_path)['nodata'][0]
clay_nodata = pygeoprocessing.get_raster_info(clay_path)['nodata'][0]
# temporary intermediate rasters for persistent parameters calculation
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for val in[
'peftxa', 'peftxb', 'p1co2a_2', 'p1co2b_2', 'ps1s3_1',
'ps1s3_2', 'ps2s3_1', 'ps2s3_2', 'omlech_1', 'omlech_2', 'vlossg']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for (
site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path, gdal.GDT_Float32,
_IC_NODATA)
def calc_wc(afiel_1, awilt_1):
"""Calculate water content of soil layer 1."""
return afiel_1 - awilt_1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
pp_reg['afiel_1_path'], pp_reg['awilt_1_path']]],
calc_wc, pp_reg['wc_path'], gdal.GDT_Float32, _TARGET_NODATA)
def calc_eftext(peftxa, peftxb, sand):
"""Calculate effect of soil texture on microbial decomposition.
Use an empirical regression to estimate the effect of soil
sand content on the microbe decomposition rate. Line 359 Prelim.f
Parameters:
peftxa (numpy.ndarray): parameter, regression intercept
peftxb (numpy.ndarray): parameter, regression slope
sand (numpy.ndarray): input, proportion sand in soil
Returns:
eftext, coefficient that modifies microbe decomposition rate.
"""
eftext = numpy.empty(sand.shape, dtype=numpy.float32)
eftext[:] = _IC_NODATA
valid_mask = (
(peftxa != _IC_NODATA) &
(peftxb != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)))
eftext[valid_mask] = (
peftxa[valid_mask] + (peftxb[valid_mask] * sand[valid_mask]))
return eftext
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['peftxa'], param_val_dict['peftxb'], sand_path]],
calc_eftext, pp_reg['eftext_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_p1co2_2(p1co2a_2, p1co2b_2, sand):
"""Calculate the fraction of carbon lost to CO2 from som1c_2.
During decomposition from active organic soil carbon, a fraction
of decomposing material is lost to CO2 as the soil respires.
Line 366 Prelim.f
Parameters:
p1co2a_2 (numpy.ndarray): parameter, intercept of regression
predicting loss to CO2 from active organic soil carbon
p1co2b_2 (numpy.ndarray): parameter, slope of regression
predicting loss to CO2 from active organic soil carbon
sand (numpy.ndarray): input, proportion sand in soil
Returns:
p1co2_2, fraction of carbon that flows to CO2 from active
organic soil carbon
"""
p1co2_2 = numpy.empty(sand.shape, dtype=numpy.float32)
p1co2_2[:] = _IC_NODATA
valid_mask = (
(p1co2a_2 != _IC_NODATA) &
(p1co2b_2 != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)))
p1co2_2[valid_mask] = (
p1co2a_2[valid_mask] + (p1co2b_2[valid_mask] * sand[valid_mask]))
return p1co2_2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['p1co2a_2'],
param_val_dict['p1co2b_2'], sand_path]],
calc_p1co2_2, pp_reg['p1co2_2_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_fps1s3(ps1s3_1, ps1s3_2, clay):
"""Calculate effect of clay content on decomposition from som1c_2.
Use an empirical regression to estimate the effect of clay content
of soil on flow from soil organic matter with fast turnover to
soil organic matter with slow turnover. Line 370 Prelim.f
Parameters:
ps1s3_1 (numpy.ndarray): parameter, regression intercept
ps1s3_2 (numpy.ndarray): parameter, regression slope
clay (numpy.ndarray): input, proportion clay in soil
Returns:
fps1s3, coefficient that modifies rate of decomposition
from som1c_2
"""
fps1s3 = numpy.empty(clay.shape, dtype=numpy.float32)
fps1s3[:] = _IC_NODATA
valid_mask = (
(ps1s3_1 != _IC_NODATA) &
(ps1s3_2 != _IC_NODATA) &
(~numpy.isclose(clay, clay_nodata)))
fps1s3[valid_mask] = (
ps1s3_1[valid_mask] + (ps1s3_2[valid_mask] * clay[valid_mask]))
return fps1s3
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['ps1s3_1'], param_val_dict['ps1s3_2'], clay_path]],
calc_fps1s3, pp_reg['fps1s3_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_fps2s3(ps2s3_1, ps2s3_2, clay):
"""Calculate effect of clay content on decomposition from som2c_2.
Use an empirical regression to estimate the effect of clay content
of soil on flow from slow soil organic carbon to soil passive organic
carbon. Line 371 Prelim.f
Parameters:
ps2s3_1 (numpy.ndarray): parameter, regression intercept
ps2s3_2 (numpy.ndarray): parameter, regression slope
clay (numpy.ndarray): input, proportion clay in soil
Returns:
fps2s3, coefficient that modifies rate of decomposition from
som2c_2 to som3c
"""
fps2s3 = numpy.empty(clay.shape, dtype=numpy.float32)
fps2s3[:] = _IC_NODATA
valid_mask = (
(ps2s3_1 != _IC_NODATA) &
(ps2s3_2 != _IC_NODATA) &
(~numpy.isclose(clay, clay_nodata)))
fps2s3[valid_mask] = (
ps2s3_1[valid_mask] + (ps2s3_2[valid_mask] * clay[valid_mask]))
return fps2s3
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['ps2s3_1'], param_val_dict['ps2s3_2'], clay_path]],
calc_fps2s3, pp_reg['fps2s3_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_orglch(omlech_1, omlech_2, sand):
"""Calculate the effect of sand content on leaching from soil.
Use an empirical regression to estimate the effect of sand content
of soil on rate of organic leaching from soil when there is drainage
of soil water from soil layer 1 to soil layer 2. Line 110 Predec.f
Parameters:
omlech_1 (numpy.ndarray): parameter, regression intercept
omlech_2 (numpy.ndarray): parameter, regression slope
sand (numpy.ndarray): input, proportion sand in soil
Returns:
orglch, the fraction of organic compounds leaching from soil
with drainage from soil layer 1 to layer 2
"""
orglch = numpy.empty(sand.shape, dtype=numpy.float32)
orglch[:] = _IC_NODATA
valid_mask = (
(omlech_1 != _IC_NODATA) &
(omlech_2 != _IC_NODATA) &
(~numpy.isclose(sand, sand_nodata)))
orglch[valid_mask] = (
omlech_1[valid_mask] + (omlech_2[valid_mask] * sand[valid_mask]))
return orglch
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['omlech_1'], param_val_dict['omlech_2'],
sand_path]],
calc_orglch, pp_reg['orglch_path'], gdal.GDT_Float32, _IC_NODATA)
def calc_vlossg(vlossg_param, clay):
"""Calculate proportion of gross mineralized N that is volatized.
During decomposition, some N is lost to volatilization. This is a
function of the gross mineralized N and is calculated according to this
multiplier, which varies with soil clay content.
Parameters:
vlossg (numpy.ndarray): parameter, volatilization loss multiplier
clay (numpy.ndarray): input, proportion clay in soil
Returns:
vlossg, proportion of gross mineralized N that is volatized
"""
valid_mask = (
(vlossg_param != _IC_NODATA) &
(~numpy.isclose(clay, clay_nodata)))
vlossg = numpy.empty(vlossg_param.shape, dtype=numpy.float32)
vlossg[:] = _IC_NODATA
max_mask = ((clay > 0.3) & valid_mask)
min_mask = ((clay < 0.1) & valid_mask)
vlossg[valid_mask] = -0.1 * (clay[valid_mask] - 0.3) + 0.01
vlossg[max_mask] = 0.01
vlossg[min_mask] = 0.03
vlossg[valid_mask] = vlossg[valid_mask] * vlossg_param[valid_mask]
return vlossg
pygeoprocessing.raster_calculator(
[(path, 1) for path in [param_val_dict['vlossg'], clay_path]],
calc_vlossg, pp_reg['vlossg_path'], gdal.GDT_Float32, _IC_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _aboveground_ratio(anps, tca, pcemic_1, pcemic_2, pcemic_3):
"""Calculate C/<iel> ratios of decomposing aboveground material.
This ratio is used to test whether there is sufficient <iel> (N or P)
in aboveground material for the material to decompose. Agdrat.f
Parameters:
anps (numpy.ndarray): state variable, N or P in the donor material
tca (numpy.ndarray): state variable, total C in the donor material
pcemic_1 (numpy.ndarray): parameter, maximum C/<iel> of new material
pcemic_2 (numpy.ndarray): parameter, minimum C/<iel> of new material
pcemic_3 (numpy.ndarray): parameter, minimum <iel> content of
decomposing material that gives minimum C/<iel> of new material
Returns:
agdrat, the C/<iel> ratio of new material
"""
valid_mask = (
(~numpy.isclose(anps, _SV_NODATA)) &
(~numpy.isclose(tca, _SV_NODATA)) &
(pcemic_1 != _IC_NODATA) &
(pcemic_2 != _IC_NODATA) &
(pcemic_3 != _IC_NODATA))
cemicb = numpy.empty(anps.shape, dtype=numpy.float32)
cemicb[:] = _IC_NODATA
cemicb[valid_mask] = (
(pcemic_2[valid_mask] - pcemic_1[valid_mask]) /
pcemic_3[valid_mask])
econt = numpy.empty(anps.shape, dtype=numpy.float32)
econt[:] = _TARGET_NODATA
econt[valid_mask] = 0
decompose_mask = ((tca > 0.) & valid_mask)
econt[decompose_mask] = anps[decompose_mask] / (tca[decompose_mask] * 2.5)
agdrat = numpy.empty(anps.shape, dtype=numpy.float32)
agdrat[:] = _TARGET_NODATA
agdrat[valid_mask] = pcemic_2[valid_mask]
compute_mask = ((econt <= pcemic_3) & valid_mask)
agdrat[compute_mask] = (
pcemic_1[compute_mask] + econt[compute_mask] * cemicb[compute_mask])
return agdrat
def _belowground_ratio(aminrl, varat_1_iel, varat_2_iel, varat_3_iel):
"""Calculate C/<iel> ratios of decomposing belowground material.
This ratio is used to test whether there is sufficient <iel> (N or P)
in soil metabolic material to decompose. Bgdrat.f
Parameters:
aminrl (numpy.ndarray): derived, average surface mineral <iel>
varat_1_iel (numpy.ndarray): parameter, maximum C/<iel> ratio for
newly decomposed material
varat_2_iel (numpy.ndarray): parameter, minimum C/<iel> ratio
varat_3_iel (numpy.ndarray): parameter, amount of <iel> present
when minimum ratio applies
Returns:
bgdrat, the C/<iel> ratio of new material
"""
valid_mask = (
(~numpy.isclose(aminrl, _SV_NODATA)) &
(varat_1_iel != _IC_NODATA) &
(varat_2_iel != _IC_NODATA) &
(varat_3_iel != _IC_NODATA))
bgdrat = numpy.empty(aminrl.shape, dtype=numpy.float32)
bgdrat[:] = _TARGET_NODATA
bgdrat[valid_mask] = (
(1. - aminrl[valid_mask] / varat_3_iel[valid_mask]) *
(varat_1_iel[valid_mask] - varat_2_iel[valid_mask]) +
varat_2_iel[valid_mask])
max_mask = ((aminrl <= 0) & valid_mask)
bgdrat[max_mask] = varat_1_iel[max_mask]
min_mask = ((aminrl > varat_3_iel) & valid_mask)
bgdrat[min_mask] = varat_2_iel[min_mask]
return bgdrat
def _structural_ratios(site_index_path, site_param_table, sv_reg, pp_reg):
"""Calculate maximum C/N and C/P ratios for structural material.
These ratios limit decomposition of structural material (i.e., material
containing lignin). Lines 31-77 Predec.f
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation.
Modifies the persistent parameter rasters indexed by the following
keys:
pp_reg['rnewas_1_1_path']
pp_reg['rnewas_1_2_path']
pp_reg['rnewas_2_1_path']
pp_reg['rnewas_2_2_path']
pp_reg['rnewbs_1_1_path']
pp_reg['rnewbs_1_2_path']
pp_reg['rnewbs_2_1_path']
pp_reg['rnewbs_2_2_path']
Returns:
None
"""
# temporary parameter rasters for structural ratios calculations
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for iel in [1, 2]:
for val in[
'pcemic1_2', 'pcemic1_1', 'pcemic1_3', 'pcemic2_2',
'pcemic2_1', 'pcemic2_3', 'rad1p_1', 'rad1p_2',
'rad1p_3', 'varat1_1', 'varat22_1']:
target_path = os.path.join(temp_dir, '{}_{}.tif'.format(val, iel))
param_val_dict['{}_{}'.format(val, iel)] = target_path
site_to_val = dict(
[(site_code, float(table['{}_{}'.format(val, iel)])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
def calc_rnewas_som2(
pcemic2_2, pcemic2_1, pcemic2_3, struce_1, strucc_1, rad1p_1,
rad1p_2, rad1p_3, pcemic1_2, rnewas1):
"""Calculate C/<iel> ratio for decomposition into som2.
This ratio is calculated separately for each nutrient (i.e., N, P).
When material decomposes into the surface slow organic pool, the
C/<iel> ratio of decomposing material must be smaller than or equal to
this ratio. A portion of the ratio of material entering som1, the
surface active pool, is also added to som2 and calculated here.
Parameters:
pcemic2_2 (numpy.ndarray): parameter, minimum C/<iel> ratio for
surface slow organic pool
pcemic2_1 (numpy.ndarray): parameter, maximum C/<iel> ratio for
surface slow organic pool
pcemic2_3 (numpy.ndarray): parameter, mimimum <iel> content of
decomposing aboveground material, above which the C/<iel>
ratio of the surface slow organic pool equals pcemic1_2
struce_1 (numpy.ndarray): state variable, <iel> in surface
structural material
strucc_1 (numpy.ndarray): state variable, C in surface
structural material
rad1p_1 (numpy.ndarray): parameter, intercept of regression used
to calculate addition of <iel> from surface active pool
rad1p_2 (numpy.ndarray): parameter, slope of regression used
to calculate addition of <iel> from surface active pool
rad1p_3 (numpy.ndarray): parameter, minimum allowable C/<iel>
used to calculate addition term for C/<iel> ratio of som2
formed from surface active pool
pcemic1_2 (numpy.ndarray): parameter, minimum C/<iel> ratio for
surface active organic pool
rnewas1 (numpy.ndarray): derived, C/<iel> ratio for decomposition
into som1
Returns:
rnewas2, required ratio for decomposition of structural material
into som2 for one nutrient
"""
valid_mask = (
(pcemic2_2 != _IC_NODATA) &
(pcemic2_1 != _IC_NODATA) &
(pcemic2_3 != _IC_NODATA) &
(~numpy.isclose(struce_1, _SV_NODATA)) &
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(rad1p_1 != _IC_NODATA) &
(rad1p_2 != _IC_NODATA) &
(rad1p_3 != _IC_NODATA) &
(pcemic1_2 != _IC_NODATA) &
(rnewas1 != _TARGET_NODATA))
rnewas2 = _aboveground_ratio(
struce_1, strucc_1, pcemic2_1, pcemic2_2, pcemic2_3)
radds1 = numpy.empty(strucc_1.shape, dtype=numpy.float32)
radds1[:] = _TARGET_NODATA
radds1[valid_mask] = (
rad1p_1[valid_mask] + rad1p_2[valid_mask] *
(rnewas1[valid_mask] - pcemic1_2[valid_mask]))
rnewas2[valid_mask] = rnewas1[valid_mask] + radds1[valid_mask]
rnewas2[valid_mask] = numpy.maximum(
rnewas2[valid_mask], rad1p_3[valid_mask])
return rnewas2
for iel in [1, 2]:
# calculate rnewas_iel_1 - aboveground material to SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['struce_1_{}_path'.format(iel)],
sv_reg['strucc_1_path'],
param_val_dict['pcemic1_1_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)],
param_val_dict['pcemic1_3_{}'.format(iel)]]],
_aboveground_ratio, pp_reg['rnewas_{}_1_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate rnewas_iel_2 - aboveground material to SOM2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['pcemic2_2_{}'.format(iel)],
param_val_dict['pcemic2_1_{}'.format(iel)],
param_val_dict['pcemic2_3_{}'.format(iel)],
sv_reg['struce_1_{}_path'.format(iel)],
sv_reg['strucc_1_path'],
param_val_dict['rad1p_1_{}'.format(iel)],
param_val_dict['rad1p_2_{}'.format(iel)],
param_val_dict['rad1p_3_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)],
pp_reg['rnewas_{}_1_path'.format(iel)]]],
calc_rnewas_som2, pp_reg['rnewas_{}_2_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate rnewbs_iel_1 - belowground material to SOM1
site_to_varat1_1 = dict([
(site_code, float(table['varat1_1_{}'.format(iel)])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_varat1_1,
pp_reg['rnewbs_{}_1_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate rnewbs_iel_2 - belowground material to SOM2
# rnewbs(iel,2) = varat22(1,iel)
site_to_varat22_1 = dict([
(site_code, float(table['varat22_1_{}'.format(iel)])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_varat22_1,
pp_reg['rnewbs_{}_2_path'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _yearly_tasks(
aligned_inputs, site_param_table, veg_trait_table, month_index,
pft_id_set, year_reg):
"""Calculate quantities that remain static for 12 months.
These quantities are annual precipitation, annual atmospheric N
deposition, and the fraction of plant residue which is lignin for each pft.
Century also calculates non-symbiotic soil N fixation once yearly, but here
those were moved to monthly tasks. Century uses precipitation in the future
12 months (prcgrw) to predict root:shoot ratios, but here we instead use
the sum of monthly precipitation in 12 months including the current one, if
data for 12 future months are not available.
Lines 79-82, 164 Eachyr.f
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including monthly precipitation and site
spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
month_index (int): current monthly step, relative to 0 so that
month_index=0 at first monthly time step
pft_id_set (set): set of integers identifying plant functional types
year_reg (dict): map of key, path pairs giving paths to the annual
precipitation and N deposition rasters
Side effects:
modifies or creates the rasters indicated by:
year_reg['annual_precip_path']
year_reg['baseNdep_path']
year_reg['pltlig_above_<pft>'] for each pft
year_reg['pltlig_below_<pft>'] for each pft
Returns:
None
Raises:
ValueError if fewer than 12 monthly precipitation rasters can be found
"""
def calc_base_N_dep(epnfa_1, epnfa_2, prcann):
"""Calculate base annual atmospheric N deposition.
Parameters:
epnfa_1 (numpy.ndarray): parameter, intercept of regression
predicting atmospheric N deposition from precipitation
epnfa_2 (numpy.ndarray): parameter, slope of regression predicting
atmospheric N deposition from precipitation
prcann (numpy.ndarray): derived, annual precipitation
Returns:
baseNdep, annual atmospheric N deposition
"""
baseNdep = numpy.empty(prcann.shape, dtype=numpy.float32)
baseNdep[:] = 0.
valid_mask = (
(epnfa_1 != _IC_NODATA) &
(epnfa_2 != _IC_NODATA) &
(prcann != _TARGET_NODATA))
baseNdep[valid_mask] = (
epnfa_1[valid_mask] +
(epnfa_2[valid_mask] * numpy.minimum(prcann[valid_mask], 80.)))
baseNdep[baseNdep < 0] = 0.
return baseNdep
def calc_pltlig(fligni_1_lyr, fligni_2_lyr, prcann):
"""Calculate the fraction of residue that is lignin. Cmplig.f
This fraction is used to calculate the fraction of residue (i.e.,
incoming litter from fall of standing dead or incoming soil from death
of roots) that is partitioned to metabolic vs structural pools. It is
calculated once per year from annual precipitation and fixed
parameters.
Parameters:
fligni_1_lyr (numpy.ndarray): parameter, intercept for regression
predicting lignin content fraction from rainfall
fligni_2_lyr (numpy.ndarray): parameter, slope for regression
predicting lignin content fraction from rainfall
prcann (numpy.ndarray): derived, annual precipitation
Returns:
pltlig_lyr, fraction of residue that is lignin
"""
valid_mask = (
(fligni_1_lyr != _IC_NODATA) &
(fligni_2_lyr != _IC_NODATA) &
(prcann != _TARGET_NODATA))
pltlig = numpy.empty(fligni_1_lyr.shape, dtype=numpy.float32)
pltlig[:] = _TARGET_NODATA
pltlig[valid_mask] = (
fligni_1_lyr[valid_mask] + fligni_2_lyr[valid_mask] *
prcann[valid_mask])
pltlig[valid_mask] = numpy.clip(pltlig[valid_mask], 0.02, 0.5)
return pltlig
offset = -12
annual_precip_rasters = []
while len(annual_precip_rasters) < 12:
offset += 1
if offset == 12:
raise ValueError("Insufficient precipitation rasters were found")
precip_month = month_index + offset
try:
annual_precip_rasters.append(
aligned_inputs['precip_%d' % precip_month])
except KeyError:
continue
precip_nodata = set([])
for precip_raster in annual_precip_rasters:
precip_nodata.update(
set([pygeoprocessing.get_raster_info(precip_raster)['nodata'][0]]))
if len(precip_nodata) > 1:
raise ValueError("Precipitation rasters include >1 nodata value")
precip_nodata = list(precip_nodata)[0]
raster_list_sum(
annual_precip_rasters, precip_nodata, year_reg['annual_precip_path'],
_TARGET_NODATA)
# intermediate parameter rasters for this operation
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for val in['epnfa_1', 'epnfa_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for val in ['fligni_1_1', 'fligni_2_1', 'fligni_1_2', 'fligni_2_2']:
for pft_i in pft_id_set:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
# calculate base N deposition
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['epnfa_1'], param_val_dict['epnfa_2'],
year_reg['annual_precip_path']]],
calc_base_N_dep, year_reg['baseNdep_path'], gdal.GDT_Float32,
_TARGET_NODATA)
for pft_i in pft_id_set:
# fraction of surface residue that is lignin
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['fligni_1_1_{}'.format(pft_i)],
param_val_dict['fligni_2_1_{}'.format(pft_i)],
year_reg['annual_precip_path']]],
calc_pltlig, year_reg['pltlig_above_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# fraction of soil residue that is lignin
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['fligni_1_2_{}'.format(pft_i)],
param_val_dict['fligni_2_2_{}'.format(pft_i)],
year_reg['annual_precip_path']]],
calc_pltlig, year_reg['pltlig_below_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_latitude(template_raster, latitude_raster_path):
"""Calculate latitude at the center of each pixel in a template raster."""
pygeoprocessing.new_raster_from_base(
template_raster, latitude_raster_path, gdal.GDT_Float32,
[_IC_NODATA])
latitude_raster = gdal.OpenEx(
latitude_raster_path, gdal.OF_RASTER | gdal.GA_Update)
target_band = latitude_raster.GetRasterBand(1)
base_raster_info = pygeoprocessing.get_raster_info(template_raster)
geotransform = base_raster_info['geotransform']
for offset_map, raster_block in pygeoprocessing.iterblocks(
(template_raster, 1)):
n_y_block = raster_block.shape[0]
n_x_block = raster_block.shape[1]
# offset by .5 so we're in the center of the pixel
xoff = offset_map['xoff'] + 0.5
yoff = offset_map['yoff'] + 0.5
# calculate the projected x and y coordinate bounds for the block
x_range = numpy.linspace(
geotransform[0] + geotransform[1] * xoff,
geotransform[0] + geotransform[1] * (xoff + n_x_block - 1),
n_x_block)
y_range = numpy.linspace(
geotransform[3] + geotransform[5] * yoff,
geotransform[3] + geotransform[5] * (yoff + n_y_block - 1),
n_y_block)
# we'll use this to avoid generating any nodata points
valid_mask = raster_block != base_raster_info['nodata']
# these indexes correspond to projected coordinates
# y_vector is what we want, an array of latitude coordinates
x_vector, y_vector = numpy.meshgrid(x_range, y_range)
target_band.WriteArray(
y_vector, xoff=offset_map['xoff'], yoff=offset_map['yoff'])
# Making sure the band and dataset is flushed and not in memory
target_band.FlushCache()
target_band.FlushCache()
target_band = None
gdal.Dataset.__swig_destroy__(latitude_raster)
latitude_raster = None
def _calc_daylength(template_raster, month, daylength_path):
"""Calculate estimated hours of daylength. Daylen.c.
Parameters:
template_raster (string): path to a raster in geographic coordinates
that is aligned with model inputs
month (int): current month of the year, such that month=0 indicates
January
daylength_path (string): path to shortwave radiation raster
Side effects:
modifies or creates the raster indicated by `daylength_path`
Returns:
None
"""
def daylength(month):
def _daylength(latitude):
"""Estimate hours of daylength for a given month and latitude."""
# Julian day at beginning of each month
jday_list = [
1, 32, 61, 92, 122, 153, 183, 214, 245, 275, 306, 337]
jday = jday_list[month - 1]
# Convert latitude from degrees to radians
rlatitude = latitude * (numpy.pi / 180.0)
declin = 0.4014 * numpy.sin(6.283185 * (jday - 77.0) / 365)
temp = 1.0 - (-numpy.tan(rlatitude) * numpy.tan(declin))**2
temp[temp < 0] = 0
par1 = numpy.sqrt(temp)
par2 = -numpy.tan(rlatitude) * numpy.tan(declin)
ahou = numpy.arctan2(par1, par2)
hours_of_daylength = (ahou / numpy.pi) * 24
return hours_of_daylength
return _daylength
# calculate an intermediate input, latitude at each pixel center
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
latitude_raster_path = os.path.join(temp_dir, 'latitude.tif')
calc_latitude(template_raster, latitude_raster_path)
pygeoprocessing.raster_calculator(
[(latitude_raster_path, 1)], daylength(month), daylength_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _shortwave_radiation(template_raster, month, shwave_path):
"""Calculate shortwave radiation outside the atmosphere.
Shortwave radiation outside the atmosphere is calculated according to
Penman (1948), "Natural evaporation from open water, bare soil and grass",
Proc. Roy. Soc. London. The latitude of each pixel is required to
calculate radiation and is calculated as an intermediate step from the
input `template_raster`. shwave.f
Parameters:
template_raster (string): path to a raster in geographic coordinates
that is aligned with model inputs
month (int): current month of the year, such that month=0 indicates
January
shwave_path (string): path to shortwave radiation raster
Side effects:
Modifies the raster indicated by `shwave_path`
Returns:
None
"""
def shwave(month):
def _shwave(latitude):
"""Calculate shortwave radiation outside the atmosphere.
Parameters:
latitude (float): latitude of current site in degrees
month (int): current month of the year, such that month=1
indicates January
Returns:
shwave, short wave solar radiation outside the atmosphere
"""
# Julian date in middle of each month of the year
jday_list = [
16, 46, 75, 106, 136, 167, 197, 228, 259, 289, 320, 350]
jday = jday_list[month - 1]
transcof = 0.8
# Convert latitude from degrees to radians
rlatitude = latitude * (numpy.pi / 180.0)
# short wave solar radiation on a clear day
declin = 0.401426 * numpy.sin(6.283185 * (jday - 77.0) / 365.0)
temp = 1.0 - (-numpy.tan(rlatitude) * numpy.tan(declin))**2
temp[temp < 0.] = 0.
par1 = numpy.sqrt(temp)
par2 = (-numpy.tan(rlatitude) * numpy.tan(declin))
ahou = numpy.arctan2(par1, par2)
ahou[ahou < 0.] = 0.
solrad = (
917.0 * transcof * (
ahou * numpy.sin(rlatitude) * numpy.sin(declin) +
numpy.cos(rlatitude) *
numpy.cos(declin) * numpy.sin(ahou)))
# short wave radiation outside the atmosphere
shwave = solrad / transcof
return shwave
return _shwave
# calculate an intermediate input, latitude at each pixel center
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
latitude_raster_path = os.path.join(temp_dir, 'latitude.tif')
calc_latitude(template_raster, latitude_raster_path)
pygeoprocessing.raster_calculator(
[(latitude_raster_path, 1)],
shwave(month), shwave_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _reference_evapotranspiration(
max_temp_path, min_temp_path, shwave_path, fwloss_4_path,
pevap_path):
"""Calculate reference evapotranspiration.
Reference evapotranspiration from the FAO Penman-Monteith equation in
"Guidelines for computing crop water requirements", FAO Irrigation and
drainage paper 56 (http://www.fao.org/docrep/X0490E/x0490e08.htm),
modified by the parameter fwloss(4).
Parameters:
max_temp_path (string): path to maximum monthly temperature
min_temp_path (string): path to minimum monthly temperature
shwave_path (string): path to shortwave radiation outside the
atmosphere
fwloss_4_path (string): path to parameter, scaling factor for
reference evapotranspiration
pevap_path (string): path to result, reference evapotranspiration
raster
Side effects:
modifies or creates the raster indicated by `pevap_path`
Returns:
None
"""
def _calc_pevap(max_temp, min_temp, shwave, fwloss_4):
"""Calculate reference evapotranspiration.
Pevap.f
Parameters:
max_temp (numpy.ndarray): input, maximum monthly temperature
min_temp (numpy.ndarray): input, minimum monthly temperature
shwave (numpy.ndarray): derived, shortwave radiation outside the
atmosphere
fwloss_4 (numpy.ndarray): parameter, scaling factor for reference
evapotranspiration
Returns:
pevap, reference evapotranspiration
"""
const1 = 0.0023
const2 = 17.8
langleys2watts = 54.0
valid_mask = (
(~numpy.isclose(max_temp, maxtmp_nodata)) &
(~numpy.isclose(min_temp, mintmp_nodata)) &
(shwave != _TARGET_NODATA) &
(fwloss_4 != _IC_NODATA))
trange = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
trange[:] = _TARGET_NODATA
trange[valid_mask] = max_temp[valid_mask] - min_temp[valid_mask]
tmean = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
tmean[:] = _IC_NODATA
tmean[valid_mask] = (max_temp[valid_mask] + min_temp[valid_mask]) / 2.0
# daily reference evapotranspiration
daypet = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
daypet[:] = _TARGET_NODATA
in1 = const1 * (tmean[valid_mask] + const2)
in2 = numpy.sqrt(trange[valid_mask])
in3 = (shwave[valid_mask] / langleys2watts)
daypet[valid_mask] = (
const1 * (tmean[valid_mask] + const2) *
numpy.sqrt(trange[valid_mask]) *
(shwave[valid_mask] / langleys2watts))
# monthly reference evapotranspiration, from mm to cm,
# bounded to be at least 0.5
monpet = (daypet * 30.) / 10.
monpet[monpet <= 0.5] = 0.5
pevap = numpy.empty(fwloss_4.shape, dtype=numpy.float32)
pevap[:] = _TARGET_NODATA
pevap[valid_mask] = monpet[valid_mask] * fwloss_4[valid_mask]
return pevap
maxtmp_nodata = pygeoprocessing.get_raster_info(
max_temp_path)['nodata'][0]
mintmp_nodata = pygeoprocessing.get_raster_info(
min_temp_path)['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
max_temp_path, min_temp_path, shwave_path, fwloss_4_path]],
_calc_pevap, pevap_path, gdal.GDT_Float32, _TARGET_NODATA)
def _potential_production(
aligned_inputs, site_param_table, current_month, month_index,
pft_id_set, veg_trait_table, prev_sv_reg, pp_reg, month_reg):
"""Calculate above- and belowground potential production.
Potential production of each plant functional type is calculated
as total potential production given incoming solar radiation,
limited by temperature, soil moisture, and obstruction by biomass and
litter. Further modification of potential production according to
limitation by water and nutrient availability is calculated in the
root:shoot ratio submodel. Lines 57-148 Potcrp.f
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including precipitation, temperature,
plant functional type composition, and site spatial index
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
current_month (int): month of the year, such that current_month=1
indicates January
month_index (int): month of the simulation, such that month_index=13
indicates month 13 of the simulation
pft_id_set (set): set of integers identifying plant functional types
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
pp_reg (dict): map of key, path pairs giving paths to persistent
intermediate parameters that do not change over the course of
the simulation
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
Side effects:
creates the raster indicated by `month_reg['h2ogef_1_<PFT>']` for each
plant functional type (PFT) where growth is scheduled to occur in
this month
creates the raster indicated by `month_reg['tgprod_pot_prod_<PFT>']`
for each plant functional type (PFT) where growth is scheduled to
occur in this month
Returns:
None
"""
# if growth does not occur this month for all PFTs,
# skip the rest of the function
do_PFT = []
for pft_i in pft_id_set:
if str(current_month) in veg_trait_table[pft_i]['growth_months']:
do_PFT.append(pft_i)
if not do_PFT:
return
def calc_ctemp(aglivc, pmxbio, maxtmp, pmxtmp, mintmp, pmntmp):
"""Calculate soil temperature relative to its effect on growth.
Soil temperature is calculated from monthly temperature inputs and
modified by total standing live biomass. Lines 69-84 Potcrp.f
Parameters:
aglivc (numpy.ndarray): derived, sum of aglivc (carbon in
aboveground live biomass) across plant functional types
pmxbio (numpy.ndarray): parameter, maximum biomass impact on
temperature
maxtmp (numpy.ndarray): input, average maximum monthly
temperature
pmxtmp (numpy.ndarray): parameter, scaling factor for effect of
biomass on monthly maximum temperature
mintmp (numpy.ndarray): input, average minimum monthly temperature
pmntmp (numpy.ndarray): parameter, scaling factor for effect of
biomass on monthly minimum temperature
Returns:
ctemp, effect of soil temperature on potential production
"""
bio = numpy.empty(aglivc.shape, dtype=numpy.float32)
bio[:] = _IC_NODATA
valid_mask = (
(aglivc >= 0.) &
(pmxbio != _IC_NODATA) &
(~numpy.isclose(maxtmp, maxtmp_nodata)) &
(pmxtmp != _IC_NODATA) &
(~numpy.isclose(mintmp, mintmp_nodata)) &
(pmntmp != _IC_NODATA))
bio[valid_mask] = aglivc[valid_mask] * 2.5
bio[bio > pmxbio] = pmxbio[bio > pmxbio]
bio[pmxbio < 0] = _IC_NODATA
# Maximum temperature
tmxs = numpy.empty(aglivc.shape, dtype=numpy.float32)
tmxs[:] = _IC_NODATA
tmxs[valid_mask] = (
maxtmp[valid_mask] + (
(25.4/(1. + 18. * numpy.exp(-0.20 * maxtmp[valid_mask]))) *
(numpy.exp(pmxtmp[valid_mask] * bio[valid_mask]) - 0.13)))
# Minimum temperature
tmns = numpy.empty(aglivc.shape, dtype=numpy.float32)
tmns[:] = _IC_NODATA
tmns[valid_mask] = (
mintmp[valid_mask] +
(pmntmp[valid_mask] * bio[valid_mask] - 1.78))
# Average temperature
ctemp = numpy.empty(aglivc.shape, dtype=numpy.float32)
ctemp[:] = _IC_NODATA
ctemp[valid_mask] = (tmxs[valid_mask] + tmns[valid_mask])/2.
return ctemp
def calc_potprd(mintmp, maxtmp, ctemp, ppdf_1, ppdf_2, ppdf_3, ppdf_4):
"""Calculate the limiting effect of temperature on growth.
Estimated soil temperature restricts potential production according to
a Poisson Density Function curve described by the plant functional
type-specific parameters ppdf_1-4.. Lines 73-84 Potcrp.f
Parameters:
mintmp (numpy.ndarray): input, average minimum monthly temperature
maxtmp (numpy.ndarray): input, average maximum monthly
temperature
ctemp (numpy.ndarray): derived, soil temperature as calculated from
monthly temperature and modified by standing live biomass
ppdf_1 (numpy.ndarray): parameter, optimum temperature for growth
ppdf_2 (numpy.ndarray): parameter, maximum temperature for growth
ppdf_3 (numpy.ndarray): parameter, left curve shape for Poisson
Density Function curve describing growth as function of
temperature
ppdf_4 (numpy.ndarray): parameter, right curve shape for Poisson
Density Function curve describing growth as function of
temperature
Returns:
potprd, scaling factor describing potential production limited
by temperature
"""
valid_mask = (
(~numpy.isclose(mintmp, mintmp_nodata)) &
(~numpy.isclose(maxtmp, maxtmp_nodata)) &
(ctemp != _IC_NODATA) &
(ppdf_1 != _IC_NODATA) &
(ppdf_2 != _IC_NODATA) &
(ppdf_3 != _IC_NODATA) &
(ppdf_4 != _IC_NODATA))
frac = numpy.empty(ctemp.shape, dtype=numpy.float32)
frac[:] = _TARGET_NODATA
frac[valid_mask] = (
(ppdf_2[valid_mask] - ctemp[valid_mask]) /
(ppdf_2[valid_mask] - ppdf_1[valid_mask]))
avg_tmp = numpy.empty(ctemp.shape, dtype=numpy.float32)
avg_tmp[valid_mask] = (mintmp[valid_mask] + maxtmp[valid_mask]) / 2.
grow_mask = (
(avg_tmp > 0) &
(frac > 0) &
valid_mask)
potprd = numpy.empty(ctemp.shape, dtype=numpy.float32)
potprd[:] = _TARGET_NODATA
potprd[valid_mask] = 0.
potprd[grow_mask] = (numpy.exp(
(ppdf_3[grow_mask]/ppdf_4[grow_mask]) *
(1. - numpy.power(frac[grow_mask], ppdf_4[grow_mask]))) *
numpy.power(frac[grow_mask], ppdf_3[grow_mask]))
return potprd
def calc_h2ogef_1(
pevap, avh2o_1, precip, wc, pprpts_1, pprpts_2, pprpts_3):
"""Calculate the limiting factor of water availability on growth.
Soil moisture restricts potential production according to the ratio
of available water to reference evapotranspiration. The shape of the
linear relationship of this ratio to potential production is
controlled by the site parameters pprpts_1, pprpts_2, and pprpts_3.
Lines 57-64 Potcrp.f
Parameters:
pevap (numpy.ndarray): derived, reference evapotranspiration
avh2o_1 (numpy.ndarray): state variable, water available to this
plant functional type for growth
precip (numpy.ndarray): input, precipitation for the current month
wc (numpy.ndarray): derived, water content in soil layer 1
pprpts_1 (numpy.ndarray): parameter, the minimum ratio of
available water to reference evapotranspiration that limits
production completely
pprpts_2 (numpy.ndarray): parameter, influences the slope of the
line predicting potential production from available water
pprpts_3 (numpy.ndarray): parameter, the ratio of available water
to reference evapotranspiration above which production is
not restricted
Returns:
h2ogef_1, scaling factor describing potential production limited
by soil moisture
"""
valid_mask = (
(pevap != _TARGET_NODATA) &
(~numpy.isclose(avh2o_1, _SV_NODATA)) &
(~numpy.isclose(precip, precip_nodata)) &
(wc != _TARGET_NODATA) &
(pprpts_1 != _IC_NODATA) &
(pprpts_2 != _IC_NODATA) &
(pprpts_3 != _IC_NODATA))
h2ogef_prior = numpy.empty(pevap.shape, dtype=numpy.float32)
h2ogef_prior[:] = _TARGET_NODATA
h2ogef_prior[valid_mask] = numpy.where(
pevap[valid_mask] >= 0.01,
(avh2o_1[valid_mask] + precip[valid_mask])/pevap[valid_mask],
0.01)
intcpt = (
pprpts_1[valid_mask] + (pprpts_2[valid_mask] * wc[valid_mask]))
slope = 1. / (pprpts_3[valid_mask] - intcpt)
h2ogef_1 = numpy.empty(pevap.shape, dtype=numpy.float32)
h2ogef_1[:] = _TARGET_NODATA
h2ogef_1[valid_mask] = (
1.0 + slope *
(h2ogef_prior[valid_mask] - pprpts_3[valid_mask]))
h2ogef_1[valid_mask] = numpy.clip(h2ogef_1[valid_mask], 0.01, 1.)
return h2ogef_1
def calc_biof(sum_stdedc, sum_aglivc, strucc_1, pmxbio, biok5):
"""Calculate the effect of obstruction on growth.
Live biomass, standing dead biomass, and litter reduce potential
production through obstruction. The shape of the relationship between
standing biomass and litter and potential production is controlled by
the site parameter pmxbio and the plant functional type parameter
biok5. Lines 91-120 Potcrp.f
Parameters:
sum_stdedc (numpy.ndarray): derived, total carbon in standing dead
biomass across plant functional types
sum_aglivc (numpy.ndarray): derived, total carbon in aboveground
live biomass across plant functional types
strucc_1 (numpy.ndarray): derived, carbon in surface litter
pmxbio (numpy.ndarray): parameter, maximum biomass impact on
potential production
biok5 (numpy.ndarray): parameter, level of standing dead biomass
and litter
Returns:
biof, scaling factor describing potential production limited
by obstruction
"""
valid_mask = (
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(pmxbio != _IC_NODATA) &
(biok5 != _IC_NODATA))
bioc = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
bioc[:] = _IC_NODATA
bioc[valid_mask] = numpy.where(
((sum_stdedc[valid_mask] + 0.1*strucc_1[valid_mask]) <= 0.), 0.01,
(sum_stdedc[valid_mask] + 0.1*strucc_1[valid_mask]))
bioc[valid_mask] = numpy.where(
(bioc[valid_mask] > pmxbio[valid_mask]), pmxbio[valid_mask],
bioc[valid_mask])
bioprd = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
bioprd[:] = _IC_NODATA
bioprd[valid_mask] = 1. - (
bioc[valid_mask] / (biok5[valid_mask] + bioc[valid_mask]))
temp1 = 1. - bioprd
temp2 = temp1 * 0.75
temp3 = temp1 * 0.25
ratlc = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
ratlc[:] = _IC_NODATA
ratlc[valid_mask] = sum_aglivc[valid_mask] / bioc[valid_mask]
biof = numpy.empty(sum_stdedc.shape, dtype=numpy.float32)
biof[:] = _TARGET_NODATA
biof[valid_mask] = numpy.where(
ratlc[valid_mask] <= 1.,
(bioprd[valid_mask] + (temp2[valid_mask] * ratlc[valid_mask])),
numpy.where(
ratlc[valid_mask] <= 2.,
(bioprd[valid_mask] + temp2[valid_mask]) +
temp3[valid_mask] * (ratlc[valid_mask] - 1.),
1.))
return biof
def calc_tgprod_pot_prod(prdx_1, shwave, potprd, h2ogef_1, biof):
"""Calculate total potential production.
Total above- and belowground potential biomass production is calculated
as the total potential production given solar radiation and the
intrinsinc growth capacity of the plant functional type, modified by
limiting factors of temperature, soil moisture, and obstruction by
standing biomass and litter. Line 147 Potcrp.f
Parameters:
prdx_1 (numpy.ndarray): parameter, the intrinsic capacity of the
plant functional type for growth per unit of solar radiation
shwave (numpy.ndarray): derived, shortwave solar radiation outside
the atmosphere
potprd (numpy.ndarray): parameter, scaling factor describing
limiting effect of temperature
h2ogef_1 (numpy.ndarray): derived, scaling factor describing the
limiting effect of soil moisture
biof (numpy.ndarray): derived, scaling factor describing the
limiting effect of obstruction by standing biomass and litter
Returns:
tgprod_pot_prod, total above- and belowground potential biomass
production (g biomass)
"""
valid_mask = (
(prdx_1 != _IC_NODATA) &
(shwave != _TARGET_NODATA) &
(potprd != _TARGET_NODATA) &
(h2ogef_1 != _TARGET_NODATA) &
(biof != _TARGET_NODATA))
tgprod_pot_prod = numpy.empty(prdx_1.shape, dtype=numpy.float32)
tgprod_pot_prod[:] = _TARGET_NODATA
tgprod_pot_prod[valid_mask] = (
prdx_1[valid_mask] * shwave[valid_mask] * potprd[valid_mask] *
h2ogef_1[valid_mask] * biof[valid_mask])
return tgprod_pot_prod
# temporary intermediate rasters for calculating total potential production
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
# site-level temporary calculated values
for val in ['sum_aglivc', 'sum_stdedc', 'ctemp', 'shwave', 'pevap']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
# PFT-level temporary calculated values
for pft_i in pft_id_set:
for val in [
'aglivc_weighted', 'stdedc_weighted', 'potprd', 'biof']:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
# temporary parameter rasters for calculating total potential production
param_val_dict = {}
# site-level parameters
for val in [
'pmxbio', 'pmxtmp', 'pmntmp', 'fwloss_4', 'pprpts_1',
'pprpts_2', 'pprpts_3']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# PFT-level parameters
for val in [
'ppdf_1', 'ppdf_2', 'ppdf_3', 'ppdf_4', 'biok5', 'prdx_1']:
for pft_i in do_PFT:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
maxtmp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
mintmp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
precip_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['precip_{}'.format(month_index)])['nodata'][0]
# calculate intermediate quantities that do not differ between PFTs:
# sum of aglivc (standing live biomass) and stdedc (standing dead biomass)
# across PFTs, weighted by % cover of each PFT
for sv in ['aglivc', 'stdedc']:
weighted_sum_path = temp_val_dict['sum_{}'.format(sv)]
weighted_state_variable_sum(
sv, prev_sv_reg, aligned_inputs, pft_id_set, weighted_sum_path)
# ctemp, soil temperature relative to impacts on growth
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_aglivc'],
param_val_dict['pmxbio'],
aligned_inputs['max_temp_{}'.format(current_month)],
param_val_dict['pmxtmp'],
aligned_inputs['min_temp_{}'.format(current_month)],
param_val_dict['pmntmp']]],
calc_ctemp, temp_val_dict['ctemp'], gdal.GDT_Float32, _IC_NODATA)
# shwave, shortwave radiation outside the atmosphere
_shortwave_radiation(
aligned_inputs['site_index'], current_month, temp_val_dict['shwave'])
# pet, reference evapotranspiration modified by fwloss parameter
_reference_evapotranspiration(
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
temp_val_dict['shwave'],
param_val_dict['fwloss_4'],
temp_val_dict['pevap'])
# calculate quantities that differ between PFTs
for pft_i in do_PFT:
# potprd, the limiting effect of temperature
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['min_temp_{}'.format(current_month)],
aligned_inputs['max_temp_{}'.format(current_month)],
temp_val_dict['ctemp'],
param_val_dict['ppdf_1_{}'.format(pft_i)],
param_val_dict['ppdf_2_{}'.format(pft_i)],
param_val_dict['ppdf_3_{}'.format(pft_i)],
param_val_dict['ppdf_4_{}'.format(pft_i)]]],
calc_potprd, temp_val_dict['potprd_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# h2ogef_1, the limiting effect of soil water availability
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pevap'],
prev_sv_reg['avh2o_1_{}_path'.format(pft_i)],
aligned_inputs['precip_{}'.format(month_index)],
pp_reg['wc_path'],
param_val_dict['pprpts_1'],
param_val_dict['pprpts_2'],
param_val_dict['pprpts_3']]],
calc_h2ogef_1, month_reg['h2ogef_1_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# biof, the limiting effect of obstruction
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_stdedc'],
temp_val_dict['sum_aglivc'],
prev_sv_reg['strucc_1_path'],
param_val_dict['pmxbio'],
param_val_dict['biok5_{}'.format(pft_i)]]],
calc_biof, temp_val_dict['biof_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# total potential production
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['prdx_1_{}'.format(pft_i)],
temp_val_dict['shwave'],
temp_val_dict['potprd_{}'.format(pft_i)],
month_reg['h2ogef_1_{}'.format(pft_i)],
temp_val_dict['biof_{}'.format(pft_i)]]],
calc_tgprod_pot_prod,
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _calc_favail_P(sv_reg, param_val_dict):
"""Calculate the fraction of P in surface layer available to plants.
This must be performed after the sum of mineral N in the surface layer
is calculated because the fraction of labile P available to plants is
impacted by the amount of mineral N in the surface layer.
Parameters:
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month, including minerl_1_1, mineral N in the
surface layer
param_val_dict (dict): map of key, path pairs giving paths to
site-level parameters, including favail_4, favail_5, favail_6,
and favail_2
Side effects:
modifies or creates the raster indicated by
`param_val_dict['favail_2']`
Returns:
None
"""
def favail_P_op(minerl_1_1, favail_4, favail_5, favail_6):
"""Calculate the fraction of P in surface layer available to plants.
The fraction of labile P available to plants depends on mineral N in
the surface layer and site parameters favail_4, favail_5, favail_6.
Line 395 Simsom.f
Parameters:
minerl_1_1 (numpy.ndarray): state variable, mineral N in the
surface layer
favail_4 (numpy.ndarray): parameter, minimum fraction of P
available
favail_5 (numpy.ndarray): parameter, maximum fraction of P
available
favail_6 (numpy.ndarray): parameter, mineral N in surface layer
required to attain maximum fraction of P available
Returns:
favail_P, fraction of mineral P available to plants
"""
valid_mask = (
(~numpy.isclose(minerl_1_1, _SV_NODATA)) &
(favail_4 != _IC_NODATA) &
(favail_5 != _IC_NODATA) &
(favail_6 != _IC_NODATA))
interim = numpy.empty(minerl_1_1.shape, dtype=numpy.float32)
interim[:] = _IC_NODATA
interim[valid_mask] = (
favail_4[valid_mask] + minerl_1_1[valid_mask] *
(favail_5[valid_mask] - favail_4[valid_mask]) /
favail_6[valid_mask])
favail_P = numpy.empty(minerl_1_1.shape, dtype=numpy.float32)
favail_P[:] = _IC_NODATA
favail_P[valid_mask] = numpy.maximum(
favail_4[valid_mask], numpy.minimum(
interim[valid_mask], favail_5[valid_mask]))
return favail_P
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_1_1_path'],
param_val_dict['favail_4'],
param_val_dict['favail_5'],
param_val_dict['favail_6']]],
favail_P_op, param_val_dict['favail_2'],
gdal.GDT_Float32, _IC_NODATA)
def _calc_avail_mineral_nutrient(pft_param_dict, sv_reg, iel, target_path):
"""Calculate one mineral nutrient available to one plant functional type.
The mineral nutrient available to a plant functional type is calculated
from the mineral nutrient content of soil layers accessible by that
plant function type.
Parameters:
pft_param_dict (dict): map of key, value pairs giving the values of
parameters for this plant functional type
(i.e., veg_trait_table[pft_i] for this pft_i)
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
iel (int): integer index for current nutrient (1=N, 2=P)
target_path (string): path to raster to contain available mineral
nutrient for this plant functional type and nutrient
Side effects:
modifies or creates the raster indicated by `target_path`
Returns:
None
"""
nlay = int(pft_param_dict['nlaypg'])
mineral_raster_list = [
sv_reg['minerl_{}_{}_path'.format(lyr, iel)] for lyr in range(
1, nlay + 1)]
raster_list_sum(
mineral_raster_list, _SV_NODATA, target_path, _TARGET_NODATA,
nodata_remove=True)
def _calc_available_nutrient(
pft_i, iel, pft_param_dict, sv_reg, site_param_table, site_index_path,
availm_path, favail_path, tgprod_path, eavail_path):
"""Calculate nutrient available to a plant functional type.
The nutrient available is the sum of mineral nutrient (N or P) in soil
layers accessible by the roots of the plant functional type, modified
by the fraction of nutrient available to plants and the current root
biomass.
Parameters:
pft_i (int): plant functional type index
iel (int): nutrient index (iel=1 indicates N, iel=2 indicates P)
pft_param_dict (dict): map of key, value pairs giving the values of
parameters for this plant functional type
(i.e., veg_trait_table[pft_i] for this pft_i)
sv_reg (dict): map of key, path pairs giving paths to state
variables for the current month
site_index_path (string): path to site spatial index raster
availm_path (string): path to raster containing available mineral
nutrient for the given plant functional type and nutrient
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
favail_path (string): path to raster containing the appropriate value
of the parameter favail. For nitrogen, this parameter is supplied
directly as user input, but for phosphorus, it must be calculated
from other parameters.
tgprod_path (string): path to raster containing total potential
production (g biomass)
eavail_path (string): path to location to store the result, nutrient
available to the plant functional type
Side effects:
modifies or creates the raster indicated by `eavail_path`
Returns:
None
"""
def calc_eavail(rictrl, bglivc, riint, availm, favail, crpstg):
"""Calculate available nutrient.
Parameters:
rictrl (numpy.ndarray): parameter, scaling factor used to
calculate the impact of root biomass on nutrient availability
bglivc (numpy.ndarray): state variable, carbon in belowground
live biomass
riint (numpy.ndarray): parameter, intercept used to calculate the
impact of root biomass on nutrient availability
availm (numpy.ndarray): derived, the sum of mineral nutrient in
soil layers accessible by this plant functional type
favail (numpy.ndarray): parameter, fraction of the nutrient
available each month to plants
crpstg (numpy.ndarray): state variable, nutrient in
retranslocation storage pool for the plant functional type
Returns:
eavail, the nutrient available to the plant functional type
"""
valid_mask = (
(rictrl != _IC_NODATA) &
(~numpy.isclose(bglivc, _SV_NODATA)) &
(riint != _IC_NODATA) &
(availm != _TARGET_NODATA) &
(favail != _IC_NODATA) &
(~numpy.isclose(crpstg, _SV_NODATA)))
rimpct = numpy.empty(rictrl.shape, dtype=numpy.float32)
rimpct[:] = _TARGET_NODATA
rimpct[valid_mask] = numpy.where(
((rictrl[valid_mask] * bglivc[valid_mask] * 2.5) > 33.),
1., 1. - riint[valid_mask] * numpy.exp(
-rictrl[valid_mask] * bglivc[valid_mask] * 2.5))
eavail = numpy.empty(rictrl.shape, dtype=numpy.float32)
eavail[:] = _TARGET_NODATA
eavail[valid_mask] = (
(availm[valid_mask] * favail[valid_mask] * rimpct[valid_mask]) +
crpstg[valid_mask])
return eavail
def add_symbiotic_fixed_N(eavail_prior, snfxmx, tgprod):
"""Add nitrogen fixed by the plant to nutrient available.
Some nitrogen may be fixed by the plant, and this must be added
to available mineral nitrogen. Nitrogen fixed by the plant is
calculated from total potential production and the maximum
rate of N fixation.
Parameters:
eavail_prior (numpy.ndarray): derived, mineral nitrogen available
to the plant functional type, calculated with calc_eavail()
snfxmx (numpy.ndarray): parameter, maximum rate of symbiotic
nitrogen fixation
tgprod (numpy.ndarray): derived, total above- and belowground
potential production (g biomass)
Returns:
eavail, total N available including N fixed by the plant
"""
valid_mask = (
(eavail_prior != _TARGET_NODATA) &
(snfxmx != _IC_NODATA) &
(tgprod != _TARGET_NODATA))
maxNfix = numpy.empty(eavail_prior.shape, dtype=numpy.float32)
maxNfix[:] = _TARGET_NODATA
maxNfix[valid_mask] = snfxmx[valid_mask] * (tgprod[valid_mask] / 2.5)
eavail = numpy.empty(eavail_prior.shape, dtype=numpy.float32)
eavail[:] = _TARGET_NODATA
eavail[valid_mask] = eavail_prior[valid_mask] + maxNfix[valid_mask]
return eavail
# temporary intermediate rasters for calculating available nutrient
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
param_val_dict = {}
for val in ['rictrl', 'riint']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for val in ['snfxmx_1']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
fill_val = pft_param_dict[val]
pygeoprocessing.new_raster_from_base(
site_index_path, target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['rictrl'],
sv_reg['bglivc_{}_path'.format(pft_i)],
param_val_dict['riint'],
availm_path, favail_path,
sv_reg['crpstg_{}_{}_path'.format(iel, pft_i)]]],
calc_eavail, eavail_path,
gdal.GDT_Float32, _TARGET_NODATA)
if iel == 1:
eavail_prior_path = os.path.join(temp_dir, 'eavail_prior.tif')
shutil.copyfile(eavail_path, eavail_prior_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
eavail_prior_path,
param_val_dict['snfxmx_1'],
tgprod_path]],
add_symbiotic_fixed_N, eavail_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _calc_nutrient_demand(
biomass_production_path, fraction_allocated_to_roots_path,
cercrp_min_above_path, cercrp_min_below_path, demand_path):
"""Calculate the demand of one nutrient by a plant functional type.
Demand is calculated from total biomass production, the fraction of biomass
production allocated to roots, and the minimum carbon/nutrient ratios of
above- and belowground live biomass. Lines 88-92 CropDynC.f and line
65, Nutrlm.f
Parameters:
biomass_production_path (string): path to raster giving total
biomass production
fraction_allocated_to_roots_path (string): path to raster giving
the fraction fo total biomass production allocated to roots
cercrp_min_above_path (string): path to raster giving the minimum
ratio of carbon to nutrient in aboveground live biomass
cercrp_min_below_path (string): path to raster giving the minimum
ratio of carbon to nutrient in belowground live biomass
Side effects:
modifies or creates the raster indicated by `demand_path`
Returns:
None
"""
def nutrient_demand_op(
biomass_production, root_fraction, cercrp_min_above,
cercrp_min_below):
"""Calculate nutrient demand.
Parameters:
biomass_production (numpy.ndarray): derived, total biomass
production
root_fraction (numpy.ndarray): derived, fraction of biomass
allocated to roots
cercrp_min_above (numpy.ndarray): derived, minimum carbon to
nutrient ratio of new aboveground live material
cercrp_min_below (numpy.ndarray): derived, minimum carbon to
nutrient ratio of new belowground live material
Returns:
demand_e, nutrient demand
"""
valid_mask = (
(biomass_production != _TARGET_NODATA) &
(root_fraction != _TARGET_NODATA) &
(cercrp_min_above != _TARGET_NODATA) &
(cercrp_min_above > 0) &
(cercrp_min_below > 0) &
(cercrp_min_below != _TARGET_NODATA))
demand_above = numpy.empty(root_fraction.shape, dtype=numpy.float32)
demand_above[:] = _TARGET_NODATA
demand_above[valid_mask] = (
((biomass_production[valid_mask] *
(1. - root_fraction[valid_mask])) / 2.5) *
(1. / cercrp_min_above[valid_mask]))
demand_below = numpy.empty(root_fraction.shape, dtype=numpy.float32)
demand_below[:] = _TARGET_NODATA
demand_below[valid_mask] = (
((biomass_production[valid_mask] *
(root_fraction[valid_mask])) / 2.5) *
(1. / cercrp_min_below[valid_mask]))
demand_e = numpy.empty(root_fraction.shape, dtype=numpy.float32)
demand_e[:] = _TARGET_NODATA
demand_e[valid_mask] = (
demand_above[valid_mask] + demand_below[valid_mask])
return demand_e
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
biomass_production_path, fraction_allocated_to_roots_path,
cercrp_min_above_path, cercrp_min_below_path]],
nutrient_demand_op, demand_path,
gdal.GDT_Float32, _TARGET_NODATA)
def calc_provisional_fracrc(
annual_precip, frtcindx, bgppa, bgppb, agppa, agppb,
cfrtcw_1, cfrtcw_2, cfrtcn_1, cfrtcn_2):
"""Calculate provisional fraction of carbon allocated to roots.
A temporary provisional fraction of carbon allocated to roots must be
calculated prior to calculating plant demand for N and P. The value
of this provisional fraction depends on whether the plant functional
type is modeled as a perennial plant or with the "Great Plains"
equation of Parton et al. 1987, "Analysis of factors controlling soil
organic matter levels in Great Plains grasslands", Soil Science
Society of America Journal. Lines 36-47 cropDynC.f
Parameters:
annual_precip (numpy.ndarray): derived, sum of monthly
precipitation over twelve months including the current month
frtcindx (numpy.ndarray): parameter, flag indicating whether
root:shoot allocation follows the Great Plains equation
(frtcindx=0) or as a perennial plant (frtcindx=1)
bgppa (numpy.ndarray): parameter, intercept in regression
estimating belowground production from annual precipitation
if frtcindx=0
bgppb (numpy.ndarray): parameter, slope in regression estimating
belowground production from annual precipitation if
frtcindx=0
agppa (numpy.ndarray): parameter, intercept in regression
estimating aboveground production from annual precipitation
if frtcindx=0
agppb (numpy.ndarray): parameter, slope in regression estimating
aboveground production from annual precipitation if
frtcindx=0
cfrtcw_1 (numpy.ndarray): parameter, maximum fraction of carbon
allocated to roots under maximum water stress if frtcindx=1
cfrtcw_2 (numpy.ndarray): parameter, minimum fraction of carbon
allocated to roots without water stress if frtcindx=1
cfrtcn_1 (numpy.ndarray): parameter, maximum fraction of carbon
allocated to roots under maximum nutrient stress if frtcindx=1
cfrtcn_2 (numpy.ndarray): parameter, minimum fraction of carbon
allocated to roots under no nutrient stress if frtcindx=1
Returns:
fracrc_p, provisional fraction of carbon allocated to roots
"""
valid_mask = (
(annual_precip != _TARGET_NODATA) &
(frtcindx != _IC_NODATA) &
(bgppa != _IC_NODATA))
rtsh = numpy.empty(annual_precip.shape, dtype=numpy.float32)
rtsh[:] = _TARGET_NODATA
rtsh[valid_mask] = (
(bgppa[valid_mask] +
annual_precip[valid_mask] * bgppb[valid_mask]) /
(agppa[valid_mask] + annual_precip[valid_mask] *
agppb[valid_mask]))
fracrc_p = numpy.empty(annual_precip.shape, dtype=numpy.float32)
fracrc_p[:] = _TARGET_NODATA
fracrc_p[valid_mask] = numpy.where(
frtcindx[valid_mask] == 0,
(1.0 / (1.0 / rtsh[valid_mask] + 1.0)),
((cfrtcw_1[valid_mask] + cfrtcw_2[valid_mask] +
cfrtcn_1[valid_mask] + cfrtcn_2[valid_mask]) / 4.0))
return fracrc_p
def calc_ce_ratios(
pramn_1_path, pramn_2_path, aglivc_path, biomax_path,
pramx_1_path, pramx_2_path, prbmn_1_path, prbmn_2_path,
prbmx_1_path, prbmx_2_path, annual_precip_path, pft_i, iel,
month_reg):
"""Calculate minimum and maximum carbon to nutrient ratios.
Minimum and maximum C/E ratios are used to calculate demand for a
nutrient by a plant functional type. This function calculates the
ratios for above- and belowground plant portions, for one plant
functional type and one nutrient. Fltce.f
Parameters:
pramn_1_path (string): path to raster containing the parameter
pramn_<iel>_1, the minimum aboveground ratio with zero biomass
pramn_2_path (string): path to raster containing the parameter
pramn_<iel>_2, the minimum aboveground ratio with biomass greater
than or equal to biomax
aglivc_path (string): path to raster containing carbon in
aboveground live biomass
biomax_path (string): path to raster containing the parameter
biomax, the biomass above which the ratio equals pramn_2
or pramx_2
pramx_1_path (string): path to raster containing the parameter
pramx_<iel>_1, the maximum aboveground ratio with zero biomass
pramx_2_path (string): path to raster containing the parameter
pramx_<iel>_2, the maximum aboveground ratio with biomass greater
than or equal to biomax
prbmn_1_path (string): path to raster containing the parameter
prbmn_<iel>_1, intercept of regression to predict minimum
belowground ratio from annual precipitation
prbmn_2_path (string): path to raster containing the parameter
prbmn_<iel>_2, slope of regression to predict minimum belowground
ratio from annual precipitation
prbmx_1_path (string): path to raster containing the parameter
prbmx_<iel>_1, intercept of regression to predict maximum
belowground ratio from annual precipitation
prbmx_2_path (string): path to raster containing the parameter
prbmx_<iel>_2, slope of regression to predict maximum belowground
ratio from annual precipitation
annual_precip_path (string): path to annual precipitation raster
pft_i (int): plant functional type index
iel (int): nutrient index (iel=1 indicates N, iel=2 indicates P)
month_reg (dict): map of key, path pairs giving paths to
intermediate calculated values that are shared between
submodels
Side effects:
creates the rasters indicated by
`month_reg['cercrp_min_above_<iel>_<pft_i>']`,
`month_reg['cercrp_max_above_<iel>_<pft_i>']`,
`month_reg['cercrp_min_below_<iel>_<pft_i>']`,
`month_reg['cercrp_max_below_<iel>_<pft_i>']`,
Returns:
None
"""
def calc_above_ratio(pra_1, pra_2, aglivc, biomax):
"""Calculate carbon to nutrient ratio for aboveground material.
Parameters:
pra_1 (numpy.ndarray): parameter, minimum or maximum ratio
with zero biomass
pra_2 (numpy.ndarray): parameter, minimum or maximum ratio
with biomass greater than or equal to biomax
aglivc (numpy.ndarray): state variable, carbon in aboveground
live material
biomax (numpy:ndarray): parameter, biomass above which the
ratio equals pra_2
Returns:
cercrp_above, carbon to nutrient ratio for aboveground
material
"""
valid_mask = (
(pra_1 != _IC_NODATA) &
(pra_2 != _IC_NODATA) &
(~numpy.isclose(aglivc, _SV_NODATA)) &
(biomax != _IC_NODATA))
cercrp_above = numpy.empty(pra_1.shape, dtype=numpy.float32)
cercrp_above[:] = _TARGET_NODATA
cercrp_above[valid_mask] = numpy.minimum(
(pra_1[valid_mask] + (pra_2[valid_mask] - pra_1[valid_mask]) *
2.5 * aglivc[valid_mask] / biomax[valid_mask]),
pra_2[valid_mask])
return cercrp_above
def calc_below_ratio(prb_1, prb_2, annual_precip):
"""Calculate carbon to nutrient ratio for belowground material.
Parameters:
prb_1 (numpy.ndarray): parameter, intercept of regression
to predict ratio from annual precipitation
prb_2 (numpy.ndarray): parameter, slope of regression to
predict ratio from annual precipitation
annual_precip (numpy.ndarray): derived, precipitation in twelve
months including the current month
Returns:
cercrp_below, carbon to nutrient ratio for belowground
material
"""
valid_mask = (
(prb_1 != _IC_NODATA) &
(prb_2 != _IC_NODATA) &
(annual_precip != _TARGET_NODATA))
cercrp_below = numpy.empty(prb_1.shape, dtype=numpy.float32)
cercrp_below[:] = _TARGET_NODATA
cercrp_below[valid_mask] = (
prb_1[valid_mask] +
(prb_2[valid_mask] * annual_precip[valid_mask]))
return cercrp_below
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
pramn_1_path, pramn_2_path, aglivc_path, biomax_path]],
calc_above_ratio,
month_reg['cercrp_min_above_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
pramx_1_path, pramx_2_path, aglivc_path, biomax_path]],
calc_above_ratio,
month_reg['cercrp_max_above_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prbmn_1_path, prbmn_2_path, annual_precip_path]],
calc_below_ratio,
month_reg['cercrp_min_below_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prbmx_1_path, prbmx_2_path, annual_precip_path]],
calc_below_ratio,
month_reg['cercrp_max_below_{}_{}'.format(iel, pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
def calc_revised_fracrc(
frtcindx_path, fracrc_p_path, totale_1_path, totale_2_path,
demand_1_path, demand_2_path, h2ogef_1_path, cfrtcw_1_path,
cfrtcw_2_path, cfrtcn_1_path, cfrtcn_2_path, fracrc_r_path):
"""
Calculate revised fraction of carbon allocated to roots.
The revised fraction of carbon allocated to roots includes the
impacts of water and nutrient limitation. The method of the
revised calculation depends on whether the plant functional
type is modeled as a perennial plant or with the "Great Plains"
equation of Parton et al. 1987, "Analysis of factors controlling soil
organic matter levels in Great Plains grasslands", Soil Science
Society of America Journal. Lines 96-104, cropDynC.f, froota.f
Parameters:
frtcindx_path (string): path to raster containing the parameter
frtcindx
fracrc_p_path (string): path to raster containing provisional
fraction of carbon allocated to roots
totale_1_path (string): path to raster containing total available
nitrogen
totale_2_path (string): path to raster containing total available
phosphorus
demand_1_path (string): path to raster containing nitrogen demand
demand_2_path (string): path to raster containing phosphorus demand
h2ogef_1_path (string): path to raster containing the limiting
effect of water availability on growth
cfrtcw_1_path (string): path to raster containing the parameter
cfrtcw_1
cfrtcw_2_path (string): path to raster containing the parameter
cfrtcw_2
cfrtcn_1_path (string): path to raster containing the parameter
cfrtcn_1
cfrtcn_2_path (string): path to raster containing the parameter
cfrtcn_2
fracrc_r_path (string): path to raster that should contain the
result, revised fraction of carbon allocated to roots
Side effects:
creates the raster indicated by `fracrc_r_path`
Returns:
None
"""
def calc_a2drat(totale, demand):
"""Calculate the ratio of available nutrient to nutrient demand.
The ratio of nutrient available to demand for the nutrient is
restricted to be between 0 and 1.
Parameters:
totale (numpy.ndarray): derived, nutrient available
demand (numpy.ndarray): derived, demand for the nutrient
Returns:
a2drat, the ratio of available nutrient to demand, restricted
to be between 0 and 1
"""
valid_mask = (
(totale != _TARGET_NODATA) &
(demand != _TARGET_NODATA))
a2drat = numpy.empty(totale.shape, dtype=numpy.float32)
a2drat[:] = _TARGET_NODATA
demand_mask = ((demand > 0) & valid_mask)
a2drat[valid_mask] = 1.
a2drat[demand_mask] = numpy.clip(
totale[demand_mask] / demand[demand_mask], 0., 1.)
return a2drat
def calc_perennial_fracrc(
h2ogef, cfrtcw_1, cfrtcw_2, a2drat_1, a2drat_2, cfrtcn_1,
cfrtcn_2):
"""Calculate fraction C allocated to roots for a perennial plant.
The fraction of carbon allocated to roots is determined by
water availability, described by h2ogef, and nutrient availability,
described by a2drat_1 for nitrogen and a2drat_2 for phosphorus.
Lines 114-125 froota.f
Parameters:
h2ogef (numpy.ndarray): derived, the limiting factor of water
availability on growth
cfrtcw_1 (numpy.ndarray): parameter, the maximum fraction of
carbon allocated to roots with maximum water stress
cfrtcw_2 (numpy.ndarray): parameter, the minimum fraction of
carbon allocated to roots with no water stress
a2drat_1 (numpy.ndarray): derived, the ratio of available
nitrogen to nitrogen demand, restricted to be between 0
and 1
a2drat_2 (numpy.ndarray): derived, the ratio of available
phosphorus to phosphorus demand, restricted to be between
0 and 1
cfrtcn_1 (numpy.ndarray): parameter, maximum fraction of
carbon allocated to roots with maximum nutrient stress
cfrtcn_2 (numpy.ndarray): parameter, minimum fraction of
carbon allocated to roots with no nutrient stress
Returns:
fracrc_perennial, revised fraction of C allocated to roots for
a perennial plant
"""
valid_mask = (
(h2ogef != _TARGET_NODATA) &
(cfrtcw_1 != _IC_NODATA) &
(cfrtcw_2 != _IC_NODATA) &
(a2drat_1 != _TARGET_NODATA) &
(a2drat_2 != _TARGET_NODATA) &
(cfrtcn_1 != _IC_NODATA) &
(cfrtcn_2 != _IC_NODATA))
h2oeff = numpy.empty(h2ogef.shape, dtype=numpy.float32)
h2oeff[:] = _TARGET_NODATA
h2oeff[valid_mask] = (
(cfrtcw_2[valid_mask] - cfrtcw_1[valid_mask]) *
(h2ogef[valid_mask] - 1.) + cfrtcw_2[valid_mask])
ntreff_1 = numpy.empty(h2ogef.shape, dtype=numpy.float32)
ntreff_1[:] = _TARGET_NODATA
ntreff_1[valid_mask] = (
(cfrtcn_2[valid_mask] - cfrtcn_1[valid_mask]) *
(a2drat_1[valid_mask] - 1.0) + cfrtcn_2[valid_mask])
ntreff_2 = numpy.empty(h2ogef.shape, dtype=numpy.float32)
ntreff_2[:] = _TARGET_NODATA
ntreff_1[valid_mask] = (
(cfrtcn_2[valid_mask] - cfrtcn_1[valid_mask]) *
(a2drat_2[valid_mask] - 1.0) + cfrtcn_2[valid_mask])
ntreff = numpy.empty(h2ogef.shape, dtype=numpy.float32)
ntreff[:] = _TARGET_NODATA
ntreff[valid_mask] = numpy.maximum(
ntreff_1[valid_mask], ntreff_2[valid_mask])
fracrc_perennial = numpy.empty(
h2ogef.shape, dtype=numpy.float32)
fracrc_perennial[:] = _TARGET_NODATA
fracrc_perennial[valid_mask] = numpy.minimum(
numpy.maximum(h2oeff[valid_mask], ntreff[valid_mask]), 0.99)
return fracrc_perennial
def revised_fracrc_op(frtcindx, fracrc_p, fracrc_perennial):
"""Calculate revised fraction of carbon allocated to roots.
The revised fraction of carbon allocated to roots is calculated
according to the parameter frtcindx. If frtcindx=0 (use the "Great
Plains equation"), the revised fraction is equal to the provisional
fraction. If frtcindx=1 (a perennial plant), the revised fraction
is calculated from water and nutrient stress.
Parameters:
frtcindx (numpy.ndarray): parameter, indicates whether revised
fraction of carbon allocated to roots should follow the
"Great Plains equation" or the algorithm for a perennial
plant
fracrc_p (numpy.ndarray): derived, provisional fraction of
carbon allocated to roots
fracrc_perennial (numpy.ndarray): derived, fraction of
carbon allocated to roots for a perennial plant
Returns:
fracrc_r, revised fraction of carbon allocated to roots
"""
valid_mask = (
(frtcindx != _IC_NODATA) &
(fracrc_p != _TARGET_NODATA) &
(fracrc_perennial != _TARGET_NODATA))
fracrc_r = numpy.empty(frtcindx.shape, dtype=numpy.float32)
fracrc_r[:] = _TARGET_NODATA
fracrc_r[valid_mask] = numpy.where(
frtcindx[valid_mask] == 0, fracrc_p[valid_mask],
fracrc_perennial[valid_mask])
return fracrc_r
# temporary intermediate rasters for calculating revised fracrc
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in ['a2drat_1', 'a2drat_2', 'fracrc_perennial']:
temp_val_dict[val] = os.path.join(
temp_dir, '{}.tif'.format(val))
pygeoprocessing.raster_calculator(
[(path, 1) for path in [totale_1_path, demand_1_path]],
calc_a2drat, temp_val_dict['a2drat_1'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [totale_2_path, demand_2_path]],
calc_a2drat, temp_val_dict['a2drat_2'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
h2ogef_1_path, cfrtcw_1_path, cfrtcw_2_path,
temp_val_dict['a2drat_1'], temp_val_dict['a2drat_2'],
cfrtcn_1_path, cfrtcn_2_path]],
calc_perennial_fracrc, temp_val_dict['fracrc_perennial'],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
frtcindx_path, fracrc_p_path,
temp_val_dict['fracrc_perennial']]],
revised_fracrc_op, fracrc_r_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def grazing_effect_on_aboveground_production(tgprod, fracrc, flgrem, grzeff):
"""Adjust aboveground production with the impact of grazing.
Removal of biomass by herbivores directly impacts potential
aboveground production according to the amount of biomass removed
and the parameter grzeff, which acts as a switch to determine the
effect. If grzeff=0, 3, or 4, aboveground production is not
changed. If grzeff=1 or 6, production decreases linearly with
biomass removed; if grzeff=2 or 5, biomass removed has a quadratic
impact on production. Grazrst.f
Parameters:
tgprod (numpy.ndarray): derived, total potential biomass
production restricted by water and nutrient availability
fracrc (numpy.ndarray): derived, fraction of carbon allocated
to roots according to water and nutrient availability
flgrem (numpy.ndarray): derived, fraction of live biomass
removed by grazing in previous monthly step
grzeff (numpy.ndarray): parameter, the effect of defoliation on
production and root:shoot ratio
Returns:
agprod, aboveground production impacted by grazing
"""
valid_mask = (
(tgprod != _TARGET_NODATA) &
(fracrc != _TARGET_NODATA) &
(flgrem != _TARGET_NODATA) &
(grzeff != _IC_NODATA))
agprod_prior = numpy.empty(tgprod.shape, dtype=numpy.float32)
agprod_prior[:] = _TARGET_NODATA
agprod_prior[valid_mask] = (
tgprod[valid_mask] * (1. - fracrc[valid_mask]))
linear_effect = numpy.empty(tgprod.shape, dtype=numpy.float32)
linear_effect[:] = _TARGET_NODATA
linear_effect[valid_mask] = numpy.maximum(
(1. - (2.21*flgrem[valid_mask])) * agprod_prior[valid_mask],
0.02)
quadratic_effect = numpy.empty(tgprod.shape, dtype=numpy.float32)
quadratic_effect[:] = _TARGET_NODATA
quadratic_effect[valid_mask] = (
(1. + 2.6*flgrem[valid_mask] -
(5.83*(numpy.power(flgrem[valid_mask], 2)))) *
agprod_prior[valid_mask])
quadratic_effect[valid_mask] = numpy.maximum(
quadratic_effect[valid_mask], 0.02)
no_effect_mask = (valid_mask & numpy.isin(grzeff, [0, 3, 4]))
linear_mask = (valid_mask & numpy.isin(grzeff, [1, 6]))
quadratic_mask = (valid_mask & numpy.isin(grzeff, [2, 5]))
agprod = numpy.empty(tgprod.shape, dtype=numpy.float32)
agprod[:] = _TARGET_NODATA
agprod[no_effect_mask] = agprod_prior[no_effect_mask]
agprod[linear_mask] = linear_effect[linear_mask]
agprod[quadratic_mask] = quadratic_effect[quadratic_mask]
return agprod
def grazing_effect_on_root_shoot(fracrc, flgrem, grzeff, gremb):
"""Adjust root:shoot ratio according to the impact of grazing.
Removal of biomass by herbivores directly impacts the root:shoot
ratio of production according to the amount of biomass removed and
the parameter grzeff, which acts as a switch to determine the
effect. If grzeff=0 or 1, the root:shoot ratio is not changed.
If grzeff=2 or 3, biomass removed has a quadratic impact on the
root:shoot ratio. If grzeff=4, 5, or 6, biomass removed has a
linear effect on the root:shoot ratio. The parameter gremb
multiplies the linear impact of grazing when grzeff=4, 5 or 6.
Grzrst.f
Parameters:
fracrc (numpy.ndarray): derived, fraction of carbon allocated
to roots according to water and nutrient availability
flgrem (numpy.ndarray): derived, fraction of live biomass
removed by grazing in previous monthly step
grzeff (numpy.ndarray): parameter, the effect of defoliation on
production and root:shoot ratio
grzemb (numpy.ndarray): parameter, grazing effect multiplier
Returns:
rtsh, root:shoot ratio impacted by grazing
"""
valid_mask = (
(fracrc != _TARGET_NODATA) &
(flgrem != _TARGET_NODATA) &
(grzeff != _IC_NODATA) &
(gremb != _IC_NODATA))
rtsh_prior = numpy.empty(fracrc.shape, dtype=numpy.float32)
rtsh_prior[:] = _TARGET_NODATA
rtsh_prior[valid_mask] = (
fracrc[valid_mask] / (1. - fracrc[valid_mask]))
quadratic_effect = numpy.empty(fracrc.shape, dtype=numpy.float32)
quadratic_effect[:] = _TARGET_NODATA
quadratic_effect[valid_mask] = numpy.maximum(
rtsh_prior[valid_mask] + 3.05 * flgrem[valid_mask] -
11.78 * numpy.power(flgrem[valid_mask], 2),
0.01)
linear_effect = numpy.empty(fracrc.shape, dtype=numpy.float32)
linear_effect[:] = _TARGET_NODATA
linear_effect[valid_mask] = numpy.maximum(
1. - (flgrem[valid_mask] * gremb[valid_mask]),
0.01)
no_effect_mask = (valid_mask & numpy.isin(grzeff, [0, 1]))
quadratic_mask = (valid_mask & numpy.isin(grzeff, [2, 3]))
linear_mask = (valid_mask & numpy.isin(grzeff, [4, 5, 6]))
rtsh = numpy.empty(fracrc.shape, dtype=numpy.float32)
rtsh[:] = _TARGET_NODATA
rtsh[no_effect_mask] = rtsh_prior[no_effect_mask]
rtsh[quadratic_mask] = quadratic_effect[quadratic_mask]
rtsh[linear_mask] = linear_effect[linear_mask]
return rtsh
def calc_tgprod_final(rtsh, agprod):
"""Calculate final total potential production.
Final total potential production is calculated from aboveground
production impacted by grazing and the final root:shoot ratio
impacted by grazing.
Parameters:
rtsh (numpy.ndarray): derived, final root:shoot ratio impacted
by grazing
agprod (numpy.ndarray): derived, final aboveground potential
production impacted by grazing
Returns:
tgprod, final total potential production
"""
valid_mask = (
(rtsh != _TARGET_NODATA) &
(agprod != _TARGET_NODATA))
tgprod = numpy.empty(rtsh.shape, dtype=numpy.float32)
tgprod[:] = _TARGET_NODATA
tgprod[valid_mask] = (
agprod[valid_mask] + (rtsh[valid_mask] * agprod[valid_mask]))
return tgprod
def calc_final_tgprod_rtsh(
tgprod_pot_prod_path, fracrc_path, flgrem_path, grzeff_path,
gremb_path, tgprod_path, rtsh_path):
"""Calculate final potential production and root:shoot ratio.
Final potential production and root:shoot ratio include the impact of
grazing. First calculate final aboveground production including the
impact of grazing; then calculate rtsh, the final root:shoot ratio
including the impact of grazing; then calculate tgprod, final total
potential production, from final aboveground production and final
root:shoot ratio. Grazrst.f
Parameters:
tgprod_pot_prod_path (string): path to raster containing total
potential biomass production restricted by water and nutrient
availability, prior to effects of grazing
fracrc_path (string): path to raster containing the fraction of
carbon production allocated to roots according to restriction
by water and nutrient availability, prior to effects of
grazing
flgrem_path (string): path to raster containing the fraction of
live aboveground biomass removed by herbivores according to
diet selection in the previous step
grzeff_path (string): path to raster containing the parameter
grzeff, the effect of defolation on production and root:shoot
ratio
gremb_path (string): path to raster containing the parameter
gremb, the grazing effect multiplier
tgprod_path (string): path to raster containing final total
potential production (g biomass)
rtsh_path (string): path to raster containing final root:shoot
ratio of potential production
Side effects:
creates the raster indicated by tgprod_path
creates the raster indicated by rtsh_path
Returns:
None
"""
# temporary intermediate rasters for grazing effect
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
agprod_path = os.path.join(temp_dir, 'agprod.tif')
# grazing effect on aboveground production
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tgprod_pot_prod_path, fracrc_path, flgrem_path,
grzeff_path]],
grazing_effect_on_aboveground_production,
agprod_path, gdal.GDT_Float32, _TARGET_NODATA)
# grazing effect on final root:shoot ratio
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
fracrc_path, flgrem_path, grzeff_path, gremb_path]],
grazing_effect_on_root_shoot, rtsh_path,
gdal.GDT_Float32, _TARGET_NODATA)
# final total potential production
pygeoprocessing.raster_calculator(
[(path, 1) for path in [rtsh_path, agprod_path]],
calc_tgprod_final, tgprod_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _root_shoot_ratio(
aligned_inputs, site_param_table, current_month, pft_id_set,
veg_trait_table, prev_sv_reg, year_reg, month_reg):
"""Calculate final potential production and root:shoot ratio.
Final potential biomass production and root:shoot ratio is calculated
according to nutrient availability and demand for the nutrient, and the
impact of defoliation by herbivores. CropDynC.f
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including the site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
current_month (int): month of the year, such that current_month=1
indicates January
pft_id_set (set): set of integers identifying plant functional types
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
year_reg (dict): map of key, path pairs giving paths to rasters that
are modified once per year, including annual precipitation
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
Side effects:
creates the raster indicated by
`month_reg['tgprod_<PFT>']`, total potential production (g biomass)
for each plant functional type (PFT)
creates the raster indicated by `month_reg['rtsh_<PFT>']` for each
plant functional type (PFT)
Returns:
None
"""
# if growth does not occur this month for all PFTs,
# skip the rest of the function
do_PFT = []
for pft_i in pft_id_set:
# growth occurs in growth months and when senescence not scheduled
do_growth = (
current_month != veg_trait_table[pft_i]['senescence_month'] and
str(current_month) in veg_trait_table[pft_i]['growth_months'])
if do_growth:
do_PFT.append(pft_i)
if not do_PFT:
return
# temporary intermediate rasters for root:shoot submodel
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for pft_i in do_PFT:
for val in ['fracrc_p', 'fracrc', 'availm']:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
for iel in [1, 2]:
for val in ['eavail', 'demand']:
temp_val_dict[
'{}_{}_{}'.format(val, iel, pft_i)] = os.path.join(
temp_dir, '{}_{}_{}.tif'.format(val, iel, pft_i))
# temporary parameter rasters for root:shoot submodel
param_val_dict = {}
# site-level parameters
for val in [
'bgppa', 'bgppb', 'agppa', 'agppb', 'favail_1', 'favail_4',
'favail_5', 'favail_6']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# PFT-level parameters
for pft_i in do_PFT:
for val in [
'frtcindx', 'cfrtcw_1', 'cfrtcw_2', 'cfrtcn_1', 'cfrtcn_2',
'biomax', 'cfrtcw_1', 'cfrtcw_2', 'cfrtcn_1', 'cfrtcn_2',
'grzeff', 'gremb']:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict['{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path, gdal.GDT_Float32,
[_IC_NODATA], fill_value_list=[fill_val])
for val in [
'pramn_1_1', 'pramn_1_2', 'pramx_1_1', 'pramx_1_2',
'prbmn_1_1', 'prbmn_1_2', 'prbmx_1_1', 'prbmx_1_2',
'pramn_2_1', 'pramn_2_2', 'pramx_2_1', 'pramx_2_2',
'prbmn_2_1', 'prbmn_2_2', 'prbmx_2_1', 'prbmx_2_2']:
target_path = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict[
'{}_{}'.format(val, pft_i)] = target_path
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], target_path,
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
# the parameter favail_2 must be calculated from current mineral N in
# surface layer
param_val_dict['favail_2'] = os.path.join(temp_dir, 'favail_2.tif')
_calc_favail_P(prev_sv_reg, param_val_dict)
for pft_i in do_PFT:
# fracrc_p, provisional fraction of C allocated to roots
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
year_reg['annual_precip_path'],
param_val_dict['frtcindx_{}'.format(pft_i)],
param_val_dict['bgppa'],
param_val_dict['bgppb'],
param_val_dict['agppa'],
param_val_dict['agppb'],
param_val_dict['cfrtcw_1_{}'.format(pft_i)],
param_val_dict['cfrtcw_2_{}'.format(pft_i)],
param_val_dict['cfrtcn_1_{}'.format(pft_i)],
param_val_dict['cfrtcn_2_{}'.format(pft_i)]]],
calc_provisional_fracrc,
temp_val_dict['fracrc_p_{}'.format(pft_i)],
gdal.GDT_Float32, _TARGET_NODATA)
for iel in [1, 2]:
# persistent ratios used here and in plant growth submodel
calc_ce_ratios(
param_val_dict['pramn_{}_1_{}'.format(iel, pft_i)],
param_val_dict['pramn_{}_2_{}'.format(iel, pft_i)],
prev_sv_reg['aglivc_{}_path'.format(pft_i)],
param_val_dict['biomax_{}'.format(pft_i)],
param_val_dict['pramx_{}_1_{}'.format(iel, pft_i)],
param_val_dict['pramx_{}_2_{}'.format(iel, pft_i)],
param_val_dict['prbmn_{}_1_{}'.format(iel, pft_i)],
param_val_dict['prbmn_{}_2_{}'.format(iel, pft_i)],
param_val_dict['prbmx_{}_1_{}'.format(iel, pft_i)],
param_val_dict['prbmx_{}_2_{}'.format(iel, pft_i)],
year_reg['annual_precip_path'], pft_i, iel, month_reg)
# sum of mineral nutrient in accessible soil layers
_calc_avail_mineral_nutrient(
veg_trait_table[pft_i], prev_sv_reg, iel,
temp_val_dict['availm_{}'.format(pft_i)])
# eavail_iel, available nutrient
_calc_available_nutrient(
pft_i, iel, veg_trait_table[pft_i], prev_sv_reg,
site_param_table, aligned_inputs['site_index'],
temp_val_dict['availm_{}'.format(pft_i)],
param_val_dict['favail_{}'.format(iel)],
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['eavail_{}_{}'.format(iel, pft_i)])
# demand_iel, demand for the nutrient
_calc_nutrient_demand(
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['fracrc_p_{}'.format(pft_i)],
month_reg['cercrp_min_above_{}_{}'.format(iel, pft_i)],
month_reg['cercrp_min_below_{}_{}'.format(iel, pft_i)],
temp_val_dict['demand_{}_{}'.format(iel, pft_i)])
# revised fraction of carbon allocated to roots
calc_revised_fracrc(
param_val_dict['frtcindx_{}'.format(pft_i)],
temp_val_dict['fracrc_p_{}'.format(pft_i)],
temp_val_dict['eavail_1_{}'.format(pft_i)],
temp_val_dict['eavail_2_{}'.format(pft_i)],
temp_val_dict['demand_1_{}'.format(pft_i)],
temp_val_dict['demand_2_{}'.format(pft_i)],
month_reg['h2ogef_1_{}'.format(pft_i)],
param_val_dict['cfrtcw_1_{}'.format(pft_i)],
param_val_dict['cfrtcw_2_{}'.format(pft_i)],
param_val_dict['cfrtcn_1_{}'.format(pft_i)],
param_val_dict['cfrtcn_2_{}'.format(pft_i)],
temp_val_dict['fracrc_{}'.format(pft_i)])
# final potential production and root:shoot ratio accounting for
# impacts of grazing
calc_final_tgprod_rtsh(
month_reg['tgprod_pot_prod_{}'.format(pft_i)],
temp_val_dict['fracrc_{}'.format(pft_i)],
month_reg['flgrem_{}'.format(pft_i)],
param_val_dict['grzeff_{}'.format(pft_i)],
param_val_dict['gremb_{}'.format(pft_i)],
month_reg['tgprod_{}'.format(pft_i)],
month_reg['rtsh_{}'.format(pft_i)])
# clean up temporary files
shutil.rmtree(temp_dir)
def _snow(
site_index_path, site_param_table, precip_path, tave_path,
max_temp_path, min_temp_path, prev_snow_path, prev_snlq_path,
current_month, snowmelt_path, snow_path, snlq_path,
inputs_after_snow_path, pet_rem_path):
"""Account for precipitation as snow and snowmelt from snowpack.
Determine whether precipitation falls as snow. Track the fate of
new and existing snowpack including evaporation and melting. Track the
the remaining snowpack and liquid in snow and potential
evapotranspiration remaining after evaporation of snow. Snowcent.f
Parameters:
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
precip_path (string): path to raster containing precipitation for the
current month
tave_path (string): path to raster containing average temperature for
the current month
max_temp_path (string): path to raster containing maximum temperature
for the current month
min_temp_path (string): path to raster containing minimum temperature
for the current month
prev_snow_path (string): path to raster containing current snowpack
prev_snlq_path (string): path to raster containing current liquid in
snow
current_month (int): current month of the year, such that month=0
indicates January
snow_path (string): path to raster to contain modified snowpack
snlq_path (string): path to raster to contain modified liquid in snow
inputs_after_snow_path (string): path to raster containing water inputs
to the system after accounting for snow
pet_rem_path (string): path to raster containing potential
evapotranspiration remaining after any evaporation of snow
Side effects:
creates the raster indicated by `snowmelt_path`
creates the raster indicated by `snow_path`
creates the raster indicated by `snlq_path`
creates the raster indicated by `inputs_after_snow_path`
creates the raster indicated by `pet_rem_path`
Returns:
None
"""
def calc_snow_moisture(return_type):
"""Calculate change in snow, pet, snow liquid, and moisture inputs.
Record changes in snowpack, liquid in snow, potential
evapotranspiration energy, and liquid draining into soil from snow.
Parameters:
return_type (string): flag indicating whether modified snowpack,
modified liquid in snow, modified potential evapotranspiration,
or soil moisture inputs after snow should be returned
Returns:
the function `_calc_snow_moisture`
"""
def _calc_snow_moisture(
tave, precip, snow, snlq, pet, tmelt_1, tmelt_2, shwave):
"""Calculate the fate of moisture from snow.
Calculate new snowfall or rain on snow. Calculate direct
evaporation of snow and consumption of potential
evapotranspiration energy. Calculate snowmelt and liquid draining
from snow into the soil.
Parameters:
tave (numpy.ndarray): derived, average temperature
precip (numpy.ndarray): input, precipitation for this month
snow (numpy.ndarray): derived, existing snowpack prior to new
snowfall
snlq (numpy.ndarray): derived, existing liquid in snowpack
pet (numpy.ndarray): derived, potential evapotranspiration
tmelt_1 (numpy.ndarray): parameter, minimum temperature above
which snow will melt
tmelt_2 (numpy.ndarray): parameter, ratio between degrees above
the minimum temperature and cm of snow that will melt
shwave (numpy.ndarray): derived, shortwave radiation outside
the atmosphere
Returns:
snowmelt if return_type is 'snowmelt'
snow_revised if return_type is 'snow'
snlq_revised if return_type is 'snlq'
pet_revised if return_type is 'pet'
inputs_after_snow if return_type is 'inputs_after_snow'
"""
valid_mask = (
(tave != _IC_NODATA) &
(~numpy.isclose(precip, precip_nodata)) &
(~numpy.isclose(snow, _SV_NODATA)) &
(~numpy.isclose(snlq, _SV_NODATA)) &
(pet != _TARGET_NODATA) &
(tmelt_1 != _IC_NODATA) &
(tmelt_2 != _IC_NODATA) &
(shwave != _TARGET_NODATA))
inputs_after_snow = numpy.empty(precip.shape, dtype=numpy.float32)
inputs_after_snow[:] = _TARGET_NODATA
inputs_after_snow[valid_mask] = precip[valid_mask]
snowfall_mask = (valid_mask & (tave <= 0))
snow[snowfall_mask] = (snow[snowfall_mask] + precip[snowfall_mask])
inputs_after_snow[snowfall_mask] = 0.
rain_on_snow_mask = (
(valid_mask) &
(tave > 0) &
(snow > 0))
snlq[rain_on_snow_mask] = (
snlq[rain_on_snow_mask] + precip[rain_on_snow_mask])
inputs_after_snow[rain_on_snow_mask] = 0.
snowtot = numpy.zeros(snow.shape, dtype=numpy.float32)
snowtot[valid_mask] = numpy.maximum(
snow[valid_mask] + snlq[valid_mask], 0)
evap_mask = (valid_mask & (snowtot > 0.))
evsnow = numpy.zeros(snow.shape, dtype=numpy.float32)
evsnow[evap_mask] = numpy.minimum(
snowtot[evap_mask], pet[evap_mask] * 0.87)
snow_revised = numpy.empty(snow.shape, dtype=numpy.float32)
snow_revised[:] = _TARGET_NODATA
snow_revised[valid_mask] = snow[valid_mask]
snow_revised[evap_mask] = numpy.maximum(
snow[evap_mask] - evsnow[evap_mask] *
(snow[evap_mask] / snowtot[evap_mask]), 0.)
snlq_revised = numpy.zeros(snow.shape, dtype=numpy.float32)
snlq_revised[valid_mask] = snlq[valid_mask]
snlq_revised[evap_mask] = numpy.maximum(
snlq[evap_mask] - evsnow[evap_mask] *
(snlq[evap_mask] / snowtot[evap_mask]), 0.)
pet_revised = numpy.empty(snow.shape, dtype=numpy.float32)
pet_revised[:] = _TARGET_NODATA
pet_revised[valid_mask] = pet[valid_mask]
pet_revised[evap_mask] = numpy.maximum(
(pet[evap_mask] - evsnow[evap_mask] / 0.87), 0.)
melt_mask = (valid_mask & (tave >= tmelt_1))
snowmelt = numpy.zeros(snow.shape, dtype=numpy.float32)
snowmelt[melt_mask] = numpy.clip(
tmelt_2[melt_mask] * (tave[melt_mask] - tmelt_1[melt_mask]) *
shwave[melt_mask], 0., snow_revised[melt_mask])
snow_revised[melt_mask] = (
snow_revised[melt_mask] - snowmelt[melt_mask])
snlq_revised[melt_mask] = (
snlq_revised[melt_mask] + snowmelt[melt_mask])
drain_mask = (melt_mask & (snlq_revised > 0.5 * snow_revised))
inputs_after_snow[drain_mask] = (
snlq_revised[drain_mask] - 0.5 * snow_revised[drain_mask])
snlq_revised[drain_mask] = (
snlq_revised[drain_mask] - inputs_after_snow[drain_mask])
if return_type == 'snowmelt':
return snowmelt
elif return_type == 'snow':
return snow_revised
elif return_type == 'snlq':
return snlq_revised
elif return_type == 'pet':
return pet_revised
else:
return inputs_after_snow
return _calc_snow_moisture
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in ['shwave', 'pet']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
for val in ['tmelt_1', 'tmelt_2', 'fwloss_4']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for (
site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path, gdal.GDT_Float32,
_IC_NODATA)
max_temp_nodata = pygeoprocessing.get_raster_info(
max_temp_path)['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
min_temp_path)['nodata'][0]
precip_nodata = pygeoprocessing.get_raster_info(
precip_path)['nodata'][0]
# solar radiation outside the atmosphere
_shortwave_radiation(precip_path, current_month, temp_val_dict['shwave'])
# pet, reference evapotranspiration modified by fwloss parameter
_reference_evapotranspiration(
max_temp_path, min_temp_path, temp_val_dict['shwave'],
param_val_dict['fwloss_4'], temp_val_dict['pet'])
# calculate snowmelt
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture('snowmelt'), snowmelt_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate change in snow
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("snow"), snow_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate change in liquid in snow
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("snlq"), snlq_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate change in potential evapotranspiration energy
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("pet"), pet_rem_path,
gdal.GDT_Float32, _TARGET_NODATA)
# calculate soil moisture inputs draining from snow after snowmelt
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tave_path, precip_path, prev_snow_path,
prev_snlq_path, temp_val_dict['pet'],
param_val_dict['tmelt_1'], param_val_dict['tmelt_2'],
temp_val_dict['shwave']]],
calc_snow_moisture("inputs_after_snow"), inputs_after_snow_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def _calc_aboveground_live_biomass(sum_aglivc, sum_tgprod):
"""Calculate aboveground live biomass for purposes of soil water.
Live biomass impacts loss of moisture inputs through canopy
interception and evapotranspiration. Because soil moisture is computed
after potential production, but before actual growth of plants, some of
the predicted growth in biomass (i.e., tgprod) is added here to
existing standing live biomass (i.e., aglivc * 2.5; line 80,
potprod.f, in Century).
Parameters:
sum_aglivc (numpy.ndarray): the sum of aglivc across plant
functional types (pft), weighted by % cover of the pft
sum_tgprod (numpy.ndarray): sum of tgprod, potential production
limited by soil water, nutrient availability, and grazing,
across pfts weighted by % cover of the pft
Returns:
aliv, aboveground live biomass for soil water submodel
"""
valid_mask = (
(sum_aglivc != _TARGET_NODATA) &
(sum_tgprod != _TARGET_NODATA))
aliv = numpy.empty(sum_aglivc.shape, dtype=numpy.float32)
aliv[:] = _TARGET_NODATA
aliv[valid_mask] = (
sum_aglivc[valid_mask] * 2.5 + (0.25 * sum_tgprod[valid_mask]))
return aliv
def _calc_standing_biomass(aliv, sum_stdedc):
"""Calculate total aboveground standing biomass for soil water.
Total standing biomass impacts loss of moisture inputs by increasing
total canopy interception and decreasing bare soil evaporation. It is
the sum of live and dead standing biomass across plant functional
types, bounded to be <= 800 g/m2.
Parameters:
aliv (numpy.ndarray): aboveground live biomass, calculated from
aglivc and tgprod across plant functional types
sum_stdedc (numpy.ndarray): aboveground standing dead C summed
across plant functional types
Returns:
sd, total aboveground standing biomass for soil water.
"""
valid_mask = (
(aliv != _TARGET_NODATA) &
(sum_stdedc != _TARGET_NODATA))
sd = numpy.empty(aliv.shape, dtype=numpy.float32)
sd[:] = _TARGET_NODATA
sd[valid_mask] = numpy.minimum(
aliv[valid_mask] + (sum_stdedc[valid_mask] * 2.5), 800.)
return sd
def subtract_surface_losses(return_type):
"""Calculate surface losses to runoff and surface evaporation.
Calculate the loss of surface moisture to runoff, canopy interception,
and bare soil evaporation.
Parameters:
return_type (string): flag indicating whether soil moisture inputs
after surface losses or total surface evaporation should be
returned
Returns:
the function `_subtract_surface_losses`
"""
def _subtract_surface_losses(
inputs_after_snow, fracro, precro, snow, alit, sd, fwloss_1,
fwloss_2, pet_rem):
"""Subtract moisture losses to runoff, interception, and evaporation.
Of the surface water inputs from precipitation and snowmelt, some water
is lost to runoff (line 113, H2olos.f). After runoff, some water is
lost to canopy interception and bare soil evaporation, if there is no
snow cover. Loss to canopy interception and bare soil evaporation is
a function of live, standing dead, and surface litter biomass. The
total loss of moisture to interception and bare soil evaporation is
bounded to be less than or equal to 40% of reference
evapotranspiration.
Parameters:
inputs_after_snow (numpy.ndarray): derived, surface water inputs
from precipitation and snowmelt, prior to runoff
fracro (numpy.ndarray): parameter, fraction of surface water
above precro that is lost to runoff
precro (numpy.ndarray): parameter, amount of surface water that
must be available for runoff to occur
snow (numpy.ndarray): derived, current snowpack
alit (numpy.ndarray): derived, biomass in surface litter
sd (numpy.ndarray): derived, total standing biomass
fwloss_1 (numpy.ndarray): parameter, scaling factor for
interception and evaporation of precip by vegetation
fwloss_2 (numpy.ndarray): parameter, scaling factor for bare soil
evaporation of precip
pet_rem (numpy.ndarray): derived, potential evaporation remaining
after evaporation of snow
Returns:
inputs_after_surface, surface water inputs to soil after runoff
and surface evaporation are subtracted, if return_type is
'inputs_after_surface'
absevap, bare soil evaporation, if return_type is 'absevap'
evap_losses, total surface evaporation, if return_type is
'evap_losses'
"""
valid_mask = (
(inputs_after_snow != _TARGET_NODATA) &
(fracro != _IC_NODATA) &
(precro != _IC_NODATA) &
(snow != _TARGET_NODATA) &
(alit != _TARGET_NODATA) &
(sd != _TARGET_NODATA) &
(fwloss_1 != _IC_NODATA) &
(fwloss_2 != _IC_NODATA) &
(pet_rem != _TARGET_NODATA))
runoff = numpy.empty(inputs_after_snow.shape, dtype=numpy.float32)
runoff[:] = _TARGET_NODATA
runoff[valid_mask] = numpy.maximum(
fracro[valid_mask] *
(inputs_after_snow[valid_mask] - precro[valid_mask]), 0.)
inputs_after_runoff = numpy.empty(
inputs_after_snow.shape, dtype=numpy.float32)
inputs_after_runoff[:] = _TARGET_NODATA
inputs_after_runoff[valid_mask] = (
inputs_after_snow[valid_mask] - runoff[valid_mask])
evap_mask = (valid_mask & (snow <= 0))
# loss to interception
aint = numpy.zeros(inputs_after_snow.shape, dtype=numpy.float32)
aint[evap_mask] = (
(0.0003 * alit[evap_mask] + 0.0006 * sd[evap_mask]) *
fwloss_1[evap_mask])
# loss to bare soil evaporation
absevap = numpy.empty(inputs_after_snow.shape, dtype=numpy.float32)
absevap[:] = _TARGET_NODATA
absevap[valid_mask] = 0.
absevap[evap_mask] = (
0.5 *
numpy.exp((-0.002 * alit[evap_mask]) - (0.004 * sd[evap_mask])) *
fwloss_2[evap_mask])
# total losses to interception and evaporation
evap_losses = numpy.empty(inputs_after_snow.shape, dtype=numpy.float32)
evap_losses[:] = _TARGET_NODATA
evap_losses[valid_mask] = 0.
evap_losses[evap_mask] = (
numpy.minimum(((absevap[evap_mask] + aint[evap_mask]) *
inputs_after_runoff[evap_mask]), (0.4 * pet_rem[evap_mask])))
# remaining inputs after evaporation
inputs_after_surface = numpy.empty(
inputs_after_snow.shape, dtype=numpy.float32)
inputs_after_surface[:] = _TARGET_NODATA
inputs_after_surface[valid_mask] = inputs_after_runoff[valid_mask]
inputs_after_surface[evap_mask] = (
inputs_after_runoff[evap_mask] - evap_losses[evap_mask])
if return_type == 'inputs_after_surface':
return inputs_after_surface
elif return_type == 'absevap':
return absevap
elif return_type == 'evap_losses':
return evap_losses
return _subtract_surface_losses
def calc_potential_transpiration(return_type):
"""Calculate potential transpiration and evaporation from soil layer 1.
Calculate potential transpiration (trap), potential evaporation from
soil layer 1 (pevp), and initial transpiration water loss (tran).
Remove the initial transpiration water loss from soil moisture inputs
at this step.
Parameters:
return_type (string): flag indicating whether potential transpiration,
potential evaporation from soil layer 1, or modified moisture
inputs should be returned
Returns:
the function `_calc_potential_transpiration`
"""
def _calc_potential_transpiration(
pet_rem, evap_losses, tave, aliv, current_moisture_inputs):
"""Calculate potential water losses to transpiration.
Calculate potential transpiration (trap), the total potential
transpiration from all soil layers by plants. Calculate potential
evaporation from soil layer 1 (pevp); this amount is calculated prior
to transpiration but actually removed after water loss to transpiration
from all soil layers has been accounted. Calculate actual transpiration
(tran). Remove actual transpiration water losses from moisture inputs
before distributing water to soil layers. This is necessary for a
monthly time step to give plants in wet climates adequate access to
water for transpiration.
Parameters:
pet_rem (numpy.ndarray): derived, potential evapotranspiration
remaining after evaporation of snow
evap_losses (numpy.ndarray): derived, total surface evaporation
tave (numpy.ndarray): derived, average temperature
aliv (numpy.ndarray): aboveground live biomass, calculated from
aglivc and tgprod across plant functional types
current_moisture_inputs (numpy.ndarray): derived, moisture inputs
after surface losses
Returns:
trap if return_type is 'trap'
pevp if return_type is 'pevp'
modified_moisture_inputs if return_type is
'modified_moisture_inputs'
"""
valid_mask = (
(pet_rem != _TARGET_NODATA) &
(evap_losses != _TARGET_NODATA) &
(tave != _IC_NODATA) &
(aliv != _TARGET_NODATA) &
(current_moisture_inputs != _TARGET_NODATA))
trap = numpy.empty(pet_rem.shape, dtype=numpy.float32)
trap[:] = _TARGET_NODATA
trap[valid_mask] = pet_rem[valid_mask] - evap_losses[valid_mask]
no_transpiration_mask = (valid_mask & (tave < 2))
trap[no_transpiration_mask] = 0.
transpiration_mask = (valid_mask & (tave >= 2))
trap[transpiration_mask] = numpy.maximum(
numpy.minimum(
trap[transpiration_mask], pet_rem[transpiration_mask] *
0.65 * (1 - numpy.exp(-0.02 * aliv[transpiration_mask]))), 0.)
trap[valid_mask] = numpy.maximum(trap[valid_mask], 0.01)
pevp = numpy.empty(pet_rem.shape, dtype=numpy.float32)
pevp[:] = _TARGET_NODATA
pevp[valid_mask] = numpy.maximum(
pet_rem[valid_mask] - trap[valid_mask] - evap_losses[valid_mask],
0.)
tran = numpy.empty(pet_rem.shape, dtype=numpy.float32)
tran[:] = _TARGET_NODATA
tran[valid_mask] = numpy.minimum(
trap[valid_mask] - 0.01, current_moisture_inputs[valid_mask])
trap[valid_mask] = trap[valid_mask] - tran[valid_mask]
modified_moisture_inputs = numpy.empty(
pet_rem.shape, dtype=numpy.float32)
modified_moisture_inputs[:] = _TARGET_NODATA
modified_moisture_inputs[valid_mask] = (
current_moisture_inputs[valid_mask] - tran[valid_mask])
if return_type == 'trap':
return trap
elif return_type == 'pevp':
return pevp
elif return_type == 'modified_moisture_inputs':
return modified_moisture_inputs
return _calc_potential_transpiration
def distribute_water_to_soil_layer(return_type):
"""Distribute moisture inputs to one soil layer prior to transpiration.
Soil moisture inputs after runoff, evaporation, and initial
transpiration are distributed to soil layers sequentially according to the
field capacity of the layer. If moisture inputs exceed the field capacity
of the layer, the remainder of moisture inputs move down to the next
adjacent soil layer.
Returns:
the function `_distribute_water`
"""
def _distribute_water(adep, afiel, asmos, current_moisture_inputs):
"""Revise soil moisture in this soil layer prior to transpiration.
Moisture inputs coming into this soil layer are compared to the field
capacity of the layer. If the field capacity is exceeded, the excess
moisture moves from this layer to the next adjacent layer.
Parameters:
adep (numpy.ndarray): parameter, depth of this soil layer in cm
afiel (numpy.ndarray): derived, field capacity of this layer
asmos (numpy.ndarray): state variable, current soil moisture
content of this soil layer
current_moisture_inputs (numpy.ndarray): derived, moisture inputs
added to this soil layer
Returns:
asmos_revised, revised soil moisture in this layer, if return_type
is 'asmos_revised'
amov, moisture flowing from this layer into the next, if
return_type is 'amov'
"""
valid_mask = (
(adep != _IC_NODATA) &
(afiel != _TARGET_NODATA) &
(~numpy.isclose(asmos, _SV_NODATA)) &
(current_moisture_inputs != _TARGET_NODATA))
afl = numpy.empty(adep.shape, dtype=numpy.float32)
afl[:] = _TARGET_NODATA
afl[valid_mask] = adep[valid_mask] * afiel[valid_mask]
asmos_interm = numpy.empty(adep.shape, dtype=numpy.float32)
asmos_interm[:] = _TARGET_NODATA
asmos_interm[valid_mask] = (
asmos[valid_mask] + current_moisture_inputs[valid_mask])
amov = numpy.empty(adep.shape, dtype=numpy.float32)
amov[:] = _TARGET_NODATA
exceeded_mask = (valid_mask & (asmos_interm > afl))
amov[exceeded_mask] = asmos_interm[exceeded_mask]
asmos_revised = numpy.empty(adep.shape, dtype=numpy.float32)
asmos_revised[:] = _TARGET_NODATA
asmos_revised[valid_mask] = asmos_interm[valid_mask]
asmos_revised[exceeded_mask] = afl[exceeded_mask]
notexceeded_mask = (valid_mask & (asmos_interm <= afl))
amov[notexceeded_mask] = 0.
if return_type == 'asmos_revised':
return asmos_revised
elif return_type == 'amov':
return amov
return _distribute_water
def calc_available_water_for_transpiration(asmos, awilt, adep):
"""Calculate water available for transpiration in one soil layer.
The water available for transpiration is the amount of water in the soil
layer minus the wilting point of the soil layer.
Parameters:
asmos (numpy.ndarray): derived, interim moisture in the soil layer
awilt (numpy.ndarray): derived, wilting point of the soil layer
adep (numpy.ndarray): parameter, depth of the soil layer in cm
Returns:
avw, available water for transpiration
"""
valid_mask = (
(asmos != _TARGET_NODATA) &
(awilt != _TARGET_NODATA) &
(adep != _IC_NODATA))
avw = numpy.empty(asmos.shape, dtype=numpy.float32)
avw[:] = _TARGET_NODATA
avw[valid_mask] = numpy.maximum(
asmos[valid_mask] - awilt[valid_mask] * adep[valid_mask], 0.)
return avw
def revise_potential_transpiration(trap, tot):
"""Revise potential transpiration according to water available.
Total potential transpiration, trap, is revised to be less than or equal
to total water available for transpiration, tot. Total water available
for transpiration is the sum of available water per soil layer.
Line 241, H2olos.f
Parameters:
trap (numpy.ndarray): derived, potential transpiration water losses
tot (numpy.ndarray): derived, total soil water available for
transpiration
Returns:
trap_revised, revised total potential transpiration
"""
valid_mask = (
(trap != _TARGET_NODATA) &
(tot != _TARGET_NODATA))
trap_revised = numpy.empty(trap.shape, dtype=numpy.float32)
trap_revised[:] = _TARGET_NODATA
trap_revised[valid_mask] = numpy.minimum(trap[valid_mask], tot[valid_mask])
return trap_revised
def remove_transpiration(return_type):
"""Remove water from a soil layer via transpiration by plants.
Transpiration from one soil layer is apportioned from total potential
transpiration, trap, according to the available water for transpiration in
this soil layer. Lines 218-294, H2olos.f
Parameters:
return_type (string): flag indicating whether avinj (water in this soil
layer available to plants for growth) or asmos (total water in this
soil layer) should be returned
Returns:
the function `_remove_transpiration`
"""
def _remove_transpiration(asmos, awilt, adep, trap, awwt, tot2):
"""Remove water from a soil layer via transpiration by plants.
Parameters:
asmos (numpy.ndarray): derived, interim moisture in this soil layer
after additions from current month precipitation
awilt (numpy.ndarray): derived, wilting point of this soil layer
adep (numpy.ndarray): parameter, depth of this soil layer in cm
trap (numpy.ndarray): derived, total potential transpiration
across all soil layers accessible by plant roots
awwt (numpy.ndarray): derived, water available for transpiration
in this soil layer weighted by transpiration depth distribution
parameter
tot2 (numpy.ndarray): derived, the sum of weighted water available
for transpiration across soil layers
Returns:
avinj, water available to plants for growth in this layer after
losses to transpiration, if return type is 'avinj'
asmos_revised, total water in this layer after losses to
transpiration, if return type is 'asmos'
"""
valid_mask = (
(asmos != _TARGET_NODATA) &
(awilt != _TARGET_NODATA) &
(adep != _IC_NODATA) &
(trap != _TARGET_NODATA) &
(awwt != _TARGET_NODATA) &
(tot2 != _TARGET_NODATA))
avinj = numpy.empty(asmos.shape, dtype=numpy.float32)
avinj[:] = _TARGET_NODATA
avinj[valid_mask] = numpy.maximum(
asmos[valid_mask] - awilt[valid_mask] * adep[valid_mask], 0.)
transpire_mask = (valid_mask & (tot2 > 0))
transpiration_loss = numpy.zeros(asmos.shape, dtype=numpy.float32)
transpiration_loss[transpire_mask] = numpy.minimum(
(trap[transpire_mask] *
awwt[transpire_mask]) / tot2[transpire_mask],
avinj[transpire_mask])
avinj[valid_mask] = avinj[valid_mask] - transpiration_loss[valid_mask]
asmos_revised = numpy.empty(asmos.shape, dtype=numpy.float32)
asmos_revised[:] = _TARGET_NODATA
asmos_revised[valid_mask] = (
asmos[valid_mask] - transpiration_loss[valid_mask])
if return_type == 'avinj':
return avinj
elif return_type == 'asmos':
return asmos_revised
return _remove_transpiration
def calc_relative_water_content_lyr_1(asmos_1, adep_1, awilt_1, afiel_1):
"""Calculate the relative water content of soil layer 1.
The relative water content of soil layer 1, prior to any evaporation losses
from soil layer 1, is used to estimate water available for evaporation
from soil layer 1. Line 280, H2olos.f
Parameters:
asmos_1 (numpy.ndarray): derived, interim moisture in soil layer 1
after losses to transpiration
adep_1 (numpy.ndarray): parameter, depth of soil layer 1 in cm
awilt_1 (numpy.ndarray): derived, wilting point of soil layer 1
afiel_1 (numpy.ndarray): derived, field capacity of soil layer 1
Returns:
rwcf_1, relative water content of soil layer 1
"""
valid_mask = (
(asmos_1 != _TARGET_NODATA) &
(adep_1 != _IC_NODATA) &
(awilt_1 != _TARGET_NODATA) &
(afiel_1 != _TARGET_NODATA))
rwcf_1 = numpy.empty(asmos_1.shape, dtype=numpy.float32)
rwcf_1[valid_mask] = (
(asmos_1[valid_mask] / adep_1[valid_mask] - awilt_1[valid_mask]) /
(afiel_1[valid_mask] - awilt_1[valid_mask]))
return rwcf_1
def calc_evaporation_loss(rwcf_1, pevp, absevap, asmos_1, awilt_1, adep_1):
"""Calculate evaporation from soil layer 1.
Some moisture is lost from soil layer 1 (i.e., the top soil layer) to
evaporation, separate from surface evaporation and transpiration by plants.
This amount is calculated from potential soil evaporation, which was
calculated from potential evapotranspiration prior to allocation of water
to soil layers. It is restricted to be less than or equal to water
available in this soil layer.
Parameters:
rwcf_1 (numpy.ndarray): derived, relative water content of soil layer 1
pevp (numpy.ndarray): derived, potential evaporation from soil layer 1
absevap (numpy.ndarray): derived, bare soil evaporation
asmos_1 (numpy.ndarray): derived, interim moisture in soil layer 1
awilt_1 (numpy.ndarray): derived, wilting point of soil layer 1
adep_1 (numpy.ndarray): parameter, depth of soil layer 1 in cm
Returns:
evlos, moisture evaporated from soil layer 1
"""
valid_mask = (
(rwcf_1 != _TARGET_NODATA) &
(pevp != _TARGET_NODATA) &
(absevap != _TARGET_NODATA) &
(asmos_1 != _TARGET_NODATA) &
(awilt_1 != _TARGET_NODATA) &
(adep_1 != _IC_NODATA))
evmt = numpy.empty(rwcf_1.shape, dtype=numpy.float32)
evmt[:] = _TARGET_NODATA
evmt[valid_mask] = numpy.maximum(
(rwcf_1[valid_mask] - 0.25) / (1 - 0.25), 0.01)
evlos = numpy.empty(rwcf_1.shape, dtype=numpy.float32)
evlos[:] = _TARGET_NODATA
evlos[valid_mask] = numpy.minimum(
evmt[valid_mask] * pevp[valid_mask] * absevap[valid_mask] * 0.1,
numpy.maximum(
asmos_1[valid_mask] - awilt_1[valid_mask] *
adep_1[valid_mask], 0.))
return evlos
def _soil_water(
aligned_inputs, site_param_table, veg_trait_table, current_month,
month_index, prev_sv_reg, pp_reg, pft_id_set, month_reg, sv_reg):
"""Allocate precipitation to runoff, transpiration, and soil moisture.
Simulate snowfall and account for evaporation and melting of the snow pack.
Allocate the flow of precipitation through interception by plants,
runoff and infiltration into the soil, percolation through the soil, and
transpiration by plants. Update soil moisture in each soil layer.
Estimate avh2o_1 for each PFT (water available to the PFT for growth),
avh2o_3 (water in first two soil layers), and amov_<lyr> (saturated flow
of water between soil layers, used in decomposition and mineral leaching).
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including precipitation, temperature,
plant functional type composition, and site spatial index
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters, including nlaypg, number of soil
layers access by plant roots
current_month (int): month of the year, such that current_month=1
indicates January
month_index (int): month of the simulation, such that month_index=1
indicates month 1 of the simulation
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
pp_reg (dict): map of key, path pairs giving persistent parameters
including field capacity of each soil layer
pft_id_set (set): set of integers identifying plant functional types
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
creates the raster indicated by `sv_reg['snow_path']`, current snowpack
creates the raster indicated by `sv_reg['snlq_path']`, current liquid
in snow
creates the raster indicated by
`sv_reg['asmos_<lyr>_path']`, soil moisture content, for each soil
layer accessible by roots of any plant functional type
creates the rasters indicated by `month_reg['amov_<lyr>']` for each
soil layer, saturated flow of water from that soil layer
creates the raster indicated by `sv_reg['avh2o_1_<PFT>_path']`, soil
moisture available for growth, for each plant functional type (PFT)
creates the raster indicated by `sv_reg['avh2o_3_path']`, available
water in the top two soil layers
Returns:
None
"""
def calc_avg_temp(max_temp, min_temp):
"""Calculate average temperature from maximum and minimum temp."""
valid_mask = (
(~numpy.isclose(max_temp, max_temp_nodata)) &
(~numpy.isclose(min_temp, min_temp_nodata)))
tave = numpy.empty(max_temp.shape, dtype=numpy.float32)
tave[:] = _IC_NODATA
tave[valid_mask] = (max_temp[valid_mask] + min_temp[valid_mask]) / 2.
return tave
def calc_surface_litter_biomass(strucc_1, metabc_1):
"""Calculate biomass in surface litter."""
valid_mask = (
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(~numpy.isclose(metabc_1, _SV_NODATA)))
alit = numpy.empty(strucc_1.shape, dtype=numpy.float32)
alit[:] = _TARGET_NODATA
alit[valid_mask] = (strucc_1[valid_mask] + metabc_1[valid_mask]) * 2.5
alit = numpy.minimum(alit, 400)
return alit
max_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
# get max number of soil layers accessible by plants
nlaypg_max = int(max(val['nlaypg'] for val in veg_trait_table.values()))
# max number of soil layers simulated, beyond those accessible by plants
nlayer_max = int(max(val['nlayer'] for val in site_param_table.values()))
# temporary intermediate rasters for soil water submodel
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'tave', 'current_moisture_inputs', 'modified_moisture_inputs',
'pet_rem', 'alit', 'sum_aglivc', 'sum_stdedc', 'sum_tgprod',
'aliv', 'sd', 'absevap', 'evap_losses', 'trap', 'trap_revised',
'pevp', 'tot', 'tot2', 'rwcf_1', 'evlos', 'avinj_interim_1']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
# temporary intermediate values for each layer accessible by plants
for val in ['avw', 'awwt', 'avinj']:
for lyr in range(1, nlaypg_max + 1):
val_lyr = '{}_{}'.format(val, lyr)
temp_val_dict[val_lyr] = os.path.join(
temp_dir, '{}.tif'.format(val_lyr))
# temporary intermediate value for each layer total
for lyr in range(1, nlayer_max + 1):
val_lyr = 'asmos_interim_{}'.format(lyr)
temp_val_dict[val_lyr] = os.path.join(
temp_dir, '{}.tif'.format(val_lyr))
# PFT-level temporary calculated values
for pft_i in pft_id_set:
for val in ['tgprod_weighted', 'sum_avinj']:
temp_val_dict['{}_{}'.format(val, pft_i)] = os.path.join(
temp_dir, '{}_{}.tif'.format(val, pft_i))
param_val_dict = {}
for val in ['fracro', 'precro', 'fwloss_1', 'fwloss_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for lyr in range(1, nlaypg_max + 1):
val_lyr = 'awtl_{}'.format(lyr)
target_path = os.path.join(temp_dir, '{}.tif'.format(val_lyr))
param_val_dict[val_lyr] = target_path
site_to_val = dict(
[(site_code, float(table[val_lyr])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
for lyr in range(1, nlayer_max + 1):
val_lyr = 'adep_{}'.format(lyr)
target_path = os.path.join(temp_dir, '{}.tif'.format(val_lyr))
param_val_dict[val_lyr] = target_path
site_to_val = dict(
[(site_code, float(table[val_lyr])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# calculate canopy and litter cover that influence moisture inputs
# calculate biomass in surface litter
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['strucc_1_path'], prev_sv_reg['metabc_1_path']]],
calc_surface_litter_biomass, temp_val_dict['alit'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate the sum of aglivc (standing live biomass) and stdedc
# (standing dead biomass) across PFTs, weighted by % cover of each PFT
for sv in ['aglivc', 'stdedc']:
weighted_sum_path = temp_val_dict['sum_{}'.format(sv)]
weighted_state_variable_sum(
sv, prev_sv_reg, aligned_inputs, pft_id_set, weighted_sum_path)
# calculate the weighted sum of tgprod, potential production, across PFTs
weighted_path_list = []
for pft_i in pft_id_set:
do_growth = (
current_month != veg_trait_table[pft_i]['senescence_month'] and
str(current_month) in veg_trait_table[pft_i]['growth_months'])
if do_growth:
target_path = temp_val_dict['tgprod_weighted_{}'.format(pft_i)]
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
raster_multiplication(
month_reg['tgprod_{}'.format(pft_i)], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
target_path, _TARGET_NODATA)
weighted_path_list.append(target_path)
if weighted_path_list:
raster_list_sum(
weighted_path_list, _TARGET_NODATA,
temp_val_dict['sum_tgprod'], _TARGET_NODATA, nodata_remove=True)
else: # no potential production occurs this month, so tgprod = 0
pygeoprocessing.new_raster_from_base(
temp_val_dict['sum_aglivc'], temp_val_dict['sum_tgprod'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0.])
# calculate average temperature
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)]]],
calc_avg_temp, temp_val_dict['tave'], gdal.GDT_Float32, _IC_NODATA)
# calculate aboveground live biomass
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_aglivc'], temp_val_dict['sum_tgprod']]],
_calc_aboveground_live_biomass, temp_val_dict['aliv'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate total standing biomass
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aliv'], temp_val_dict['sum_stdedc']]],
_calc_standing_biomass, temp_val_dict['sd'],
gdal.GDT_Float32, _TARGET_NODATA)
# modify standing snow, liquid in snow, return moisture inputs after snow
_snow(
aligned_inputs['site_index'], site_param_table,
aligned_inputs['precip_{}'.format(month_index)],
temp_val_dict['tave'],
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
prev_sv_reg['snow_path'], prev_sv_reg['snlq_path'],
current_month, month_reg['snowmelt'], sv_reg['snow_path'],
sv_reg['snlq_path'], temp_val_dict['modified_moisture_inputs'],
temp_val_dict['pet_rem'])
# remove runoff and surface evaporation from moisture inputs
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
temp_val_dict['current_moisture_inputs'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['current_moisture_inputs'],
param_val_dict['fracro'], param_val_dict['precro'],
sv_reg['snow_path'], temp_val_dict['alit'],
temp_val_dict['sd'], param_val_dict['fwloss_1'],
param_val_dict['fwloss_2'], temp_val_dict['pet_rem']]],
subtract_surface_losses('inputs_after_surface'),
temp_val_dict['modified_moisture_inputs'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate bare soil evaporation
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['current_moisture_inputs'],
param_val_dict['fracro'], param_val_dict['precro'],
sv_reg['snow_path'], temp_val_dict['alit'],
temp_val_dict['sd'], param_val_dict['fwloss_1'],
param_val_dict['fwloss_2'], temp_val_dict['pet_rem']]],
subtract_surface_losses('absevap'),
temp_val_dict['absevap'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate total losses to surface evaporation
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['current_moisture_inputs'],
param_val_dict['fracro'], param_val_dict['precro'],
sv_reg['snow_path'], temp_val_dict['alit'],
temp_val_dict['sd'], param_val_dict['fwloss_1'],
param_val_dict['fwloss_2'], temp_val_dict['pet_rem']]],
subtract_surface_losses('evap_losses'),
temp_val_dict['evap_losses'],
gdal.GDT_Float32, _TARGET_NODATA)
# remove losses due to initial transpiration from water inputs
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
temp_val_dict['current_moisture_inputs'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pet_rem'], temp_val_dict['evap_losses'],
temp_val_dict['tave'], temp_val_dict['aliv'],
temp_val_dict['current_moisture_inputs']]],
calc_potential_transpiration('modified_moisture_inputs'),
temp_val_dict['modified_moisture_inputs'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate potential transpiration
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pet_rem'], temp_val_dict['evap_losses'],
temp_val_dict['tave'], temp_val_dict['aliv'],
temp_val_dict['current_moisture_inputs']]],
calc_potential_transpiration('trap'), temp_val_dict['trap'],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate potential evaporation from top soil layer
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pet_rem'], temp_val_dict['evap_losses'],
temp_val_dict['tave'], temp_val_dict['aliv'],
temp_val_dict['current_moisture_inputs']]],
calc_potential_transpiration('pevp'), temp_val_dict['pevp'],
gdal.GDT_Float32, _TARGET_NODATA)
# distribute water to each layer
for lyr in range(1, nlayer_max + 1):
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
temp_val_dict['current_moisture_inputs'])
# revise moisture content of this soil layer
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['adep_{}'.format(lyr)],
pp_reg['afiel_{}_path'.format(lyr)],
prev_sv_reg['asmos_{}_path'.format(lyr)],
temp_val_dict['current_moisture_inputs']]],
distribute_water_to_soil_layer('asmos_revised'),
temp_val_dict['asmos_interim_{}'.format(lyr)],
gdal.GDT_Float32, _TARGET_NODATA)
# calculate soil moisture moving to next layer
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
param_val_dict['adep_{}'.format(lyr)],
pp_reg['afiel_{}_path'.format(lyr)],
prev_sv_reg['asmos_{}_path'.format(lyr)],
temp_val_dict['current_moisture_inputs']]],
distribute_water_to_soil_layer('amov'),
temp_val_dict['modified_moisture_inputs'],
gdal.GDT_Float32, _TARGET_NODATA)
# amov, water moving to next layer, persists between submodels
shutil.copyfile(
temp_val_dict['modified_moisture_inputs'],
month_reg['amov_{}'.format(lyr)])
# calculate available water for transpiration
avw_list = []
for lyr in range(1, nlaypg_max + 1):
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['asmos_interim_{}'.format(lyr)],
pp_reg['awilt_{}_path'.format(lyr)],
param_val_dict['adep_{}'.format(lyr)]]],
calc_available_water_for_transpiration,
temp_val_dict['avw_{}'.format(lyr)], gdal.GDT_Float32,
_TARGET_NODATA)
avw_list.append(temp_val_dict['avw_{}'.format(lyr)])
# total water available for transpiration
raster_list_sum(
avw_list, _TARGET_NODATA, temp_val_dict['tot'], _TARGET_NODATA)
# calculate water available for transpiration weighted by transpiration
# depth for that soil layer
awwt_list = []
for lyr in range(1, nlaypg_max + 1):
raster_multiplication(
temp_val_dict['avw_{}'.format(lyr)], _TARGET_NODATA,
param_val_dict['awtl_{}'.format(lyr)], _IC_NODATA,
temp_val_dict['awwt_{}'.format(lyr)], _TARGET_NODATA)
awwt_list.append(temp_val_dict['awwt_{}'.format(lyr)])
# total weighted available water for transpiration
raster_list_sum(
awwt_list, _TARGET_NODATA, temp_val_dict['tot2'], _TARGET_NODATA)
# revise total potential transpiration
pygeoprocessing.raster_calculator(
[(path, 1) for path in [temp_val_dict['trap'], temp_val_dict['tot']]],
revise_potential_transpiration, temp_val_dict['trap_revised'],
gdal.GDT_Float32, _TARGET_NODATA)
# remove water via transpiration
for lyr in range(1, nlaypg_max + 1):
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['asmos_interim_{}'.format(lyr)],
pp_reg['awilt_{}_path'.format(lyr)],
param_val_dict['adep_{}'.format(lyr)],
temp_val_dict['trap_revised'],
temp_val_dict['awwt_{}'.format(lyr)], temp_val_dict['tot2']]],
remove_transpiration('avinj'),
temp_val_dict['avinj_{}'.format(lyr)], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['asmos_interim_{}'.format(lyr)],
pp_reg['awilt_{}_path'.format(lyr)],
param_val_dict['adep_{}'.format(lyr)],
temp_val_dict['trap_revised'],
temp_val_dict['awwt_{}'.format(lyr)], temp_val_dict['tot2']]],
remove_transpiration('asmos'), sv_reg['asmos_{}_path'.format(lyr)],
gdal.GDT_Float32, _TARGET_NODATA)
# no transpiration is removed from layers not accessible by plants
for lyr in range(nlaypg_max + 1, nlayer_max + 1):
shutil.copyfile(
temp_val_dict['asmos_interim_{}'.format(lyr)],
sv_reg['asmos_{}_path'.format(lyr)])
# relative water content of soil layer 1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['asmos_1_path'], param_val_dict['adep_1'],
pp_reg['awilt_1_path'], pp_reg['afiel_1_path']]],
calc_relative_water_content_lyr_1, temp_val_dict['rwcf_1'],
gdal.GDT_Float32, _TARGET_NODATA)
# evaporation from soil layer 1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['rwcf_1'], temp_val_dict['pevp'],
temp_val_dict['absevap'], sv_reg['asmos_1_path'],
pp_reg['awilt_1_path'], param_val_dict['adep_1']]],
calc_evaporation_loss, temp_val_dict['evlos'],
gdal.GDT_Float32, _TARGET_NODATA)
# remove evaporation from total moisture in soil layer 1
shutil.copyfile(sv_reg['asmos_1_path'], temp_val_dict['asmos_interim_1'])
raster_difference(
temp_val_dict['asmos_interim_1'], _TARGET_NODATA,
temp_val_dict['evlos'], _TARGET_NODATA, sv_reg['asmos_1_path'],
_TARGET_NODATA)
# remove evaporation from moisture available to plants in soil layer 1
shutil.copyfile(temp_val_dict['avinj_1'], temp_val_dict['avinj_interim_1'])
raster_difference(
temp_val_dict['avinj_interim_1'], _TARGET_NODATA,
temp_val_dict['evlos'], _TARGET_NODATA, temp_val_dict['avinj_1'],
_TARGET_NODATA)
# calculate avh2o_1, soil water available for growth, for each PFT
for pft_i in pft_id_set:
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
soil_layers_accessible = [
temp_val_dict['avinj_{}'.format(lyr)] for lyr in
range(1, int(veg_trait_table[pft_i]['nlaypg']) + 1)]
raster_list_sum(
soil_layers_accessible, _TARGET_NODATA,
temp_val_dict['sum_avinj_{}'.format(pft_i)],
_TARGET_NODATA, nodata_remove=True)
raster_multiplication(
temp_val_dict['sum_avinj_{}'.format(pft_i)], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
sv_reg['avh2o_1_{}_path'.format(pft_i)], _SV_NODATA)
# calculate avh2o_3, moisture in top two soil layers
soil_layers_to_sum = [
temp_val_dict['avinj_{}'.format(lyr)] for lyr in [1, 2]]
raster_list_sum(
soil_layers_to_sum, _TARGET_NODATA, sv_reg['avh2o_3_path'],
_SV_NODATA, nodata_remove=False)
# set correct nodata value for all revised asmos rasters
for lyr in range(1, nlayer_max + 1):
reclassify_nodata(sv_reg['asmos_{}_path'.format(lyr)], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_anerb(rprpet, pevap, drain, aneref_1, aneref_2, aneref_3):
"""Calculate the effect of soil anaerobic conditions on decomposition.
The impact of soil anaerobic conditions on decomposition is calculated from
soil moisture and reference evapotranspiration. Anerob.f.
Parameters:
rprpet (numpy.ndarray): derived, ratio of precipitation or snowmelt to
reference evapotranspiration
pevap (numpy.ndarray): derived, reference evapotranspiration
drain (numpy.ndarray): parameter, the fraction of excess water lost by
drainage. Indicates whether a soil is sensitive for anaerobiosis
(drain = 0) or not (drain = 1)
aneref_1 (numpy.ndarray): parameter, value of rprpet below which there
is no negative impact of soil anaerobic conditions on decomposition
aneref_2 (numpy.ndarray): parameter, value of rprpet above which there
is maximum negative impact of soil anaerobic conditions on
decomposition
aneref_3 (numpy.ndarray): parameter, minimum value of the impact of
soil anaerobic conditions on decomposition
Returns:
anerb, the effect of soil anaerobic conditions on decomposition
"""
valid_mask = (
(rprpet != _TARGET_NODATA) &
(pevap != _TARGET_NODATA) &
(drain != _IC_NODATA) &
(aneref_1 != _IC_NODATA) &
(aneref_2 != _IC_NODATA) &
(aneref_3 != _IC_NODATA))
xh2o = numpy.empty(rprpet.shape, dtype=numpy.float32)
xh2o[:] = _TARGET_NODATA
xh2o[valid_mask] = (
(rprpet[valid_mask] - aneref_1[valid_mask]) * pevap[valid_mask] *
(1. - drain[valid_mask]))
anerb = numpy.empty(rprpet.shape, dtype=numpy.float32)
anerb[:] = _TARGET_NODATA
anerb[valid_mask] = 1.
high_rprpet_mask = (valid_mask & (rprpet > aneref_1) & (xh2o > 0))
anerb[high_rprpet_mask] = numpy.maximum(
1. + (1. - aneref_3[high_rprpet_mask]) /
(aneref_1[high_rprpet_mask] - aneref_2[high_rprpet_mask]) *
(aneref_1[high_rprpet_mask] +
(xh2o[high_rprpet_mask] / pevap[high_rprpet_mask]) -
aneref_1[high_rprpet_mask]),
aneref_3[high_rprpet_mask])
return anerb
def esched(return_type):
"""Calculate flow of an element accompanying decomposition of C.
Calculate the movement of one element (N or P) as C decomposes from one
state variable (the donating stock, or box A) to another state variable
(the receiving stock, or box B). Esched.f
Parameters:
return_type (string): flag indicating whether to return material
leaving box A, material arriving in box B, or material flowing
into or out of the mineral pool
Returns:
the function `_esched`
"""
def _esched(cflow, tca, rcetob, anps, labile):
"""Calculate the flow of one element (iel) to accompany decomp of C.
This is a transcription of Esched.f: "Schedule N, P, or S flow and
associated mineralization or immobilization flow for decomposition
from Box A to Box B."
If there is enough of iel (N or P) in the donating stock to satisfy
the required ratio, that material flows from the donating stock to
the receiving stock and whatever iel is leftover goes to mineral
pool. If there is not enough iel to satisfy the required ratio, iel
is drawn from the mineral pool to satisfy the ratio; if there is
not enough iel in the mineral pool, the material does not leave the
donating stock.
Parameters:
cflow (numpy.ndarray): derived, total C that is decomposing from
box A to box B
tca (numpy.ndarray): state variable, C in donating stock, i.e.
box A
rcetob (numpy.ndarray): derived, required ratio of C/iel in the
receiving stock
anps (numpy.ndarray): state variable, iel (N or P) in the donating
stock
labile (numpy.ndarray): state variable, mineral iel (N or P)
Returns:
material_leaving_a, the amount of material leaving box A, if
return_type is 'material_leaving_a'
material_arriving_b, the amount of material arriving in box B,
if return_type is 'material_arriving_b'
mnrflo, flow to or from mineral pool, if return_type is
'mineral_flow'
"""
valid_mask = (
(cflow != _IC_NODATA) &
(~numpy.isclose(tca, _SV_NODATA)) &
(tca > 0) &
(rcetob != _TARGET_NODATA) &
(~numpy.isclose(anps, _SV_NODATA)) &
(~numpy.isclose(labile, _SV_NODATA)))
outofa = numpy.empty(cflow.shape, dtype=numpy.float32)
outofa[:] = _IC_NODATA
outofa[valid_mask] = (
anps[valid_mask] * (cflow[valid_mask] / tca[valid_mask]))
immobil_ratio = numpy.zeros(cflow.shape)
nonzero_mask = ((outofa > 0) & valid_mask)
immobil_ratio[nonzero_mask] = (
cflow[nonzero_mask] / outofa[nonzero_mask])
immflo = numpy.zeros(cflow.shape)
immflo[valid_mask] = (
cflow[valid_mask] / rcetob[valid_mask] - outofa[valid_mask])
labile_supply = numpy.zeros(cflow.shape)
labile_supply[valid_mask] = labile[valid_mask] - immflo[valid_mask]
atob = numpy.zeros(cflow.shape)
atob[valid_mask] = cflow[valid_mask] / rcetob[valid_mask]
# immobilization
immobilization_mask = (
(immobil_ratio > rcetob) &
(labile_supply > 0) &
valid_mask)
# mineralization
mineralization_mask = (
(immobil_ratio <= rcetob) &
valid_mask)
# no movement
no_movt_mask = (
(immobil_ratio > rcetob) &
(labile_supply <= 0) &
valid_mask)
material_leaving_a = numpy.empty(cflow.shape, dtype=numpy.float32)
material_leaving_a[:] = _IC_NODATA
material_arriving_b = numpy.empty(cflow.shape, dtype=numpy.float32)
material_arriving_b[:] = _IC_NODATA
mnrflo = numpy.empty(cflow.shape, dtype=numpy.float32)
mnrflo[:] = _IC_NODATA
material_leaving_a[immobilization_mask] = (
outofa[immobilization_mask])
material_arriving_b[immobilization_mask] = (
outofa[immobilization_mask] + immflo[immobilization_mask])
mnrflo[immobilization_mask] = -immflo[immobilization_mask]
material_leaving_a[mineralization_mask] = outofa[mineralization_mask]
material_arriving_b[mineralization_mask] = atob[mineralization_mask]
mnrflo[mineralization_mask] = (
outofa[mineralization_mask] - atob[mineralization_mask])
material_leaving_a[no_movt_mask] = 0.
material_arriving_b[no_movt_mask] = 0.
mnrflo[no_movt_mask] = 0.
if return_type == 'material_leaving_a':
return material_leaving_a
elif return_type == 'material_arriving_b':
return material_arriving_b
elif return_type == 'mineral_flow':
return mnrflo
return _esched
def fsfunc(minerl_1_2, sorpmx, pslsrb):
"""Calculate the fraction of mineral P that is in solution.
The fraction of P in solution is influenced by two soil properties:
the maximum sorption potential of the soil and sorption affinity.
Parameters:
minerl_1_2 (numpy.ndarray): state variable, mineral P in top layer
sorpmx (numpy.ndarray): parameter, maximum P sorption potential
pslsrb (numpy.ndarray): parameter, slope term which controls the
fraction of mineral P that is labile
Returns:
fsol, fraction of P in solution
"""
valid_mask = (
(~numpy.isclose(minerl_1_2, _SV_NODATA)) &
(minerl_1_2 > 0) &
(sorpmx != _IC_NODATA) &
(pslsrb != _IC_NODATA))
c_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
c_ar[valid_mask] = (
sorpmx[valid_mask] * (2.0 - pslsrb[valid_mask]) / 2.)
b_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
b_ar[valid_mask] = (
sorpmx[valid_mask] - minerl_1_2[valid_mask] + c_ar[valid_mask])
sq_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
sq_ar[valid_mask] = (
b_ar[valid_mask] * b_ar[valid_mask] + 4. * c_ar[valid_mask] *
minerl_1_2[valid_mask])
sqrt_ar = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
sqrt_ar[valid_mask] = numpy.sqrt(sq_ar[valid_mask])
labile = numpy.zeros(minerl_1_2.shape, dtype=numpy.float32)
labile[valid_mask] = (-b_ar[valid_mask] + sqrt_ar[valid_mask]) / 2.
fsol = numpy.empty(minerl_1_2.shape, dtype=numpy.float32)
fsol[:] = _TARGET_NODATA
fsol[valid_mask] = labile[valid_mask] / minerl_1_2[valid_mask]
return fsol
def calc_surface_som2_ratio(
som1c_1, som1e_1_iel, rad1p_1_iel, rad1p_2_iel, rad1p_3_iel,
pcemic1_2_iel):
"""Calculate the required C/iel ratio for material entering surface SOM2.
The C/iel ratio of material decomposing from surface SOM1 into surface SOM2
fluctuates with each decomposition time step according to the current C/iel
content of SOM1.
Parameters:
som1c_1 (numpy.ndarray): state variable, C in surface SOM1
som1e_1_iel (numpy.ndarray): state variable, iel in surface SOM1
rad1p_1_iel (numpy.ndarray): parameter, intercept term
rad1p_2_iel (numpy.ndarray): parameter, slope term
rad1p_3_iel (numpy.ndarray): parameter, minimum allowable C/iel for
addition term
pcemic1_2_iel (numpy.ndarray): parameter, minimum C/iel ratio
Returns:
rceto2_surface, required C/iel ratio of material entering surface SOM2
"""
valid_mask = (
(~numpy.isclose(som1c_1, _SV_NODATA)) &
(~numpy.isclose(som1e_1_iel, _SV_NODATA)) &
(som1e_1_iel > 0) &
(rad1p_1_iel != _IC_NODATA) &
(rad1p_2_iel != _IC_NODATA) &
(pcemic1_2_iel != _IC_NODATA) &
(rad1p_3_iel != _IC_NODATA))
radds1 = numpy.empty(som1c_1.shape, dtype=numpy.float32)
radds1[:] = _TARGET_NODATA
radds1[valid_mask] = (
rad1p_1_iel[valid_mask] + rad1p_2_iel[valid_mask] *
((som1c_1[valid_mask] / som1e_1_iel[valid_mask]) -
pcemic1_2_iel[valid_mask]))
rceto2_surface = numpy.empty(som1c_1.shape, dtype=numpy.float32)
rceto2_surface[:] = _TARGET_NODATA
rceto2_surface[valid_mask] = numpy.maximum(
(som1c_1[valid_mask] / som1e_1_iel[valid_mask] + radds1[valid_mask]),
rad1p_3_iel[valid_mask])
return rceto2_surface
def calc_tcflow_strucc_1(
aminrl_1, aminrl_2, strucc_1, struce_1_1, struce_1_2, rnewas_1_1,
rnewas_2_1, strmax_1, defac, dec1_1, pligst_1, strlig_1, pheff_struc):
"""Calculate total flow out of surface structural C.
The total potential flow of C out of surface structural material is
calculated according to its lignin content, the decomposition factor, and
soil pH. The actual flow is limited by the availability of N and P. N and P
may be supplied by the mineral source, or by the element (N or P) in the
decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average surface mineral N
aminrl_2 (numpy.ndarray): derived, average surface mineral P
strucc_1 (numpy.ndarray): state variable, surface structural C
struce_1_1 (numpy.ndarray): state variable, surface structural N
struce_1_2 (numpy.ndarray): state variable, surface structural P
rnewas_1_1 (numpy.ndarray): derived, required C/N ratio for
aboveground material decomposing to SOM1
rnewas_2_1 (numpy.ndarray): derived, required C/P ratio for
aboveground material decomposing to SOM1
strmax_1 (numpy.ndarray): parameter, maximum decomposition amount
defac (numpy.ndarray): derived, decomposition factor
dec1_1 (numpy.ndarray): parameter, maximum decomposition rate
pligst_1 (numpy.ndarray): parameter, effect of lignin content on
decomposition rate
strlig_1 (numpy.ndarray): state variable, lignin content of decomposing
material
pheff_struc (numpy.ndarray): derived, effect of soil pH on
decomposition rate
Returns:
tcflow_strucc_1, total flow of C out of surface structural
material
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(~numpy.isclose(struce_1_1, _SV_NODATA)) &
(~numpy.isclose(struce_1_2, _SV_NODATA)) &
(rnewas_1_1 != _TARGET_NODATA) &
(rnewas_2_1 != _TARGET_NODATA) &
(strmax_1 != _IC_NODATA) &
(defac != _TARGET_NODATA) &
(dec1_1 != _IC_NODATA) &
(pligst_1 != _IC_NODATA) &
(~numpy.isclose(strlig_1, _SV_NODATA)) &
(pheff_struc != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(strucc_1[valid_mask], strmax_1[valid_mask]) *
defac[valid_mask] * dec1_1[valid_mask] *
numpy.exp(-pligst_1[valid_mask] * strlig_1[valid_mask]) * 0.020833 *
pheff_struc[valid_mask])
decompose_mask = (
((aminrl_1 > 0.0000001) | ((strucc_1 / struce_1_1) <= rnewas_1_1)) &
((aminrl_2 > 0.0000001) | ((strucc_1 / struce_1_2) <= rnewas_2_1)) &
valid_mask)
tcflow_strucc_1 = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_strucc_1[:] = _IC_NODATA
tcflow_strucc_1[valid_mask] = 0.
tcflow_strucc_1[decompose_mask] = potential_flow[decompose_mask]
return tcflow_strucc_1
def calc_tcflow_strucc_2(
aminrl_1, aminrl_2, strucc_2, struce_2_1, struce_2_2, rnewbs_1_1,
rnewbs_2_1, strmax_2, defac, dec1_2, pligst_2, strlig_2, pheff_struc,
anerb):
"""Calculate total flow out of soil structural C.
The total potential flow of C out of soil structural material is
calculated according to its lignin content, the decomposition factor, and
soil pH. The actual flow is limited by the availability of N and P. N and P
may be supplied by the mineral source, or by the element (N or P) in the
decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average soil mineral N
aminrl_2 (numpy.ndarray): derived, average soil mineral P
strucc_2 (numpy.ndarray): state variable, soil structural C
struce_2_1 (numpy.ndarray): state variable, soil structural N
struce_2_2 (numpy.ndarray): state variable, soil structural P
rnewbs_1_1 (numpy.ndarray): derived, required C/N ratio for
belowground material decomposing to SOM1
rnewbs_2_1 (numpy.ndarray): derived, required C/P ratio for
belowground material decomposing to SOM1
strmax_2 (numpy.ndarray): parameter, maximum decomposition amount
defac (numpy.ndarray): derived, decomposition factor
dec1_2 (numpy.ndarray): parameter, maximum decomposition rate
pligst_2 (numpy.ndarray): parameter, effect of lignin content on
decomposition rate
strlig_2 (numpy.ndarray): state variable, lignin content of decomposing
material
pheff_struc (numpy.ndarray): derived, effect of soil pH on
decomposition rate
anerb (numpy.ndarray): derived, effect of soil anaerobic conditions on
decomposition rate
Returns:
tcflow_strucc_2, total flow of C out of soil structural
material
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(strucc_2, _SV_NODATA)) &
(~numpy.isclose(struce_2_1, _SV_NODATA)) &
(~numpy.isclose(struce_2_2, _SV_NODATA)) &
(rnewbs_1_1 != _TARGET_NODATA) &
(rnewbs_2_1 != _TARGET_NODATA) &
(strmax_2 != _IC_NODATA) &
(defac != _TARGET_NODATA) &
(dec1_2 != _IC_NODATA) &
(pligst_2 != _IC_NODATA) &
(~numpy.isclose(strlig_2, _SV_NODATA)) &
(pheff_struc != _TARGET_NODATA) &
(anerb != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(strucc_2[valid_mask], strmax_2[valid_mask]) *
defac[valid_mask] * dec1_2[valid_mask] *
numpy.exp(-pligst_2[valid_mask] * strlig_2[valid_mask]) * 0.020833 *
pheff_struc[valid_mask] * anerb[valid_mask])
decompose_mask = (
((aminrl_1 > 0.0000001) | ((strucc_2 / struce_2_1) <= rnewbs_1_1)) &
((aminrl_2 > 0.0000001) | ((strucc_2 / struce_2_2) <= rnewbs_2_1)) &
valid_mask)
tcflow_strucc_2 = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_strucc_2[:] = _IC_NODATA
tcflow_strucc_2[valid_mask] = 0.
tcflow_strucc_2[decompose_mask] = potential_flow[decompose_mask]
return tcflow_strucc_2
def calc_tcflow_surface(
aminrl_1, aminrl_2, cstatv, estatv_1, estatv_2, rcetob_1, rcetob_2,
defac, dec_param, pheff):
"""Calculate total flow of C out of a surface pool.
The total potential flow of C out of a surface pool is calculated according
to the decomposition factor and soil pH. The actual flow is limited by the
availability of N and P. N and P may be supplied by the mineral source, or
by the element (N or P) in the decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average surface mineral N
aminrl_2 (numpy.ndarray): derived, average surface mineral P
cstatv (numpy.ndarray): state variable, C in decomposing pool
estatv_1 (numpy.ndarray): state variable, N in decomposing pool
estatv_2 (numpy.ndarray): state variable, P in decomposing pool
rcetob_1 (numpy.ndarray): derived, required C/N ratio for
material entering the receiving pool
rcetob_2 (numpy.ndarray): derived, required C/P ratio for
material entering the receiving pool
defac (numpy.ndarray): derived, decomposition factor
dec_param (numpy.ndarray): parameter, maximum decomposition rate
pheff (numpy.ndarray): derived, effect of soil pH on
decomposition rate
Returns:
tcflow, total flow of C out of the decomposing pool
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(estatv_1, _SV_NODATA)) &
(~numpy.isclose(estatv_2, _SV_NODATA)) &
(rcetob_1 != _TARGET_NODATA) &
(rcetob_2 != _TARGET_NODATA) &
(defac != _TARGET_NODATA) &
(dec_param != _IC_NODATA) &
(pheff != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(
cstatv[valid_mask] * defac[valid_mask] * dec_param[valid_mask] *
0.020833 * pheff[valid_mask], cstatv[valid_mask]))
decompose_mask = (
((aminrl_1 > 0.0000001) | ((cstatv / estatv_1) <= rcetob_1)) &
((aminrl_2 > 0.0000001) | ((cstatv / estatv_2) <= rcetob_2)) &
valid_mask)
tcflow = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow[:] = _IC_NODATA
tcflow[valid_mask] = 0.
tcflow[decompose_mask] = potential_flow[decompose_mask]
return tcflow
def calc_tcflow_soil(
aminrl_1, aminrl_2, cstatv, estatv_1, estatv_2, rcetob_1,
rcetob_2, defac, dec_param, pheff, anerb):
"""Calculate total flow out of soil metabolic C.
The total potential flow of C out of soil metabolic material is
calculated according to the decomposition factor, soil pH, and soil
anaerobic conditions. The actual flow is limited by the availability of N
and P. N and P may be supplied by the mineral source, or by the element
(N or P) in the decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average soil mineral N
aminrl_2 (numpy.ndarray): derived, average soil mineral P
cstatv (numpy.ndarray): state variable, C in decomposing stock
estatv_1 (numpy.ndarray): state variable, N in decomposing stock
estatv_2 (numpy.ndarray): state variable, P in decomposing stock
rcetob_1 (numpy.ndarray): derived, required C/N ratio for
material entering receiving stock
rceto1_2 (numpy.ndarray): derived, required C/P ratio for
material entering receiving stock
defac (numpy.ndarray): derived, decomposition factor
dec_param (numpy.ndarray): parameter, maximum decomposition rate
pheff (numpy.ndarray): derived, effect of soil pH on
decomposition rate
anerb (numpy.ndarray): derived, effect of soil anaerobic
conditions on decomposition rate
Returns:
tcflow_soil, total flow of C out of soil metabolic
material
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(cstatv, _SV_NODATA)) &
(~numpy.isclose(estatv_1, _SV_NODATA)) &
(~numpy.isclose(estatv_2, _SV_NODATA)) &
(rcetob_1 != _TARGET_NODATA) &
(rcetob_2 != _TARGET_NODATA) &
(defac != _TARGET_NODATA) &
(dec_param != _IC_NODATA) &
(pheff != _TARGET_NODATA) &
(anerb != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
numpy.minimum(
cstatv[valid_mask] * defac[valid_mask] * dec_param[valid_mask] *
0.020833 * pheff[valid_mask] * anerb[valid_mask],
cstatv[valid_mask]))
decompose_mask = (
((aminrl_1 > 0.0000001) | ((cstatv / estatv_1) <= rcetob_1)) &
((aminrl_2 > 0.0000001) | ((cstatv / estatv_2) <= rcetob_2)) &
valid_mask)
tcflow_soil = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_soil[:] = _IC_NODATA
tcflow_soil[valid_mask] = 0.
tcflow_soil[decompose_mask] = potential_flow[decompose_mask]
return tcflow_soil
def calc_tcflow_som1c_2(
aminrl_1, aminrl_2, som1c_2, som1e_2_1, som1e_2_2, rceto2_1,
rceto2_2, defac, dec3_2, eftext, anerb, pheff_metab):
"""Calculate total flow out of soil SOM1.
The total potential flow of C out of soil SOM1 is calculated
according to the effect of soil texture, anaerobic conditions,
and soil pH. The actual flow is limited by the availability of N
and P. N and P may be supplied by the mineral source, or by the
element (N or P) in the decomposing stock.
Parameters:
aminrl_1 (numpy.ndarray): derived, average surface mineral N
aminrl_2 (numpy.ndarray): derived, average surface mineral P
som1c_2 (numpy.ndarray): state variable, C in soil SOM1
som1e_2_1 (numpy.ndarray): state variable, N in soil SOM1
som1e_2_2 (numpy.ndarray): state variable, P in soil SOM1
rceto2_1 (numpy.ndarray): derived, required C/N ratio for
material decomposing to soil SOM2
rceto2_2 (numpy.ndarray): derived, required C/P ratio for
material decomposing to soil SOM2
defac (numpy.ndarray): derived, decomposition factor
dec3_2 (numpy.ndarray): parameter, maximum decomposition rate
eftext (numpy.ndarray): derived, effect of soil texture on
decomposition rate
anerb (numpy.ndarray): derived, effect of soil anaerobic conditions
on decomposition rate
pheff_metab (numpy.ndarray): derived, effect of soil pH on
decomposition rate
Returns:
tcflow_som1c_2, total flow of C out of soil SOM1
"""
valid_mask = (
(~numpy.isclose(aminrl_1, _SV_NODATA)) &
(~numpy.isclose(aminrl_2, _SV_NODATA)) &
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som1e_2_1, _SV_NODATA)) &
(~numpy.isclose(som1e_2_2, _SV_NODATA)) &
(rceto2_1 != _TARGET_NODATA) &
(rceto2_2 != _TARGET_NODATA) &
(defac != _TARGET_NODATA) &
(dec3_2 != _IC_NODATA) &
(eftext != _TARGET_NODATA) &
(anerb != _TARGET_NODATA) &
(pheff_metab != _TARGET_NODATA))
potential_flow = numpy.zeros(aminrl_1.shape, dtype=numpy.float32)
potential_flow[valid_mask] = (
som1c_2[valid_mask] * defac[valid_mask] * dec3_2[valid_mask] *
eftext[valid_mask] * anerb[valid_mask] * 0.020833 *
pheff_metab[valid_mask])
decompose_mask = (
((aminrl_1 > 0.0000001) | ((som1c_2 / som1e_2_1) <= rceto2_1)) &
((aminrl_2 > 0.0000001) | ((som1c_2 / som1e_2_2) <= rceto2_2)) &
valid_mask)
tcflow_som1c_2 = numpy.empty(aminrl_1.shape, dtype=numpy.float32)
tcflow_som1c_2[:] = _IC_NODATA
tcflow_som1c_2[valid_mask] = 0.
tcflow_som1c_2[decompose_mask] = potential_flow[decompose_mask]
return tcflow_som1c_2
def calc_som3_flow(tcflow, fps, animpt, anerb):
"""Calculate the C that flows from soil SOM1 or SOM2 to SOM3.
The fraction of total flow leaving SOM1 or SOM2 that goes to SOM3 is
dependent on soil clay content and soil anaerobic conditions.
Parameters:
tcflow (numpy.ndarray): derived, total C leaving soil SOM1 or SOM2
fps (numpy.ndarray): derived, effect of soil clay content on
decomposition to SOM3
animpt (numpy.ndarray): parameter, slope of relationship between
anaerobic conditions and decomposition flow to SOM3
anerb (numpy.ndarray): derived, impact of soil anaerobic conditions
on decomposition
Returns:
tosom3, C flowing to SOM3
"""
valid_mask = (
(tcflow != _IC_NODATA) &
(fps != _IC_NODATA) &
(animpt != _IC_NODATA) &
(anerb != _TARGET_NODATA))
tosom3 = numpy.empty(tcflow.shape, dtype=numpy.float32)
tosom3[:] = _IC_NODATA
tosom3[valid_mask] = (
tcflow[valid_mask] * fps[valid_mask] *
(1. + animpt[valid_mask] * (1. - anerb[valid_mask])))
return tosom3
def calc_som2_flow(som2c_1, cmix, defac):
"""Calculate the C that flows from surface SOM2 to soil SOM2.
Some C flows from surface SOM2 to soil SOM2 via mixing. This flow is
controlled by the parameter cmix.
Parameters:
som2c_1 (numpy.ndarray): state variable, C in surface SOM2
cmix (numpy.ndarray): parameter, amount of C flowing via mixing
defac (numpy.ndarray): derived, decomposition factor
Returns:
tcflow, C flowing to soil SOM2 via mixing
"""
valid_mask = (
(~numpy.isclose(som2c_1, _SV_NODATA)) &
(cmix != _IC_NODATA) &
(defac != _TARGET_NODATA))
tcflow = numpy.empty(som2c_1.shape, dtype=numpy.float32)
tcflow[:] = _IC_NODATA
tcflow[valid_mask] = (
som2c_1[valid_mask] * cmix[valid_mask] * defac[valid_mask] *
0.020833)
return tcflow
def calc_respiration_mineral_flow(cflow, frac_co2, estatv, cstatv):
"""Calculate mineral flow of one element associated with respiration.
As material decomposes from one stock to another, some CO2 is lost
to microbial respiration and some nutrient (N or P) moves to the
mineral pool. Respir.f
Parameters:
cflow (numpy.ndarray): derived, C decomposing from one stock
to another
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
estatv (numpy.ndarray): state variable, iel (N or P) in the
decomposing stock
cstatv (numpy.ndarray): state variable, C in the decomposing
stock
Returns:
mineral_flow, flow of iel (N or P) accompanying respiration
"""
valid_mask = (
(cflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA) &
(~numpy.isclose(estatv, _SV_NODATA)) &
(~numpy.isclose(cstatv, _SV_NODATA)))
co2_loss = numpy.zeros(cflow.shape, dtype=numpy.float32)
co2_loss[valid_mask] = cflow[valid_mask] * frac_co2[valid_mask]
mineral_flow = numpy.empty(cflow.shape, dtype=numpy.float32)
mineral_flow[:] = _IC_NODATA
mineral_flow[valid_mask] = 0.
flow_mask = ((cstatv > 0) & valid_mask)
mineral_flow[flow_mask] = (
co2_loss[flow_mask] * estatv[flow_mask] / cstatv[flow_mask])
return mineral_flow
def update_gross_mineralization(gross_mineralization, mineral_flow):
"""Update gross N mineralization with current mineral flow.
Gross mineralization of N during decomposition is used to calculate
volatilization loss of N after decomposition. It is updated with N
mineral flow if mineral flow is positive.
Parameters:
gross_mineralization (numpy.ndarray): gross N mineralization during
decomposition
mineral_flow (numpy.ndarray): N mineral flow
Returns:
gromin_updated, updated gross mineralization
"""
valid_mask = (
(gross_mineralization != _TARGET_NODATA) &
(mineral_flow != _IC_NODATA))
gromin_updated = numpy.empty(
gross_mineralization.shape, dtype=numpy.float32)
gromin_updated[:] = _TARGET_NODATA
gromin_updated[valid_mask] = gross_mineralization[valid_mask]
update_mask = ((mineral_flow > 0) & valid_mask)
gromin_updated[update_mask] = (
gross_mineralization[update_mask] + mineral_flow[update_mask])
return gromin_updated
def calc_net_cflow(cflow, frac_co2):
"""Calculate net flow of C after loss to CO2.
As material decomposes from one stock to another, some C is lost to
CO2 through microbial respiration. Calculate the net flow of C after
subtracting losses to CO2.
Parameters:
cflow (numpy.ndarray): derived, C decomposing from one stock
to another
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
Returns:
net_cflow, amount of decomposing C that flows after accounting
for CO2 losses
"""
valid_mask = (
(cflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA))
co2_loss = numpy.zeros(cflow.shape, dtype=numpy.float32)
co2_loss[valid_mask] = cflow[valid_mask] * frac_co2[valid_mask]
net_cflow = numpy.empty(cflow.shape, dtype=numpy.float32)
net_cflow[:] = _IC_NODATA
net_cflow[valid_mask] = cflow[valid_mask] - co2_loss[valid_mask]
return net_cflow
def calc_net_cflow_tosom2(tcflow, frac_co2, tosom3, cleach):
"""Calculate net flow of C from soil SOM1 to soil SOM2.
The C flowing from soil SOM1 to SOM2 is the remainder of total flow
from SOM1, after accounting for losses to CO2 through respiration,
decomposition to SOM3, and leaching.
Parameters:
tcflow (numpy.ndarray): derived, total C decomposing from soil
SOM1
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
tosom3 (numpy.ndarray): derived, C flowing from SOM1 to SOM3
cleach (numpy.ndarray): derived, leached organic C
Returns:
net_tosom2, amount of C that flows from soil SOM1 to soil SOm2
"""
valid_mask = (
(tcflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA) &
(tosom3 != _IC_NODATA) &
(cleach != _TARGET_NODATA))
net_tosom2 = numpy.empty(tcflow.shape, dtype=numpy.float32)
net_tosom2[:] = _IC_NODATA
net_tosom2[valid_mask] = (
tcflow[valid_mask] - (tcflow[valid_mask] * frac_co2[valid_mask]) -
tosom3[valid_mask] - cleach[valid_mask])
return net_tosom2
def calc_net_cflow_tosom1(tcflow, frac_co2, tosom3):
"""Calculate net flow of C from soil SOM2 to soil SOM1.
The C flowing from soil SOM2 to SOM1 is the remainder of total flow
from SOM2, after accounting for losses to CO2 through respiration
and decomposition to SOM3.
Parameters:
tcflow (numpy.ndarray): derived, total C decomposing from soil
SOM1
frac_co2 (numpy.ndarray): parameter, fraction of decomposing
C lost as CO2
tosom3 (numpy.ndarray): derived, C flowing from SOM1 to SOM3
Returns:
net_tosom1, amount of C that flows from soil SOM2 to soil SOM1
"""
valid_mask = (
(tcflow != _IC_NODATA) &
(frac_co2 != _IC_NODATA) &
(tosom3 != _IC_NODATA))
net_tosom1 = numpy.empty(tcflow.shape, dtype=numpy.float32)
net_tosom1[:] = _IC_NODATA
net_tosom1[valid_mask] = (
tcflow[valid_mask] - (tcflow[valid_mask] * frac_co2[valid_mask]) -
tosom3[valid_mask])
return net_tosom1
def respiration(
tcflow_path, frac_co2_path, cstatv_path, estatv_path,
delta_estatv_path, delta_minerl_1_iel_path, gromin_1_path=None):
"""Calculate and apply flow of N or P during respiration.
Microbial respiration accompanies decomposition of most stocks.
Calculate the flow of one element (N or P) to the mineral pool, which
accompanies this respiration.
Parameters:
tcflow_path (string): path to raster containing flow of C that
is accompanied by respiration
frac_co2_path (string): path to raster containing fraction of
C lost to co2
cstatv_path (string): path to raster containing C state variable
of decomposing pool
estatv_path (string): path to raster containing iel (N or P) state
variable of decomposing pool
delta_estatv_path (string): path to raster containing change
in the iel state variable of decomposing pool
delta_minerl_1_iel_path (string): path to raster containing
change in surface mineral iel
gromin_1_path (string): path to raster containing gross
mineralization of N
Side effects:
modifies or creates the raster indicated by `delta_estatv_path`
modifies or creates the raster indicated by `delta_minerl_1_iel_path`
modifies or creates the raster indicated by `gromin_1_path`, if
supplied
Returns:
None
"""
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='d_statv_temp', dir=PROCESSING_DIR) as d_statv_temp_file:
d_statv_temp_path = d_statv_temp_file.name
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
tcflow_path, frac_co2_path, estatv_path,
cstatv_path]],
calc_respiration_mineral_flow, operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
# mineral flow is removed from the decomposing iel state variable
shutil.copyfile(delta_estatv_path, d_statv_temp_path)
raster_difference(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
delta_estatv_path, _IC_NODATA)
# mineral flow is added to surface mineral iel
shutil.copyfile(delta_minerl_1_iel_path, d_statv_temp_path)
raster_sum(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
delta_minerl_1_iel_path, _IC_NODATA)
if gromin_1_path:
shutil.copyfile(gromin_1_path, d_statv_temp_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
d_statv_temp_path,
operand_temp_path]],
update_gross_mineralization, gromin_1_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up
os.remove(operand_temp_path)
os.remove(d_statv_temp_path)
def nutrient_flow(
cflow_path, cstatv_donating_path, estatv_donating_path, rcetob_path,
minerl_1_path, d_estatv_donating_path, d_estatv_receiving_path,
d_minerl_path, gromin_path=None):
"""Calculate and apply the flow of one nutrient accompanying C.
As C decomposes from one compartment to another, nutrients (N and P)
also flow from the donating compartment to the receiving compartment.
Some N or P may also flow to or from the mineral pool. Calculate and
apply the flow of iel (N or P) accompanying the given flow of C.
Parameters:
cflow_path (string): path to raster containing the flow of C
from the donating to the receiving pool
cstatv_donating_path (string): path to raster containing the C
state variable in the donating pool
estatv_donating_path (string): path to raster containing the iel
(N or P) in the donating pool
rcetob_path (string): path to raster containing required C/iel
ratio in the receiving pool
minerl_1_path (string): path to raster containing surface mineral iel
d_estatv_donating_path (string): path to raster containing change
in iel in the donating pool
d_estatv_receiving_path (string): path to raster containing change
in iel in the receiving pool
d_minerl_path (string): path to raster containing change in surface
mineral iel
gromin_path (string): path to raster containing gross mineralization
of N
Side effects:
modifies or creates the raster indicated by `d_estatv_donating_path`
modifies or creates the raster indicated by `d_estatv_receiving_path`
modifies or creates the raster indicated by `d_minerl_path`
modifies or creates the raster indicated by `gromin_path`, if supplied
Returns:
None
"""
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='d_statv_temp', dir=PROCESSING_DIR) as d_statv_temp_file:
d_statv_temp_path = d_statv_temp_file.name
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cflow_path, cstatv_donating_path, rcetob_path,
estatv_donating_path, minerl_1_path]],
esched('material_leaving_a'), operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(d_estatv_donating_path, d_statv_temp_path)
raster_difference(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
d_estatv_donating_path, _IC_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cflow_path, cstatv_donating_path, rcetob_path,
estatv_donating_path, minerl_1_path]],
esched('material_arriving_b'), operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(d_estatv_receiving_path, d_statv_temp_path)
raster_sum(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
d_estatv_receiving_path, _IC_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cflow_path, cstatv_donating_path, rcetob_path,
estatv_donating_path, minerl_1_path]],
esched('mineral_flow'), operand_temp_path, gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(d_minerl_path, d_statv_temp_path)
raster_sum(
d_statv_temp_path, _IC_NODATA, operand_temp_path, _IC_NODATA,
d_minerl_path, _IC_NODATA)
if gromin_path:
shutil.copyfile(gromin_path, d_statv_temp_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
d_statv_temp_path, operand_temp_path]],
update_gross_mineralization, gromin_path,
gdal.GDT_Float32, _TARGET_NODATA)
# clean up
os.remove(operand_temp_path)
os.remove(d_statv_temp_path)
def calc_c_leach(amov_2, tcflow, omlech_3, orglch):
"""Calculate the amount of C leaching from soil SOM1 to stream flow.
Some C leaches from soil SOM1 if the water flow out of soil layer 2
is above a critical level.
Parameters:
amov_2 (numpy.ndarray): derived, moisture flowing out of soil layer
2
tcflow (numpy.ndarray): derived, total flow of C out of soil SOM1
omlech_3 (numpy.ndarray): parameter, threshold value for amov_2
orglch (numpy.ndarray): derived, effect of sand content on leaching
rate
Returns:
cleach, C leaching from soil SOM1 to stream flow
"""
valid_mask = (
(amov_2 != _TARGET_NODATA) &
(tcflow != _IC_NODATA) &
(omlech_3 != _IC_NODATA) &
(orglch != _IC_NODATA))
cleach = numpy.empty(amov_2.shape, dtype=numpy.float32)
cleach[:] = _TARGET_NODATA
cleach[valid_mask] = 0
linten = numpy.zeros(amov_2.shape)
linten[valid_mask] = numpy.minimum(
(1. - (omlech_3[valid_mask] - amov_2[valid_mask]) /
omlech_3[valid_mask]), 1.)
leach_mask = ((amov_2 > 0) & valid_mask)
cleach[leach_mask] = (
tcflow[leach_mask] * orglch[leach_mask] * linten[leach_mask])
return cleach
def remove_leached_iel(
som1c_2_path, som1e_2_iel_path, cleach_path, d_som1e_2_iel_path,
iel):
"""Remove N or P leached from soil SOM1.
As soil SOM1 decomposes into SOM3, some of N and P is lost from SOM1
through leaching. The amount lost is calculated from the amount of C
leaching from the soil and the proportion of iel (N or P) in soil SOM1.
Parameters:
som1c_2_path (string): path to raster containing C in soil SOM1
som1e_2_iel_path (string): path to raster containing iel in soil
SOM1
cleach_path (string): path to raster containing C leaching from
SOM1
d_som1e_2_iel_path (string): path to raster giving change in
som1e_2_iel
iel (int): index indicating N (iel == 1) or P (iel == 2))
Side effects:
modifies the raster indicated by `d_som1e_2_iel_path`
Returns:
None
"""
def calc_leached_N(som1c_2, som1e_2_1, cleach):
"""Calculate the N leaching from soil SOM1."""
valid_mask = (
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som1e_2_1, _SV_NODATA)) &
(som1c_2 > 0) &
(som1e_2_1 > 0) &
(cleach != _TARGET_NODATA))
rceof1_1 = numpy.zeros(som1c_2.shape)
rceof1_1[valid_mask] = som1c_2[valid_mask] / som1e_2_1[valid_mask] * 2.
orgflow = numpy.empty(som1c_2.shape, dtype=numpy.float32)
orgflow[:] = _IC_NODATA
orgflow[valid_mask] = cleach[valid_mask] / rceof1_1[valid_mask]
return orgflow
def calc_leached_P(som1c_2, som1e_2_2, cleach):
"""Calculate the P leaching from soil SOM1."""
valid_mask = (
(~numpy.isclose(som1c_2, _SV_NODATA)) &
(~numpy.isclose(som1e_2_2, _SV_NODATA)) &
(som1c_2 > 0) &
(som1e_2_2 > 0) &
(cleach != _TARGET_NODATA))
rceof1_2 = numpy.zeros(som1c_2.shape)
rceof1_2[valid_mask] = (
som1c_2[valid_mask] / som1e_2_2[valid_mask] * 35.)
orgflow = numpy.empty(som1c_2.shape, dtype=numpy.float32)
orgflow[:] = _IC_NODATA
orgflow[valid_mask] = cleach[valid_mask] / rceof1_2[valid_mask]
return orgflow
with tempfile.NamedTemporaryFile(
prefix='operand_temp', dir=PROCESSING_DIR) as operand_temp_file:
operand_temp_path = operand_temp_file.name
with tempfile.NamedTemporaryFile(
prefix='d_statv_temp', dir=PROCESSING_DIR) as d_statv_temp_file:
d_statv_temp_path = d_statv_temp_file.name
if iel == 1:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
som1c_2_path, som1e_2_iel_path, cleach_path]],
calc_leached_N, operand_temp_path,
gdal.GDT_Float32, _TARGET_NODATA)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
som1c_2_path, som1e_2_iel_path, cleach_path]],
calc_leached_P, operand_temp_path,
gdal.GDT_Float32, _TARGET_NODATA)
# remove leached iel from SOM1
shutil.copyfile(d_som1e_2_iel_path, d_statv_temp_path)
raster_difference(
d_statv_temp_path, _IC_NODATA,
operand_temp_path, _IC_NODATA,
d_som1e_2_iel_path, _IC_NODATA)
# clean up
os.remove(operand_temp_path)
os.remove(d_statv_temp_path)
def calc_pflow(pstatv, rate_param, defac):
"""Calculate the flow of mineral P flowing from one pool to another.
Mineral P contains multiple pools, including parent material, labile P,
sorbed and strongly sorbed P, and occluded P. Calculate the flow from one
mineral P pool to another.
Parameters:
pstatv (numpy.ndarray): state variable, P in donating mineral pool
rate_param (numpy.ndarray): parameter, base rate of flow
defac (numpy.ndarray): derived, decomposition rate
Returns:
pflow, mineral P flowing from donating to receiving pool
"""
valid_mask = (
(~numpy.isclose(pstatv, _SV_NODATA)) &
(rate_param != _IC_NODATA) &
(defac != _TARGET_NODATA))
pflow = numpy.empty(pstatv.shape, dtype=numpy.float64)
pflow[:] = _IC_NODATA
pflow[valid_mask] = (
pstatv[valid_mask] * rate_param[valid_mask] * defac[valid_mask] *
0.020833)
return pflow
def calc_pflow_to_secndy(minerl_lyr_2, pmnsec_2, fsol, defac):
"""Calculate the flow of mineral to secondary P in one soil layer.
P flows from the mineral pool of each soil layer into secondary P (strongly
sorbed P) according to the amount in the mineral pool and the amount of P
in solution.
Parameters:
minerl_lyr_2 (numpy.ndarray): state variable, mineral P in soil layer
lyr
pmnsec_2 (numpy.ndarray): parameter, base flow rate
fsol (numpy.ndarray): derived, fraction of P in solution
defac (numpy.ndarray): derived, decomposition factor
Returns:
fmnsec, flow of mineral P to secondary in one soil layer
"""
valid_mask = (
(~numpy.isclose(minerl_lyr_2, _SV_NODATA)) &
(pmnsec_2 != _IC_NODATA) &
(fsol != _TARGET_NODATA) &
(defac != _TARGET_NODATA))
fmnsec = numpy.empty(minerl_lyr_2.shape, dtype=numpy.float64)
fmnsec[:] = _IC_NODATA
fmnsec[valid_mask] = (
pmnsec_2[valid_mask] * minerl_lyr_2[valid_mask] *
(1. - fsol[valid_mask]) * defac[valid_mask] * 0.020833)
return fmnsec
def update_aminrl(
minerl_1_1_path, minerl_1_2_path, fsol_path, aminrl_1_path,
aminrl_2_path):
"""Update aminrl_1 and aminrl_2, average mineral N and P in surface soil.
Aminrl_1, average mineral N, and aminrl_2, average mineral P, represent
labile N or P available for decomposition. They are kept as a running
average of the minerl_1_1 (for N) or minerl_1_2 (for P) state variable
across decomposition time steps.
Parameters:
minerl_1_1_path (string): path to raster giving current mineral N
in soil layer 1
minerl_1_2_path (string): path to raster giving current mineral N
in soil layer 2
fsol_path (string): path to raster giving fraction of mineral P in
solution
aminrl_1_path (string): path to raster containing average mineral N
aminrl_2_path (string): path to raster containing average mineral P
Side effects:
modifies or creates the raster indicated by `aminrl_1_path`
modifies or creates the raster indicated by `aminrl_2_path
Returns:
None
"""
def update_aminrl_1(aminrl_1_prev, minerl_1_1):
"""Update average mineral N."""
valid_mask = (
(~numpy.isclose(aminrl_1_prev, _SV_NODATA)) &
(~numpy.isclose(minerl_1_1, _SV_NODATA)))
aminrl_1 = numpy.empty(aminrl_1_prev.shape, dtype=numpy.float32)
aminrl_1[:] = _SV_NODATA
aminrl_1[valid_mask] = (
aminrl_1_prev[valid_mask] + minerl_1_1[valid_mask] / 2.)
return aminrl_1
def update_aminrl_2(aminrl_2_prev, minerl_1_2, fsol):
"""Update average mineral P.
Average mineral P is calculated from the fraction of mineral P in
soil layer 1 that is in solution.
Parameters:
aminrl_2_prev (numpy.ndarray): derived, previous average surface
mineral P
minerl_1_2 (numpy.ndarray): state variable, current mineral P in
soil layer 1
fsol (numpy.ndarray): derived, fraction of labile P in solution
Returns:
aminrl_2, updated average mineral P
"""
valid_mask = (
(~numpy.isclose(aminrl_2_prev, _SV_NODATA)) &
(~numpy.isclose(minerl_1_2, _SV_NODATA)) &
(fsol != _TARGET_NODATA))
aminrl_2 = numpy.empty(aminrl_2_prev.shape, dtype=numpy.float32)
aminrl_2[:] = _SV_NODATA
aminrl_2[valid_mask] = (
aminrl_2_prev[valid_mask] +
(minerl_1_2[valid_mask] * fsol[valid_mask]) / 2.)
return aminrl_2
with tempfile.NamedTemporaryFile(
prefix='aminrl_prev', dir=PROCESSING_DIR) as aminrl_prev_file:
aminrl_prev_path = aminrl_prev_file.name
shutil.copyfile(aminrl_1_path, aminrl_prev_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [aminrl_prev_path, minerl_1_1_path]],
update_aminrl_1, aminrl_1_path, gdal.GDT_Float32, _SV_NODATA)
shutil.copyfile(aminrl_2_path, aminrl_prev_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aminrl_prev_path, minerl_1_2_path, fsol_path]],
update_aminrl_2, aminrl_2_path, gdal.GDT_Float32, _SV_NODATA)
# clean up
os.remove(aminrl_prev_path)
def sum_biomass(
weighted_live_c, weighted_dead_c, strucc_1, metabc_1, elitst):
"""Calculate total biomass for the purposes of soil shading.
Total aboveground biomass for the purposes of soil shading is the sum
of live biomass, standing dead biomass, and litter. The impact of
litter is modifed by the parameter elitst.
Parameters:
weighted_live_c (numpy.ndarray): derived, sum of the state variable
aglivc across plant functional types
weighted_dead_c (numpy.ndarray): derived, sum of the state variable
stdedc across plant functional types
strucc_1 (numpy.ndarray): state variable, surface structural c
metabc_1 (numpy.ndarray): state variable, surface metabolic c
elitst (numpy.ndarray): parameter, effect of litter on soil
temperature relative to live and standing dead biomass
Returns:
biomass, total biomass for purposes of soil shading
"""
valid_mask = (
(weighted_live_c != _TARGET_NODATA) &
(weighted_dead_c != _TARGET_NODATA) &
(~numpy.isclose(strucc_1, _SV_NODATA)) &
(~numpy.isclose(metabc_1, _SV_NODATA)) &
(elitst != _IC_NODATA))
biomass = numpy.empty(weighted_live_c.shape, dtype=numpy.float32)
biomass[:] = _TARGET_NODATA
biomass[valid_mask] = (
(weighted_live_c[valid_mask] + weighted_dead_c[valid_mask]) * 2.5 +
(strucc_1[valid_mask] + metabc_1[valid_mask]) * 2.5 *
elitst[valid_mask])
return biomass
def _decomposition(
aligned_inputs, current_month, month_index, pft_id_set,
site_param_table, year_reg, month_reg, prev_sv_reg, pp_reg, sv_reg):
"""Update soil C, N and P after decomposition.
C, N and P move from one surface or soil stock to another depending on the
availability of N and P in the decomposing stock. This function covers
lines 118-323 in Simsom.f, including decomp.f, litdec.f, somdec.f, and
pschem.f.
Parameters:
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including precipitation, temperature, and
site spatial index
current_month (int): month of the year, such that current_month=1
indicates January
month_index (int): month of the simulation, such that month_index=13
indicates month 13 of the simulation
pft_id_set (set): set of integers identifying plant functional types
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
year_reg (dict): map of key, path pairs giving paths to annual
precipitation and annual N deposition rasters
month_reg (dict): map of key, path pairs giving paths to intermediate
calculated values that are shared between submodels
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
pp_reg (dict): map of key, path pairs giving persistent parameters
including required ratios for decomposition, the effect of soil
texture on decomposition rate, and the effect of soil texture on
the rate of organic leaching
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
creates all rasters in sv_reg pertaining to structural, metabolic,
som1, som2, and som3 C, N, and P; mineral N and P; and parent,
secondary, and occluded mineral P
Returns:
None
"""
def calc_N_fixation(precip, annual_precip, baseNdep, epnfs_2):
"""Calculate monthly atmospheric N fixation.
Atmospheric N fixation for the month is calculated from annual N
deposition, calculated once per year, according to the ratio of monthly
precipitation to annual precipitation. Total N fixed in this month is
scheduled to be added to the surface mineral N pool. Lines 193-205,
Simsom.f
Parameters:
precip (numpy.ndarray): input, monthly precipitation
annual_precip (numpy.ndarray): derived, annual precipitation
baseNdep (numpy.ndarray): derived, annual atmospheric N deposition
epnfs_2 (numpy.ndarray): parameter, intercept of regression
predicting N deposition from annual precipitation
Returns:
wdfxm, atmospheric N deposition for the current month
"""
valid_mask = (
(~numpy.isclose(precip, precip_nodata)) &
(annual_precip != _TARGET_NODATA) &
(annual_precip > 0) &
(baseNdep != _TARGET_NODATA) &
(epnfs_2 != _IC_NODATA))
wdfxm = numpy.zeros(precip.shape, dtype=numpy.float32)
wdfxm[valid_mask] = (
baseNdep[valid_mask] *
(precip[valid_mask] / annual_precip[valid_mask]) +
epnfs_2[valid_mask] *
numpy.minimum(annual_precip[valid_mask], 100.) *
(precip[valid_mask] / annual_precip[valid_mask]))
return wdfxm
def calc_rprpet(pevap, snowmelt, avh2o_3, precip):
"""Calculate the ratio of precipitation to ref evapotranspiration.
The ratio of precipitation or snowmelt to reference evapotranspiration
influences agdefac and bgdefac, the above- and belowground
decomposition factors.
Parameters:
pevap (numpy.ndarray): derived, reference evapotranspiration
snowmelt (numpy.ndarray): derived, snowmelt occuring this month
avh2o_3 (numpy.ndarray): derived, moisture in top two soil layers
precip (numpy.ndarray): input, precipitation for this month
Returns:
rprpet, the ratio of precipitation or snowmelt to reference
evapotranspiration
"""
valid_mask = (
(pevap != _TARGET_NODATA) &
(snowmelt != _TARGET_NODATA) &
(avh2o_3 != _TARGET_NODATA) &
(~numpy.isclose(precip, precip_nodata)))
rprpet = numpy.empty(pevap.shape, dtype=numpy.float32)
rprpet[:] = _TARGET_NODATA
snowmelt_mask = (valid_mask & (snowmelt > 0) & (pevap > 0))
rprpet[snowmelt_mask] = snowmelt[snowmelt_mask] / pevap[snowmelt_mask]
no_melt_mask = (valid_mask & (snowmelt <= 0))
rprpet[no_melt_mask] = (
(avh2o_3[no_melt_mask] + precip[no_melt_mask]) /
pevap[no_melt_mask])
return rprpet
def calc_bgwfunc(rprpet):
"""Calculate the impact of belowground water content on decomposition.
Bgwfunc reflects the effect of soil moisture on decomposition and is
also used to calculate shoot senescence due to water stress. It is
calculated from the ratio of soil water in the top two soil layers to
reference evapotranspiration.
Parameters:
rprpet (numpy.ndarray): derived, ratio of precipitation or snowmelt
to reference evapotranspiration
Returns:
bgwfunc, the effect of soil moisture on decomposition
"""
valid_mask = (rprpet != _TARGET_NODATA)
bgwfunc = numpy.empty(rprpet.shape, dtype=numpy.float32)
bgwfunc[:] = _TARGET_NODATA
bgwfunc[valid_mask] = (
1. / (1. + 30 * numpy.exp(-8.5 * rprpet[valid_mask])))
bgwfunc[(valid_mask & (rprpet > 9))] = 1
return bgwfunc
def calc_stemp(
biomass, snow, max_temp, min_temp, daylength, pmntmp, pmxtmp):
"""Calculate mean soil surface temperature for decomposition.
Soil surface temperature is modified from monthly temperature inputs
by estimated impacts of shading by aboveground biomass and litter, and
estimated daylength. Surftemp.f
Parameters:
biomass (numpy.ndarray): derived, sum of aboveground biomass and
surface litter across plant functional types
snow (numpy.ndarray): state variable, current snowpack
max_temp (numpy.ndarray): input, maximum temperature this month
min_temp (numpy.ndarray): input, minimum temperature this month
daylength (numpy.ndarray): derived, estimated hours of daylight
pmntmp (numpy.ndarray): parameter, effect of biomass on minimum
surface temperature
pmxtmp (numpy.ndarray): parameter, effect of biomass on maximum
surface temperature
Returns:
stemp, mean soil surface temperature for decomposition
"""
valid_mask = (
(biomass != _TARGET_NODATA) &
(snow != _SV_NODATA) &
(~numpy.isclose(max_temp, max_temp_nodata)) &
(~numpy.isclose(min_temp, min_temp_nodata)) &
(daylength != _TARGET_NODATA) &
(pmntmp != _IC_NODATA) &
(pmxtmp != _IC_NODATA))
tmxs = numpy.empty(biomass.shape, dtype=numpy.float32)
tmxs[valid_mask] = (
max_temp[valid_mask] + (25.4 / (1. + 18. * numpy.exp(
-0.2 * max_temp[valid_mask]))) *
(numpy.exp(pmxtmp[valid_mask] * biomass[valid_mask]) - 0.13))
tmns = numpy.empty(biomass.shape, dtype=numpy.float32)
tmns[valid_mask] = (
min_temp[valid_mask] + pmntmp[valid_mask] * biomass[valid_mask]
- 1.78)
shortday_mask = ((daylength < 12.) & valid_mask)
snow_mask = ((snow > 0) & valid_mask)
tmns_mlt = numpy.empty(biomass.shape, dtype=numpy.float32)
tmns_mlt[valid_mask] = (
((12. - daylength[valid_mask]) * 1.2 + 12.) / 24.)
tmns_mlt[shortday_mask] = (
((12 - daylength[shortday_mask]) * 3. + 12.) / 24.)
tmns_mlt[valid_mask] = numpy.clip(tmns_mlt[valid_mask], 0.05, 0.95)
stemp = numpy.empty(biomass.shape, dtype=numpy.float32)
stemp[:] = _TARGET_NODATA
stemp[valid_mask] = (
(1 - tmns_mlt[valid_mask]) * tmxs[valid_mask] +
tmns_mlt[valid_mask] * tmns[valid_mask])
stemp[snow_mask] = 0.
return stemp
def calc_defac(bgwfunc, stemp, teff_1, teff_2, teff_3, teff_4):
"""Calculate decomposition factor.
The decomposition factor influences the rate of surface and soil
decomposition and reflects the influence of soil temperature and
moisture. Lines 151-200, Cycle.f.
Parameters:
bgwfunc (numpy.ndarray): derived, effect of soil moisture on
decomposition
stemp (numpy.ndarray): derived, average soil surface temperature
teff_1 (numpy.ndarray): parameter, x location of inflection point
for calculating the effect of soil temperature on decomposition
factor
teff_2 (numpy.ndarray): parameter, y location of inflection point
for calculating the effect of soil temperature on decomposition
factor
teff_3 (numpy.ndarray): parameter, step size for calculating the
effect of soil temperature on decomposition factor
teff_4 (numpy.ndarray): parameter, slope of the line at the
inflection point, for calculating the effect of soil
temperature on decomposition factor
Returns:
defac, aboveground and belowground decomposition factor
"""
valid_mask = (
(bgwfunc != _TARGET_NODATA) &
(teff_1 != _IC_NODATA) &
(teff_2 != _IC_NODATA) &
(teff_3 != _IC_NODATA) &
(teff_4 != _IC_NODATA))
tfunc = numpy.empty(bgwfunc.shape, dtype=numpy.float32)
tfunc[:] = _TARGET_NODATA
tfunc[valid_mask] = numpy.maximum(
0.01,
(teff_2[valid_mask] + (teff_3[valid_mask] / numpy.pi) *
numpy.arctan(numpy.pi * teff_4[valid_mask] *
(stemp[valid_mask] - teff_1[valid_mask]))) /
(teff_2[valid_mask] + (teff_3[valid_mask] / numpy.pi) *
numpy.arctan(numpy.pi * teff_4[valid_mask] *
(30.0 - teff_1[valid_mask]))))
defac = numpy.empty(bgwfunc.shape, dtype=numpy.float32)
defac[:] = _TARGET_NODATA
defac[valid_mask] = numpy.maximum(
0., tfunc[valid_mask] * bgwfunc[valid_mask])
return defac
def calc_pheff_struc(pH):
"""Calculate the effect of soil pH on decomp of structural material.
The effect of soil pH on decomposition rate is a multiplier ranging
from 0 to 1. The effect on decomposition of structural material
differs from the effect on decomposition of metabolic material in
the values of two constants.
Parameters:
pH (numpy.ndarray): input, soil pH
Returns:
pheff_struc, the effect of soil pH on decomposition rate of
structural material
"""
valid_mask = (~numpy.isclose(pH, pH_nodata))
pheff_struc = numpy.empty(pH.shape, dtype=numpy.float32)
pheff_struc[valid_mask] = numpy.clip(
(0.5 + (1.1 / numpy.pi) *
numpy.arctan(numpy.pi * 0.7 * (pH[valid_mask] - 4.))), 0, 1)
return pheff_struc
def calc_pheff_metab(pH):
"""Calculate the effect of soil pH on decomp of metabolic material.
The effect of soil pH on decomposition rate is a multiplier ranging
from 0 to 1. The effect on decomposition of structural material
differs from the effect on decomposition of metabolic material in
the values of two constants.
Parameters:
pH (numpy.ndarray): input, soil pH
Returns:
pheff_metab, the effect of soil pH on decomposition rate of
metabolic material
"""
valid_mask = (~numpy.isclose(pH, pH_nodata))
pheff_metab = numpy.empty(pH.shape, dtype=numpy.float32)
pheff_metab[valid_mask] = numpy.clip(
(0.5 + (1.14 / numpy.pi) *
numpy.arctan(numpy.pi * 0.7 * (pH[valid_mask] - 4.8))), 0, 1)
return pheff_metab
def calc_pheff_som3(pH):
"""Calculate the effect of soil pH on decomposition of SOM3.
The effect of soil pH on decomposition rate is a multiplier ranging
from 0 to 1. The effect on decomposition of SOM3 differs from the
effect of pH on decomposition of other pools in the value of
constants.
Parameters:
pH (numpy.ndarray): input, soil pH
Returns:
pheff_som3, the effect of soil pH on decomposition rate of
SOM3
"""
valid_mask = (~numpy.isclose(pH, pH_nodata))
pheff_metab = numpy.empty(pH.shape, dtype=numpy.float32)
pheff_metab[valid_mask] = numpy.clip(
(0.5 + (1.1 / numpy.pi) *
numpy.arctan(numpy.pi * 0.7 * (pH[valid_mask] - 3.))), 0, 1)
return pheff_metab
precip_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['precip_{}'.format(month_index)])['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
max_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
pH_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['ph_path'])['nodata'][0]
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'd_statv_temp', 'operand_temp', 'shwave', 'pevap', 'rprpet',
'daylength', 'sum_aglivc', 'sum_stdedc', 'biomass', 'stemp',
'defac', 'anerb', 'gromin_1', 'pheff_struc', 'pheff_metab',
'aminrl_1', 'aminrl_2', 'fsol', 'tcflow', 'tosom2',
'net_tosom2', 'tosom1', 'net_tosom1', 'tosom3', 'cleach',
'pheff_som3', 'pflow']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
for iel in [1, 2]:
for val in ['rceto1', 'rceto2', 'rceto3']:
temp_val_dict['{}_{}'.format(val, iel)] = os.path.join(
temp_dir, '{}.tif'.format('{}_{}'.format(val, iel)))
param_val_dict = {}
for val in [
'fwloss_4', 'elitst', 'pmntmp', 'pmxtmp', 'teff_1', 'teff_2',
'teff_3', 'teff_4', 'drain', 'aneref_1', 'aneref_2', 'aneref_3',
'sorpmx', 'pslsrb', 'strmax_1', 'dec1_1', 'pligst_1', 'strmax_2',
'dec1_2', 'pligst_2', 'rsplig', 'ps1co2_1', 'ps1co2_2', 'dec2_1',
'pcemic1_1_1', 'pcemic1_2_1', 'pcemic1_3_1', 'pcemic1_1_2',
'pcemic1_2_2', 'pcemic1_3_2', 'varat1_1_1', 'varat1_2_1',
'varat1_3_1', 'varat1_1_2', 'varat1_2_2', 'varat1_3_2', 'dec2_2',
'pmco2_1', 'pmco2_2', 'rad1p_1_1', 'rad1p_2_1', 'rad1p_3_1',
'rad1p_1_2', 'rad1p_2_2', 'rad1p_3_2', 'dec3_1', 'p1co2a_1',
'varat22_1_1', 'varat22_2_1', 'varat22_3_1', 'varat22_1_2',
'varat22_2_2', 'varat22_3_2', 'dec3_2', 'animpt', 'varat3_1_1',
'varat3_2_1', 'varat3_3_1', 'varat3_1_2', 'varat3_2_2',
'varat3_3_2', 'omlech_3', 'dec5_2', 'p2co2_2', 'dec5_1', 'p2co2_1',
'dec4', 'p3co2', 'cmix', 'pparmn_2', 'psecmn_2', 'nlayer',
'pmnsec_2', 'psecoc1', 'psecoc2', 'epnfs_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# shwave, shortwave radiation outside the atmosphere
_shortwave_radiation(
aligned_inputs['site_index'], current_month, temp_val_dict['shwave'])
# pet, reference evapotranspiration modified by fwloss parameter
_reference_evapotranspiration(
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
temp_val_dict['shwave'], param_val_dict['fwloss_4'],
temp_val_dict['pevap'])
# rprpet, ratio of precipitation to reference evapotranspiration
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['pevap'], month_reg['snowmelt'],
sv_reg['avh2o_3_path'],
aligned_inputs['precip_{}'.format(month_index)]]],
calc_rprpet, temp_val_dict['rprpet'], gdal.GDT_Float32,
_TARGET_NODATA)
# bgwfunc, effect of soil moisture on decomposition
pygeoprocessing.raster_calculator(
[(temp_val_dict['rprpet'], 1)],
calc_bgwfunc, month_reg['bgwfunc'], gdal.GDT_Float32,
_TARGET_NODATA)
# estimated daylength
_calc_daylength(
aligned_inputs['site_index'], current_month,
temp_val_dict['daylength'])
# total biomass for purposes of soil shading
for sv in ['aglivc', 'stdedc']:
weighted_sum_path = temp_val_dict['sum_{}'.format(sv)]
weighted_state_variable_sum(
sv, prev_sv_reg, aligned_inputs, pft_id_set, weighted_sum_path)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['sum_aglivc'], temp_val_dict['sum_stdedc'],
prev_sv_reg['strucc_1_path'], prev_sv_reg['metabc_1_path'],
param_val_dict['elitst']]],
sum_biomass, temp_val_dict['biomass'], gdal.GDT_Float32,
_TARGET_NODATA)
# stemp, soil surface temperature for the purposes of decomposition
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['biomass'], sv_reg['snow_path'],
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)],
temp_val_dict['daylength'], param_val_dict['pmntmp'],
param_val_dict['pmxtmp']]],
calc_stemp, temp_val_dict['stemp'], gdal.GDT_Float32,
_TARGET_NODATA)
# defac, decomposition factor calculated from soil temp and moisture
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
month_reg['bgwfunc'], temp_val_dict['stemp'],
param_val_dict['teff_1'], param_val_dict['teff_2'],
param_val_dict['teff_3'], param_val_dict['teff_4']]],
calc_defac, temp_val_dict['defac'], gdal.GDT_Float32,
_TARGET_NODATA)
# anerb, impact of soil anaerobic conditions on decomposition
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['rprpet'], temp_val_dict['pevap'],
param_val_dict['drain'], param_val_dict['aneref_1'],
param_val_dict['aneref_2'], param_val_dict['aneref_3']]],
calc_anerb, temp_val_dict['anerb'], gdal.GDT_Float32,
_TARGET_NODATA)
# initialize gromin_1, gross mineralization of N
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['gromin_1'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
# pH effect on decomposition for structural material
pygeoprocessing.raster_calculator(
[(aligned_inputs['ph_path'], 1)],
calc_pheff_struc, temp_val_dict['pheff_struc'], gdal.GDT_Float32,
_TARGET_NODATA)
# pH effect on decomposition for metabolic material
pygeoprocessing.raster_calculator(
[(aligned_inputs['ph_path'], 1)],
calc_pheff_metab, temp_val_dict['pheff_metab'], gdal.GDT_Float32,
_TARGET_NODATA)
# initialize aminrl_1 and aminrl_2
shutil.copyfile(prev_sv_reg['minerl_1_1_path'], temp_val_dict['aminrl_1'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['minerl_1_2_path'], param_val_dict['sorpmx'],
param_val_dict['pslsrb']]],
fsfunc, temp_val_dict['fsol'], gdal.GDT_Float32, _TARGET_NODATA)
raster_multiplication(
prev_sv_reg['minerl_1_2_path'], _SV_NODATA,
temp_val_dict['fsol'], _TARGET_NODATA,
temp_val_dict['aminrl_2'], _SV_NODATA)
# initialize current month state variables and delta state variable dict
nlayer_max = int(max(
val['nlayer'] for val in site_param_table.values()))
delta_sv_dict = {
'minerl_1_1': os.path.join(temp_dir, 'minerl_1_1.tif'),
'parent_2': os.path.join(temp_dir, 'parent_2.tif'),
'secndy_2': os.path.join(temp_dir, 'secndy_2.tif'),
'occlud': os.path.join(temp_dir, 'occlud.tif'),
}
for lyr in range(1, nlayer_max + 1):
state_var = 'minerl_{}_2'.format(lyr)
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
# initialize mineral N in current sv_reg
for lyr in range(1, nlayer_max + 1):
state_var = 'minerl_{}_1'.format(lyr)
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for compartment in ['strlig']:
for lyr in [1, 2]:
state_var = '{}_{}'.format(compartment, lyr)
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for compartment in ['som3']:
state_var = '{}c'.format(compartment)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for iel in [1, 2]:
state_var = '{}e_{}'.format(compartment, iel)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for compartment in ['struc', 'metab', 'som1', 'som2']:
for lyr in [1, 2]:
state_var = '{}c_{}'.format(compartment, lyr)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for iel in [1, 2]:
state_var = '{}e_{}_{}'.format(compartment, lyr, iel)
delta_sv_dict[state_var] = os.path.join(
temp_dir, '{}.tif'.format(state_var))
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for state_var in ['parent_2', 'secndy_2', 'occlud']:
shutil.copyfile(
prev_sv_reg['{}_path'.format(state_var)],
sv_reg['{}_path'.format(state_var)])
for dtm in range(4):
# initialize change (delta, d) in state variables for this decomp step
for state_var in delta_sv_dict.keys():
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], delta_sv_dict[state_var],
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[0])
if dtm == 0:
# schedule flow of N from atmospheric fixation to surface mineral
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['precip_{}'.format(month_index)],
year_reg['annual_precip_path'], year_reg['baseNdep_path'],
param_val_dict['epnfs_2']]],
calc_N_fixation, delta_sv_dict['minerl_1_1'],
gdal.GDT_Float32, _IC_NODATA)
# decomposition of structural material in surface and soil
for lyr in [1, 2]:
if lyr == 1:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['strucc_1_path'], sv_reg['struce_1_1_path'],
sv_reg['struce_1_2_path'], pp_reg['rnewas_1_1_path'],
pp_reg['rnewas_2_1_path'], param_val_dict['strmax_1'],
temp_val_dict['defac'], param_val_dict['dec1_1'],
param_val_dict['pligst_1'], sv_reg['strlig_1_path'],
temp_val_dict['pheff_struc']]],
calc_tcflow_strucc_1, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
else:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['strucc_2_path'], sv_reg['struce_2_1_path'],
sv_reg['struce_2_2_path'], pp_reg['rnewbs_1_1_path'],
pp_reg['rnewbs_2_1_path'], param_val_dict['strmax_2'],
temp_val_dict['defac'], param_val_dict['dec1_2'],
param_val_dict['pligst_2'], sv_reg['strlig_2_path'],
temp_val_dict['pheff_struc'], temp_val_dict['anerb']]],
calc_tcflow_strucc_2, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['strucc_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['strucc_{}'.format(lyr)], _IC_NODATA)
# structural material decomposes first to SOM2
raster_multiplication(
temp_val_dict['tcflow'], _IC_NODATA,
sv_reg['strlig_{}_path'.format(lyr)], _SV_NODATA,
temp_val_dict['tosom2'], _IC_NODATA)
# microbial respiration with decomposition to SOM2
respiration(
temp_val_dict['tosom2'], param_val_dict['rsplig'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tosom2'], param_val_dict['rsplig'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tosom2'], param_val_dict['rsplig']]],
calc_net_cflow, temp_val_dict['net_tosom2'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom2'], _IC_NODATA,
delta_sv_dict['som2c_{}'.format(lyr)], _IC_NODATA)
if lyr == 1:
rcetob = 'rnewas'
else:
rcetob = 'rnewbs'
# N and P flows from STRUC to SOM2
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
pp_reg['{}_1_2_path'.format(rcetob)],
sv_reg['minerl_1_1_path'],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['som2e_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
pp_reg['{}_2_2_path'.format(rcetob)],
sv_reg['minerl_1_2_path'],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['som2e_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
# structural material decomposes next to SOM1
raster_difference(
temp_val_dict['tcflow'], _IC_NODATA, temp_val_dict['tosom2'],
_IC_NODATA, temp_val_dict['tosom1'], _IC_NODATA)
# microbial respiration with decomposition to SOM1
respiration(
temp_val_dict['tosom1'],
param_val_dict['ps1co2_{}'.format(lyr)],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tosom1'],
param_val_dict['ps1co2_{}'.format(lyr)],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tosom1'],
param_val_dict['ps1co2_{}'.format(lyr)]]],
calc_net_cflow, temp_val_dict['net_tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom1'], _IC_NODATA,
delta_sv_dict['som1c_{}'.format(lyr)], _IC_NODATA)
if lyr == 1:
rcetob = 'rnewas'
else:
rcetob = 'rnewbs'
# N and P flows from STRUC to SOM1
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_1_path'.format(lyr)],
pp_reg['{}_1_1_path'.format(rcetob)],
sv_reg['minerl_1_1_path'],
delta_sv_dict['struce_{}_1'.format(lyr)],
delta_sv_dict['som1e_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['strucc_{}_path'.format(lyr)],
sv_reg['struce_{}_2_path'.format(lyr)],
pp_reg['{}_2_1_path'.format(rcetob)],
sv_reg['minerl_1_2_path'],
delta_sv_dict['struce_{}_2'.format(lyr)],
delta_sv_dict['som1e_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
# decomposition of metabolic material in surface and soil to SOM1
for lyr in [1, 2]:
if lyr == 1:
for iel in [1, 2]:
# required ratio for surface metabolic decomposing to SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['metabe_1_{}_path'.format(iel)],
sv_reg['metabc_1_path'],
param_val_dict['pcemic1_1_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)],
param_val_dict['pcemic1_3_{}'.format(iel)]]],
_aboveground_ratio,
temp_val_dict['rceto1_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['metabc_1_path'], sv_reg['metabe_1_1_path'],
sv_reg['metabe_1_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec2_1'],
temp_val_dict['pheff_metab']]],
calc_tcflow_surface, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
else:
for iel in [1, 2]:
# required ratio for soil metabolic decomposing to SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_{}'.format(iel)],
param_val_dict['varat1_1_{}'.format(iel)],
param_val_dict['varat1_2_{}'.format(iel)],
param_val_dict['varat1_3_{}'.format(iel)]]],
_belowground_ratio,
temp_val_dict['rceto1_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['metabc_2_path'], sv_reg['metabe_2_1_path'],
sv_reg['metabe_2_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec2_2'], temp_val_dict['pheff_metab'],
temp_val_dict['anerb']]],
calc_tcflow_soil, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['metabc_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['metabc_{}'.format(lyr)], _IC_NODATA)
# microbial respiration with decomposition to SOM1
respiration(
temp_val_dict['tcflow'],
param_val_dict['pmco2_{}'.format(lyr)],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_1_path'.format(lyr)],
delta_sv_dict['metabe_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'],
param_val_dict['pmco2_{}'.format(lyr)],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_2_path'.format(lyr)],
delta_sv_dict['metabe_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'],
param_val_dict['pmco2_{}'.format(lyr)]]],
calc_net_cflow, temp_val_dict['net_tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_{}'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom1'], _IC_NODATA,
delta_sv_dict['som1c_{}'.format(lyr)], _IC_NODATA)
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_1_path'.format(lyr)],
temp_val_dict['rceto1_1'], sv_reg['minerl_1_1_path'],
delta_sv_dict['metabe_{}_1'.format(lyr)],
delta_sv_dict['som1e_{}_1'.format(lyr)],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom1'],
sv_reg['metabc_{}_path'.format(lyr)],
sv_reg['metabe_{}_2_path'.format(lyr)],
temp_val_dict['rceto1_2'], sv_reg['minerl_1_2_path'],
delta_sv_dict['metabe_{}_2'.format(lyr)],
delta_sv_dict['som1e_{}_2'.format(lyr)],
delta_sv_dict['minerl_1_2'])
# decomposition of surface SOM1 to surface SOM2: line 63 Somdec.f
for iel in [1, 2]:
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['som1c_1_path'],
sv_reg['som1e_1_{}_path'.format(iel)],
param_val_dict['rad1p_1_{}'.format(iel)],
param_val_dict['rad1p_2_{}'.format(iel)],
param_val_dict['rad1p_3_{}'.format(iel)],
param_val_dict['pcemic1_2_{}'.format(iel)]]],
calc_surface_som2_ratio,
temp_val_dict['rceto2_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som1c_1_path'], sv_reg['som1e_1_1_path'],
sv_reg['som1e_1_2_path'], temp_val_dict['rceto2_1'],
temp_val_dict['rceto2_2'], temp_val_dict['defac'],
param_val_dict['dec3_1'],
temp_val_dict['pheff_struc']]],
calc_tcflow_surface, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_1'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som1c_1'], _IC_NODATA)
# microbial respiration with decomposition to SOM2
respiration(
temp_val_dict['tcflow'], param_val_dict['p1co2a_1'],
sv_reg['som1c_1_path'], sv_reg['som1e_1_1_path'],
delta_sv_dict['som1e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['p1co2a_1'],
sv_reg['som1c_1_path'], sv_reg['som1e_1_2_path'],
delta_sv_dict['som1e_1_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p1co2a_1']]],
calc_net_cflow, temp_val_dict['net_tosom2'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_1'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom2'], _IC_NODATA,
delta_sv_dict['som2c_1'], _IC_NODATA)
# N and P flows from som1e_1 to som2e_1, line 123 Somdec.f
nutrient_flow(
temp_val_dict['net_tosom2'], sv_reg['som1c_1_path'],
sv_reg['som1e_1_1_path'], temp_val_dict['rceto2_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som1e_1_1'],
delta_sv_dict['som2e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom2'], sv_reg['som1c_1_path'],
sv_reg['som1e_1_2_path'], temp_val_dict['rceto2_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som1e_1_2'],
delta_sv_dict['som2e_1_2'], delta_sv_dict['minerl_1_2'])
# soil SOM1 decomposes to soil SOM3 and SOM2, line 137 Somdec.f
for iel in [1, 2]:
# required ratio for soil SOM1 decomposing to SOM2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_{}'.format(iel)],
param_val_dict['varat22_1_{}'.format(iel)],
param_val_dict['varat22_2_{}'.format(iel)],
param_val_dict['varat22_3_{}'.format(iel)]]],
_belowground_ratio,
temp_val_dict['rceto2_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_1_path'],
sv_reg['som1e_2_2_path'], temp_val_dict['rceto2_1'],
temp_val_dict['rceto2_2'], temp_val_dict['defac'],
param_val_dict['dec3_2'], pp_reg['eftext_path'],
temp_val_dict['anerb'], temp_val_dict['pheff_metab']]],
calc_tcflow_som1c_2, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som1c_2'], _IC_NODATA)
# microbial respiration with decomposition to SOM3, line 179
respiration(
temp_val_dict['tcflow'], pp_reg['p1co2_2_path'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_1_path'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], pp_reg['p1co2_2_path'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_2_path'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], pp_reg['fps1s3_path'],
param_val_dict['animpt'], temp_val_dict['anerb']]],
calc_som3_flow, temp_val_dict['tosom3'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(delta_sv_dict['som3c'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom3'], _IC_NODATA,
delta_sv_dict['som3c'], _IC_NODATA)
for iel in [1, 2]:
# required ratio for soil SOM1 decomposing to SOM3, line 198
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_{}'.format(iel)],
param_val_dict['varat3_1_{}'.format(iel)],
param_val_dict['varat3_2_{}'.format(iel)],
param_val_dict['varat3_3_{}'.format(iel)]]],
_belowground_ratio,
temp_val_dict['rceto3_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som1c_2_path'],
sv_reg['som1e_2_1_path'], temp_val_dict['rceto3_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som1e_2_1'],
delta_sv_dict['som3e_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som1c_2_path'],
sv_reg['som1e_2_2_path'], temp_val_dict['rceto3_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som1e_2_2'],
delta_sv_dict['som3e_2'], delta_sv_dict['minerl_1_2'])
# organic leaching: line 204 Somdec.f
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
month_reg['amov_2'], temp_val_dict['tcflow'],
param_val_dict['omlech_3'], pp_reg['orglch_path']]],
calc_c_leach, temp_val_dict['cleach'], gdal.GDT_Float32,
_TARGET_NODATA)
for iel in [1, 2]:
remove_leached_iel(
sv_reg['som1c_2_path'], sv_reg['som1e_2_{}_path'.format(iel)],
temp_val_dict['cleach'],
delta_sv_dict['som1e_2_{}'.format(iel)], iel)
# rest of flow from soil SOM1 goes to SOM2
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], pp_reg['p1co2_2_path'],
temp_val_dict['tosom3'], temp_val_dict['cleach']]],
calc_net_cflow_tosom2, temp_val_dict['net_tosom2'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom2'], _IC_NODATA,
delta_sv_dict['som2c_2'], _IC_NODATA)
# N and P flows from soil SOM1 to soil SOM2, line 257
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_1_path'],
temp_val_dict['rceto2_1'], sv_reg['minerl_1_1_path'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['som2e_2_1'],
delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom2'],
sv_reg['som1c_2_path'], sv_reg['som1e_2_2_path'],
temp_val_dict['rceto2_2'], sv_reg['minerl_1_2_path'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['som2e_2_2'],
delta_sv_dict['minerl_1_2'])
# soil SOM2 decomposing to soil SOM1 and SOM3, line 269
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som2c_2_path'], sv_reg['som2e_2_1_path'],
sv_reg['som2e_2_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec5_2'], temp_val_dict['pheff_metab'],
temp_val_dict['anerb']]],
calc_tcflow_soil, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_2'], _IC_NODATA)
respiration(
temp_val_dict['tcflow'], param_val_dict['pmco2_2'],
sv_reg['som2c_2_path'], sv_reg['som2e_2_1_path'],
delta_sv_dict['som2e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['pmco2_2'],
sv_reg['som2c_2_path'], sv_reg['som2e_2_2_path'],
delta_sv_dict['som2e_2_2'], delta_sv_dict['minerl_1_2'])
# soil SOM2 flows first to SOM3
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], pp_reg['fps2s3_path'],
param_val_dict['animpt'], temp_val_dict['anerb']]],
calc_som3_flow, temp_val_dict['tosom3'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(delta_sv_dict['som3c'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom3'], _IC_NODATA,
delta_sv_dict['som3c'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_1_path'], temp_val_dict['rceto3_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_2_1'],
delta_sv_dict['som3e_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom3'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_2_path'], temp_val_dict['rceto3_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_2_2'],
delta_sv_dict['som3e_2'], delta_sv_dict['minerl_1_2'])
# rest of flow from soil SOM2 goes to soil SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p2co2_2'],
temp_val_dict['tosom3']]],
calc_net_cflow_tosom1, temp_val_dict['net_tosom1'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['net_tosom1'], _IC_NODATA,
delta_sv_dict['som1c_2'], _IC_NODATA)
nutrient_flow(
temp_val_dict['net_tosom1'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_1_path'], temp_val_dict['rceto1_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_2_1'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['net_tosom1'], sv_reg['som2c_2_path'],
sv_reg['som2e_2_2_path'], temp_val_dict['rceto1_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_2_2'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['minerl_1_2'])
# surface SOM2 decomposes to surface SOM1
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som2c_1_path'], sv_reg['som2e_1_1_path'],
sv_reg['som2e_1_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec5_1'], temp_val_dict['pheff_struc']]],
calc_tcflow_surface, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_1'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_1'], _IC_NODATA)
respiration(
temp_val_dict['tcflow'], param_val_dict['p2co2_1'],
sv_reg['som2c_1_path'], sv_reg['som2e_1_1_path'],
delta_sv_dict['som2e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['p2co2_1'],
sv_reg['som2c_1_path'], sv_reg['som2e_1_2_path'],
delta_sv_dict['som2e_1_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p2co2_1']]],
calc_net_cflow, temp_val_dict['tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_1'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom1'], _IC_NODATA,
delta_sv_dict['som1c_1'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_1_path'], temp_val_dict['rceto1_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_1_1'],
delta_sv_dict['som1e_1_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_2_path'], temp_val_dict['rceto1_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_1_2'],
delta_sv_dict['som1e_1_2'], delta_sv_dict['minerl_1_2'])
# SOM3 decomposing to soil SOM1
# pH effect on decomposition of SOM3
pygeoprocessing.raster_calculator(
[(aligned_inputs['ph_path'], 1)],
calc_pheff_som3, temp_val_dict['pheff_som3'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['aminrl_1'], temp_val_dict['aminrl_2'],
sv_reg['som3c_path'], sv_reg['som3e_1_path'],
sv_reg['som3e_2_path'], temp_val_dict['rceto1_1'],
temp_val_dict['rceto1_2'], temp_val_dict['defac'],
param_val_dict['dec4'], temp_val_dict['pheff_som3'],
temp_val_dict['anerb']]],
calc_tcflow_soil, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som3c'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som3c'], _IC_NODATA)
respiration(
temp_val_dict['tcflow'], param_val_dict['p3co2'],
sv_reg['som3c_path'], sv_reg['som3e_1_path'],
delta_sv_dict['som3e_1'], delta_sv_dict['minerl_1_1'],
gromin_1_path=temp_val_dict['gromin_1'])
respiration(
temp_val_dict['tcflow'], param_val_dict['p3co2'],
sv_reg['som3c_path'], sv_reg['som3e_2_path'],
delta_sv_dict['som3e_2'], delta_sv_dict['minerl_1_2'])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tcflow'], param_val_dict['p3co2']]],
calc_net_cflow, temp_val_dict['tosom1'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['som1c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tosom1'], _IC_NODATA,
delta_sv_dict['som1c_2'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som3c_path'],
sv_reg['som3e_1_path'], temp_val_dict['rceto1_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som3e_1'],
delta_sv_dict['som1e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tosom1'], sv_reg['som3c_path'],
sv_reg['som3e_2_path'], temp_val_dict['rceto1_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som3e_2'],
delta_sv_dict['som1e_2_2'], delta_sv_dict['minerl_1_2'])
# Surface SOM2 flows to soil SOM2 via mixing
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['som2c_1_path'], param_val_dict['cmix'],
temp_val_dict['defac']]],
calc_som2_flow, temp_val_dict['tcflow'],
gdal.GDT_Float32, _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_1'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_1'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['som2c_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['tcflow'], _IC_NODATA,
delta_sv_dict['som2c_2'], _IC_NODATA)
# ratios for N and P entering soil som2 via mixing
raster_division(
sv_reg['som2c_1_path'], _SV_NODATA,
sv_reg['som2e_1_1_path'], _IC_NODATA,
temp_val_dict['rceto2_1'], _IC_NODATA)
raster_division(
sv_reg['som2c_1_path'], _SV_NODATA,
sv_reg['som2e_1_2_path'], _IC_NODATA,
temp_val_dict['rceto2_2'], _IC_NODATA)
nutrient_flow(
temp_val_dict['tcflow'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_1_path'], temp_val_dict['rceto2_1'],
sv_reg['minerl_1_1_path'], delta_sv_dict['som2e_1_1'],
delta_sv_dict['som2e_2_1'], delta_sv_dict['minerl_1_1'],
gromin_path=temp_val_dict['gromin_1'])
nutrient_flow(
temp_val_dict['tcflow'], sv_reg['som2c_1_path'],
sv_reg['som2e_1_2_path'], temp_val_dict['rceto2_2'],
sv_reg['minerl_1_2_path'], delta_sv_dict['som2e_1_2'],
delta_sv_dict['som2e_2_2'], delta_sv_dict['minerl_1_2'])
# P flow from parent to mineral: Pschem.f
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['parent_2_path'], param_val_dict['pparmn_2'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['parent_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['parent_2'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['minerl_1_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['minerl_1_2'], _IC_NODATA)
# P flow from secondary to mineral
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['secndy_2_path'], param_val_dict['psecmn_2'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['minerl_1_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['minerl_1_2'], _IC_NODATA)
# P flow from mineral to secondary
for lyr in range(1, nlayer_max + 1):
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_{}_2_path'.format(lyr)],
param_val_dict['pmnsec_2'], temp_val_dict['fsol'],
temp_val_dict['defac']]],
calc_pflow_to_secndy, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['minerl_{}_2'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['minerl_{}_2'.format(lyr)], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
# P flow from secondary to occluded
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['secndy_2_path'], param_val_dict['psecoc1'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['occlud'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['occlud'], _IC_NODATA)
# P flow from occluded to secondary
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['occlud_path'], param_val_dict['psecoc2'],
temp_val_dict['defac']]],
calc_pflow, temp_val_dict['pflow'], gdal.GDT_Float64,
_IC_NODATA)
shutil.copyfile(
delta_sv_dict['occlud'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['occlud'], _IC_NODATA)
shutil.copyfile(
delta_sv_dict['secndy_2'], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _IC_NODATA,
temp_val_dict['pflow'], _IC_NODATA,
delta_sv_dict['secndy_2'], _IC_NODATA)
# accumulate flows
compartment = 'som3'
state_var = '{}c'.format(compartment)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for iel in [1, 2]:
state_var = '{}e_{}'.format(compartment, iel)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for compartment in ['struc', 'metab', 'som1', 'som2']:
for lyr in [1, 2]:
state_var = '{}c_{}'.format(compartment, lyr)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for iel in [1, 2]:
state_var = '{}e_{}_{}'.format(compartment, lyr, iel)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for iel in [1, 2]:
state_var = 'minerl_1_{}'.format(iel)
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
for state_var in ['parent_2', 'secndy_2', 'occlud']:
shutil.copyfile(
sv_reg['{}_path'.format(state_var)],
temp_val_dict['operand_temp'])
raster_sum(
delta_sv_dict[state_var], _IC_NODATA,
temp_val_dict['operand_temp'], _SV_NODATA,
sv_reg['{}_path'.format(state_var)], _SV_NODATA)
# update aminrl: Simsom.f line 301
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
sv_reg['minerl_1_2_path'], param_val_dict['sorpmx'],
param_val_dict['pslsrb']]],
fsfunc, temp_val_dict['fsol'], gdal.GDT_Float32, _TARGET_NODATA)
update_aminrl(
sv_reg['minerl_1_1_path'], sv_reg['minerl_1_2_path'],
temp_val_dict['fsol'], temp_val_dict['aminrl_1'],
temp_val_dict['aminrl_2'])
# volatilization loss of N: line 323 Simsom.f
raster_multiplication(
temp_val_dict['gromin_1'], _TARGET_NODATA,
pp_reg['vlossg_path'], _IC_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA)
shutil.copyfile(
sv_reg['minerl_1_1_path'], temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
sv_reg['minerl_1_1_path'], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def partit(
cpart_path, epart_1_path, epart_2_path, frlign_path,
site_index_path, site_param_table, lyr, sv_reg):
"""Partition incoming material into structural and metabolic pools.
When organic material is added to the soil, for example as dead
biomass falls and becomes litter, or when organic material is added
from animal waste, it is partitioned into structural (STRUCC_lyr) and
metabolic (METABC_lyr) material according to the ratio of lignin to N in
the residue. As residue is partitioned, some N and P may be directly
absorbed from surface mineral N or P into the residue.
Parameters:
cpart_path (string): path to raster containing C in incoming material
that is to be partitioned
epart_1_path (string): path to raster containing N in incoming
material
epart_2_path (string): path to raster containing P in incoming
material
frlign_path (string): path to raster containing fraction of incoming
material that is lignin
site_index_path (string): path to site spatial index raster
site_param_table (dict): map of site spatial index to dictionaries
that contain site-level parameters
lyr (int): layer which is receiving the incoming material (i.e.,
1=surface layer, 2=soil layer)
sv_reg (dict): map of key, path pairs giving paths to current state
variables
Side effects:
modifies the rasters indicated by the following paths:
sv_reg['minerl_1_1_path']
sv_reg['minerl_1_2_path']
sv_reg['metabc_{}_path'.format(lyr)]
sv_reg['strucc_{}_path'.format(lyr)]
sv_reg['metabe_{}_1_path'.format(lyr)]
sv_reg['metabe_{}_2_path'.format(lyr)]
sv_reg['struce_{}_1_path'.format(lyr)]
sv_reg['struce_{}_2_path'.format(lyr)]
sv_reg['strlig_{}_path'.format(lyr)]
Returns:
None
"""
def calc_dirabs(
cpart, epart_iel, minerl_1_iel, damr_lyr_iel, pabres, damrmn_iel):
"""Calculate direct absorption of mineral N or P.
When organic material is added to the soil, some mineral N or P may
be directly absorbed from the surface mineral layer into the incoming
material. the amount transferred depends on the N or P in the incoming
material and the required C/N or C/P ratio of receiving material.
Parameters:
cpart (numpy.ndarray): derived, C in incoming material
epart_iel (numpy.ndarray): derived, <iel> in incoming material
minerl_1_iel (numpy.ndarray): state variable, surface mineral <iel>
damr_lyr_iel (numpy.ndarray): parameter, fraction of iel in lyr
absorbed by residue
pabres (numpy.ndarray): parameter, amount of residue which will
give maximum direct absorption of iel
damrmn_iel (numpy.ndarray): parameter, minimum C/iel ratio allowed
in residue after direct absorption
Returns:
dirabs_iel, <iel> (N or P) absorbed from the surface mineral pool
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(epart_iel != _TARGET_NODATA) &
(~numpy.isclose(minerl_1_iel, _SV_NODATA)) &
(damr_lyr_iel != _IC_NODATA) &
(pabres != _IC_NODATA) &
(damrmn_iel != _IC_NODATA))
dirabs_iel = numpy.empty(cpart.shape, dtype=numpy.float32)
dirabs_iel[:] = _TARGET_NODATA
dirabs_iel[valid_mask] = 0.
minerl_mask = ((minerl_1_iel >= 0) & valid_mask)
dirabs_iel[minerl_mask] = (
damr_lyr_iel[minerl_mask] * minerl_1_iel[minerl_mask] *
numpy.maximum(cpart[minerl_mask] / pabres[minerl_mask], 1.))
# rcetot: C/E ratio of incoming material
rcetot = numpy.empty(cpart.shape, dtype=numpy.float32)
rcetot[:] = _IC_NODATA
e_sufficient_mask = (((epart_iel + dirabs_iel) > 0) & valid_mask)
rcetot[valid_mask] = 0
rcetot[e_sufficient_mask] = (
cpart[e_sufficient_mask] / (
epart_iel[e_sufficient_mask] + dirabs_iel[e_sufficient_mask]))
dirabs_mod_mask = ((rcetot < damrmn_iel) & valid_mask)
dirabs_iel[dirabs_mod_mask] = numpy.maximum(
cpart[dirabs_mod_mask] / damrmn_iel[dirabs_mod_mask] -
epart_iel[dirabs_mod_mask], 0.)
return dirabs_iel
def calc_d_metabc_lyr(cpart, epart_1, dirabs_1, frlign, spl_1, spl_2):
"""Calculate the change in metabolic C after addition of new material.
Parameters:
cpart (numpy.ndarray): C in incoming material
epart_1 (numpy.ndarray): N in incoming material
dirabs_1 (numpy.ndarray): derived, direct aborption of mineral N
into incoming material
frlign (numpy.ndarray): fraction of incoming material which is
lignin
spl_1 (numpy.ndarray): parameter, intercept of regression
predicting fraction of residue going to metabolic
spl_2 (numpy.ndarray): parameter, slope of regression predicting
fraction of residue going to metabolic
Returns:
d_metabc_lyr, change in metabc_lyr
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(epart_1 != _TARGET_NODATA) &
(dirabs_1 != _TARGET_NODATA) &
(frlign != _TARGET_NODATA) &
(spl_1 != _IC_NODATA) &
(spl_2 != _IC_NODATA))
movt_mask = ((cpart > 0) & valid_mask)
# rlnres: ratio of lignin to N in the incoming material
rlnres = numpy.empty(cpart.shape, dtype=numpy.float32)
rlnres[:] = _TARGET_NODATA
rlnres[valid_mask] = 0.
rlnres[movt_mask] = (
frlign[movt_mask] / (
(epart_1[movt_mask] + dirabs_1[movt_mask]) /
(cpart[movt_mask] * 2.5)))
# frmet: fraction of cpart that goes to metabolic
frmet = numpy.empty(cpart.shape, dtype=numpy.float32)
frmet[:] = _TARGET_NODATA
frmet[valid_mask] = (
spl_1[valid_mask] - spl_2[valid_mask] * rlnres[valid_mask])
lign_exceeded_mask = ((frlign > (1. - frmet)) & valid_mask)
frmet[lign_exceeded_mask] = 1. - frlign[lign_exceeded_mask]
d_metabc_lyr = numpy.empty(cpart.shape, dtype=numpy.float32)
d_metabc_lyr[:] = _TARGET_NODATA
d_metabc_lyr[valid_mask] = cpart[valid_mask] * frmet[valid_mask]
return d_metabc_lyr
def calc_d_strucc_lyr(cpart, d_metabc_lyr):
"""Calculate change in structural C after addition of new material.
Parameters:
cpart (numpy.ndarray): derived, C in incoming material
d_metabc_lyr (numpy.ndarray) derived, change in metabc_lyr
Returns:
d_strucc_lyr, change in strucc_lyr
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(d_metabc_lyr != _TARGET_NODATA))
d_strucc_lyr = numpy.empty(cpart.shape, dtype=numpy.float32)
d_strucc_lyr[:] = _TARGET_NODATA
d_strucc_lyr[valid_mask] = cpart[valid_mask] - d_metabc_lyr[valid_mask]
return d_strucc_lyr
def calc_d_struce_lyr_iel(d_strucc_lyr, rcestr_iel):
"""Calculate the change in N or P in structural material in layer lyr.
Parameters:
d_strucc_lyr (numpy.ndarray): change in strucc_lyr with addition of
incoming material
rcestr_iel (numpy.ndarray): parameter, C/<iel> ratio for structural
material
Returns:
d_struce_lyr_iel, change in structural N or P in layer lyr
"""
valid_mask = (
(d_strucc_lyr != _TARGET_NODATA) &
(rcestr_iel != _IC_NODATA))
d_struce_lyr_iel = numpy.empty(d_strucc_lyr.shape, dtype=numpy.float32)
d_struce_lyr_iel[valid_mask] = (
d_strucc_lyr[valid_mask] / rcestr_iel[valid_mask])
return d_struce_lyr_iel
def calc_d_metabe_lyr_iel(cpart, epart_iel, dirabs_iel, d_struce_lyr_iel):
"""Calculate the change in N or P in metabolic material in layer lyr.
Parameters:
cpart (numpy.ndarray): C in incoming material
epart_iel (numpy.ndarray): <iel> in incoming material
dirabs_iel (numpy.ndarray): <iel> absorbed from the surface mineral
pool
d_struce_lyr_iel (numpy.ndarray): change in structural N or P in
layer lyr
Returns:
d_metabe_lyr_iel, change in metabolic N or P in layer lyr
"""
valid_mask = (
(cpart != _TARGET_NODATA) &
(epart_iel != _TARGET_NODATA) &
(dirabs_iel != _TARGET_NODATA) &
(d_struce_lyr_iel != _TARGET_NODATA))
d_metabe_lyr_iel = numpy.empty(cpart.shape, dtype=numpy.float32)
d_metabe_lyr_iel[:] = _TARGET_NODATA
d_metabe_lyr_iel[valid_mask] = (
epart_iel[valid_mask] + dirabs_iel[valid_mask] -
d_struce_lyr_iel[valid_mask])
return d_metabe_lyr_iel
def calc_d_strlig_lyr(frlign, d_strucc_lyr, cpart, strlig_lyr, strucc_lyr):
"""Calculate change in fraction of lignin in structural material.
Parameters:
frlign (numpy.ndarray): fraction of incoming material which is
lignin
d_strucc_lyr (numpy.ndarray): change in strucc_lyr with addition of
incoming material
cpart (numpy.ndarray): C in incoming material
strlig_lyr (numpy.ndarray): state variable, lignin in structural
material in receiving layer
strucc_lyr (numpy.ndarray): state variable, C in structural
material in layer lyr
Returns:
d_strlig_lyr, change in fraction of lignin in structural material
in layer lyr
"""
valid_mask = (
(frlign != _TARGET_NODATA) &
(d_strucc_lyr != _TARGET_NODATA) &
(cpart != _TARGET_NODATA) &
(~numpy.isclose(strlig_lyr, _SV_NODATA)) &
(~numpy.isclose(strucc_lyr, _SV_NODATA)))
movt_mask = ((cpart > 0) & valid_mask)
fligst = numpy.empty(frlign.shape, dtype=numpy.float32)
fligst[:] = _TARGET_NODATA
fligst[valid_mask] = 1.
fligst[movt_mask] = numpy.minimum(
frlign[movt_mask] / (
d_strucc_lyr[movt_mask] / cpart[movt_mask]), 1.)
strlig_lyr_mod = numpy.empty(frlign.shape, dtype=numpy.float32)
strlig_lyr_mod[:] = _TARGET_NODATA
strlig_lyr_mod[valid_mask] = (
((strlig_lyr[valid_mask] * strucc_lyr[valid_mask]) +
(fligst[valid_mask] * d_strucc_lyr[valid_mask])) /
(strucc_lyr[valid_mask] + d_strucc_lyr[valid_mask]))
d_strlig_lyr = numpy.empty(frlign.shape, dtype=numpy.float32)
d_strlig_lyr[:] = _IC_NODATA
d_strlig_lyr[valid_mask] = (
strlig_lyr_mod[valid_mask] - strlig_lyr[valid_mask])
return d_strlig_lyr
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'dirabs_1', 'dirabs_2', 'd_metabc_lyr', 'd_strucc_lyr',
'd_struce_lyr_iel', 'd_statv_temp', 'operand_temp']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
for val in [
'damr_{}_1'.format(lyr), 'damr_{}_2'.format(lyr), 'pabres',
'damrmn_1', 'damrmn_2', 'spl_1', 'spl_2', 'rcestr_1',
'rcestr_2']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(site_index_path, 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# direct absorption of N and P from surface mineral layer
for iel in [1, 2]:
if iel == 1:
epart_path = epart_1_path
else:
epart_path = epart_2_path
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, epart_path,
sv_reg['minerl_1_{}_path'.format(iel)],
param_val_dict['damr_{}_{}'.format(lyr, iel)],
param_val_dict['pabres'],
param_val_dict['damrmn_{}'.format(iel)]]],
calc_dirabs, temp_val_dict['dirabs_{}'.format(iel)],
gdal.GDT_Float32, _TARGET_NODATA)
# remove direct absorption from surface mineral layer
shutil.copyfile(
sv_reg['minerl_1_{}_path'.format(iel)],
temp_val_dict['d_statv_temp'])
raster_difference(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['dirabs_{}'.format(iel)], _TARGET_NODATA,
sv_reg['minerl_1_{}_path'.format(iel)], _SV_NODATA)
# partition C into structural and metabolic
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, epart_1_path, temp_val_dict['dirabs_1'],
frlign_path, param_val_dict['spl_1'],
param_val_dict['spl_2']]],
calc_d_metabc_lyr, temp_val_dict['d_metabc_lyr'], gdal.GDT_Float32,
_TARGET_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, temp_val_dict['d_metabc_lyr']]],
calc_d_strucc_lyr, temp_val_dict['d_strucc_lyr'], gdal.GDT_Float32,
_TARGET_NODATA)
shutil.copyfile(
sv_reg['metabc_{}_path'.format(lyr)], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['d_metabc_lyr'], _TARGET_NODATA,
sv_reg['metabc_{}_path'.format(lyr)], _SV_NODATA)
shutil.copyfile(
sv_reg['strucc_{}_path'.format(lyr)], temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['d_strucc_lyr'], _TARGET_NODATA,
sv_reg['strucc_{}_path'.format(lyr)], _SV_NODATA)
# partition N and P into structural and metabolic
for iel in [1, 2]:
if iel == 1:
epart_path = epart_1_path
else:
epart_path = epart_2_path
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['d_strucc_lyr'],
param_val_dict['rcestr_{}'.format(iel)]]],
calc_d_struce_lyr_iel, temp_val_dict['d_struce_lyr_iel'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['struce_{}_{}_path'.format(lyr, iel)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['d_struce_lyr_iel'], _TARGET_NODATA,
sv_reg['struce_{}_{}_path'.format(lyr, iel)], _SV_NODATA)
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
cpart_path, epart_path,
temp_val_dict['dirabs_{}'.format(iel)],
temp_val_dict['d_struce_lyr_iel']]],
calc_d_metabe_lyr_iel, temp_val_dict['operand_temp'],
gdal.GDT_Float32, _TARGET_NODATA)
shutil.copyfile(
sv_reg['metabe_{}_{}_path'.format(lyr, iel)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
sv_reg['metabe_{}_{}_path'.format(lyr, iel)], _SV_NODATA)
# adjust fraction of lignin in receiving structural pool
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
frlign_path, temp_val_dict['d_strucc_lyr'], cpart_path,
sv_reg['strlig_{}_path'.format(lyr)],
sv_reg['strucc_{}_path'.format(lyr)]]],
calc_d_strlig_lyr, temp_val_dict['operand_temp'], gdal.GDT_Float32,
_IC_NODATA)
shutil.copyfile(
sv_reg['strlig_{}_path'.format(lyr)],
temp_val_dict['d_statv_temp'])
raster_sum(
temp_val_dict['d_statv_temp'], _SV_NODATA,
temp_val_dict['operand_temp'], _IC_NODATA,
sv_reg['strlig_{}_path'.format(lyr)], _SV_NODATA)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_fall_standing_dead(stdedc, fallrt):
"""Calculate delta C with fall of standing dead.
Material falls from standing dead biomass into surface litter
according to a constant monthly fall rate.
Parameters:
stdedc (numpy.ndarray): state variable, C in standing dead material
fallrt (numpy.ndarray): parameter, fraction of standing dead material
that falls each month
Returns:
delta_c_standing_dead, change in C in standing dead
"""
valid_mask = (
(~numpy.isclose(stdedc, _SV_NODATA)) &
(fallrt != _IC_NODATA))
delta_c_standing_dead = numpy.empty(stdedc.shape, dtype=numpy.float32)
delta_c_standing_dead[:] = _TARGET_NODATA
delta_c_standing_dead[valid_mask] = stdedc[valid_mask] * fallrt[valid_mask]
return delta_c_standing_dead
def calc_root_death(
average_temperature, rtdtmp, rdr, avh2o_1, deck5, bglivc):
"""Calculate delta C with death of roots.
Material flows from roots into soil organic matter pools due to root death.
Root death rate is limited by average temperature and influenced by
available soil moisture. Change in C is calculated by multiplying the root
death rate by bglivc, C in live roots.
Parameters:
average_temperature (numpy.ndarray): derived, average temperature for
the current month
rtdtmp (numpy.ndarray): parameter, temperature below which root death
does not occur
rdr (numpy.ndarray): parameter, maximum root death rate at very dry
soil conditions
avh2o_1 (numpy.ndarray): state variable, water available to the current
plant functional type for growth
deck5 (numpy.ndarray): parameter, level of available soil water at
which root death rate is half maximum
bglivc (numpy.ndarray): state variable, C in belowground live roots
Returns:
delta_c_root_death, change in C during root death
"""
valid_mask = (
(average_temperature != _IC_NODATA) &
(rdr != _IC_NODATA) &
(~numpy.isclose(avh2o_1, _SV_NODATA)) &
(deck5 != _IC_NODATA) &
(~numpy.isclose(bglivc, _SV_NODATA)))
root_death_rate = numpy.empty(bglivc.shape, dtype=numpy.float32)
root_death_rate[:] = _TARGET_NODATA
root_death_rate[valid_mask] = 0.
temp_sufficient_mask = ((average_temperature >= rtdtmp) & valid_mask)
root_death_rate[temp_sufficient_mask] = numpy.minimum(
rdr[temp_sufficient_mask] *
(1.0 - avh2o_1[temp_sufficient_mask] / (
deck5[temp_sufficient_mask] + avh2o_1[temp_sufficient_mask])),
0.95)
delta_c_root_death = numpy.empty(bglivc.shape, dtype=numpy.float32)
delta_c_root_death[:] = _TARGET_NODATA
delta_c_root_death[valid_mask] = (
root_death_rate[valid_mask] * bglivc[valid_mask])
return delta_c_root_death
def calc_delta_iel(c_state_variable, iel_state_variable, delta_c):
"""Calculate the change in N or P accompanying change in C.
As C flows out of standing dead biomass or roots, the amount of iel
(N or P) flowing out of the same pool is calculated from the change in C
according to the ratio of C to iel in the pool.
Parameters:
c_state_variable (numpy.ndarray): state variable, C in the pool that is
losing material
iel_state_variable (numpy.ndarray): state variable, N or P in the pool
that is losing material
delta_c (numpy.ndarray): derived, change in C. Change in N or P is
proportional to this amount.
Returns:
delta_iel, change in N or P accompanying the change in C
"""
valid_mask = (
(~numpy.isclose(c_state_variable, _SV_NODATA)) &
(~numpy.isclose(iel_state_variable, _SV_NODATA)) &
(c_state_variable > 0) &
(delta_c != _TARGET_NODATA))
delta_iel = numpy.empty(c_state_variable.shape, dtype=numpy.float32)
delta_iel[:] = _TARGET_NODATA
delta_iel[valid_mask] = (
(iel_state_variable[valid_mask] / c_state_variable[valid_mask]) *
delta_c[valid_mask])
return delta_iel
def _death_and_partition(
state_variable, aligned_inputs, site_param_table, current_month,
year_reg, pft_id_set, veg_trait_table, prev_sv_reg, sv_reg):
"""Track movement of C, N and P from a pft-level state variable into soil.
Calculate C, N and P leaving the specified state variable and entering
surface or soil organic matter pools. Subtract the change in C, N and P
from the state variable tracked for each pft, sum up the amounts across
pfts, and distribute the sum of the material flowing from the state
variable to surface or soil structural and metabolic pools.
Parameters:
state_variable (string): string identifying the state variable that is
flowing into organic matter. Must be one of "stded" (for fall
of standing dead) or "bgliv" (for death of roots). If the state
variable is stded, material flowing from stded enters surface
structural and metabolic pools. If the state variable is bgliv,
material flowing from bgliv enters soil structural and metabolic
pools.
aligned_inputs (dict): map of key, path pairs indicating paths
to aligned model inputs, including temperature,
plant functional type composition, and site spatial index
site_param_table (dict): map of site spatial indices to dictionaries
containing site parameters
current_month (int): month of the year, such that current_month=1
indicates January
pft_id_set (set): set of integers identifying plant functional types
veg_trait_table (dict): map of pft id to dictionaries containing
plant functional type parameters
prev_sv_reg (dict): map of key, path pairs giving paths to state
variables for the previous month
sv_reg (dict): map of key, path pairs giving paths to state variables
for the current month
Side effects:
creates the rasters indicated by
sv_reg['<state_variable>c_<pft>_path'] for each pft
sv_reg['<state_variable>e_1_<pft>_path'] for each pft
sv_reg['<state_variable>e_2_<pft>_path'] for each pft
modifies the rasters indicated by
sv_reg['minerl_1_1_path']
sv_reg['minerl_1_2_path']
sv_reg['metabc_<lyr>_path']
sv_reg['strucc_<lyr>_path']
sv_reg['metabe_<lyr>_1_path']
sv_reg['metabe_<lyr>_2_path']
sv_reg['struce_<lyr>_1_path']
sv_reg['struce_<lyr>_2_path']
sv_reg['strlig_<lyr>_path']
where lyr=1 if `state_variable` == 'stded'
lyr=2 if `state_variable` == 'bgliv'
Returns:
None
"""
def calc_avg_temp(max_temp, min_temp):
"""Calculate average temperature from maximum and minimum temp."""
valid_mask = (
(~numpy.isclose(max_temp, max_temp_nodata)) &
(~numpy.isclose(min_temp, min_temp_nodata)))
tave = numpy.empty(max_temp.shape, dtype=numpy.float32)
tave[:] = _IC_NODATA
tave[valid_mask] = (max_temp[valid_mask] + min_temp[valid_mask]) / 2.
return tave
temp_dir = tempfile.mkdtemp(dir=PROCESSING_DIR)
temp_val_dict = {}
for val in [
'tave', 'delta_c', 'delta_iel', 'delta_sv_weighted',
'operand_temp', 'sum_weighted_delta_C', 'sum_weighted_delta_N',
'sum_weighted_delta_P', 'weighted_lignin', 'sum_lignin',
'fraction_lignin']:
temp_val_dict[val] = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict = {}
# site-level parameters
val = 'deck5'
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
site_to_val = dict(
[(site_code, float(table[val])) for
(site_code, table) in site_param_table.items()])
pygeoprocessing.reclassify_raster(
(aligned_inputs['site_index'], 1), site_to_val, target_path,
gdal.GDT_Float32, _IC_NODATA)
# pft-level parameters
for val in['fallrt', 'rtdtmp', 'rdr']:
target_path = os.path.join(temp_dir, '{}.tif'.format(val))
param_val_dict[val] = target_path
# sum of material across pfts to be partitioned to organic matter
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_weighted_delta_C'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_weighted_delta_N'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_weighted_delta_P'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], temp_val_dict['sum_lignin'],
gdal.GDT_Float32, [_TARGET_NODATA], fill_value_list=[0])
max_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['max_temp_{}'.format(current_month)])['nodata'][0]
min_temp_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['min_temp_{}'.format(current_month)])['nodata'][0]
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
aligned_inputs['max_temp_{}'.format(current_month)],
aligned_inputs['min_temp_{}'.format(current_month)]]],
calc_avg_temp, temp_val_dict['tave'], gdal.GDT_Float32, _IC_NODATA)
for pft_i in pft_id_set:
pft_nodata = pygeoprocessing.get_raster_info(
aligned_inputs['pft_{}'.format(pft_i)])['nodata'][0]
# calculate change in C leaving the given state variable
if state_variable == 'stded':
fill_val = veg_trait_table[pft_i]['fallrt']
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], param_val_dict['fallrt'],
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['stdedc_{}_path'.format(pft_i)],
param_val_dict['fallrt']]],
calc_fall_standing_dead, temp_val_dict['delta_c'],
gdal.GDT_Float32, _TARGET_NODATA)
else:
for val in ['rtdtmp', 'rdr']:
fill_val = veg_trait_table[pft_i][val]
pygeoprocessing.new_raster_from_base(
aligned_inputs['site_index'], param_val_dict[val],
gdal.GDT_Float32, [_IC_NODATA], fill_value_list=[fill_val])
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
temp_val_dict['tave'],
param_val_dict['rtdtmp'],
param_val_dict['rdr'],
sv_reg['avh2o_1_{}_path'.format(pft_i)],
param_val_dict['deck5'],
prev_sv_reg['bglivc_{}_path'.format(pft_i)]]],
calc_root_death, temp_val_dict['delta_c'],
gdal.GDT_Float32, _TARGET_NODATA)
# subtract delta_c from the pft-level state variable
raster_difference(
prev_sv_reg['{}c_{}_path'.format(state_variable, pft_i)],
_SV_NODATA, temp_val_dict['delta_c'], _TARGET_NODATA,
sv_reg['{}c_{}_path'.format(state_variable, pft_i)], _SV_NODATA)
# calculate delta C weighted by % cover of this pft
raster_multiplication(
temp_val_dict['delta_c'], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA)
shutil.copyfile(
temp_val_dict['sum_weighted_delta_C'],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_C'], _TARGET_NODATA)
# calculate weighted fraction of flowing C which is lignin
if state_variable == 'stded':
frlign_path = year_reg['pltlig_above_{}'.format(pft_i)]
else:
frlign_path = year_reg['pltlig_below_{}'.format(pft_i)]
raster_multiplication(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
frlign_path, _TARGET_NODATA,
temp_val_dict['weighted_lignin'], _TARGET_NODATA)
shutil.copyfile(
temp_val_dict['sum_lignin'], temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['weighted_lignin'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_lignin'], _TARGET_NODATA)
for iel in [1, 2]:
# calculate N or P flowing out of the pft-level state variable
pygeoprocessing.raster_calculator(
[(path, 1) for path in [
prev_sv_reg['{}c_{}_path'.format(state_variable, pft_i)],
prev_sv_reg['{}e_{}_{}_path'.format(
state_variable, iel, pft_i)],
temp_val_dict['delta_c']]],
calc_delta_iel, temp_val_dict['delta_iel'],
gdal.GDT_Float32, _TARGET_NODATA)
# subtract delta_iel from the pft-level state variable
raster_difference(
prev_sv_reg['{}e_{}_{}_path'.format(
state_variable, iel, pft_i)], _SV_NODATA,
temp_val_dict['delta_iel'], _TARGET_NODATA,
sv_reg['{}e_{}_{}_path'.format(state_variable, iel, pft_i)],
_SV_NODATA)
# calculate delta iel weighted by % cover of this pft
raster_multiplication(
temp_val_dict['delta_iel'], _TARGET_NODATA,
aligned_inputs['pft_{}'.format(pft_i)], pft_nodata,
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA)
if iel == 1:
shutil.copyfile(
temp_val_dict['sum_weighted_delta_N'],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_N'], _TARGET_NODATA)
else:
shutil.copyfile(
temp_val_dict['sum_weighted_delta_P'],
temp_val_dict['operand_temp'])
raster_sum(
temp_val_dict['delta_sv_weighted'], _TARGET_NODATA,
temp_val_dict['operand_temp'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_P'], _TARGET_NODATA)
# partition sum of C, N and P into structural and metabolic pools
if state_variable == 'stded':
lyr = 1
else:
lyr = 2
raster_division(
temp_val_dict['sum_lignin'], _TARGET_NODATA,
temp_val_dict['sum_weighted_delta_C'], _TARGET_NODATA,
temp_val_dict['fraction_lignin'], _TARGET_NODATA)
partit(
temp_val_dict['sum_weighted_delta_C'],
temp_val_dict['sum_weighted_delta_N'],
temp_val_dict['sum_weighted_delta_P'],
temp_val_dict['fraction_lignin'],
aligned_inputs['site_index'], site_param_table, lyr, sv_reg)
# clean up temporary files
shutil.rmtree(temp_dir)
def calc_senescence_water_shading(
aglivc, bgwfunc, fsdeth_1, fsdeth_3, fsdeth_4):
"""Calculate shoot death due to water stress and shading.
In months where senescence is not scheduled to occur, some shoot death
may still occur due to water stress and shading.
Parameters:
aglivc (numpy.ndarray): state variable, carbon in aboveground live
biomass
bgwfunc (numpy.ndarray): derived, effect of soil moisture on
decomposition and shoot senescence
fsdeth_1 (numpy.ndarray): parameter, maximum shoot death rate at very
dry soil conditions
fsdeth_3 (numpy.ndarray): parameter, additional fraction of shoots
which die when aglivc is greater than fsdeth_4
fsdeth_4 (numpy.ndarray): parameter, threshold value for aglivc
above which shading increases senescence
Returns:
fdeth, fraction of aboveground live biomass that is converted to
standing dead
"""
valid_mask = (
(~numpy.isclose(aglivc, _SV_NODATA)) &
(bgwfunc != _TARGET_NODATA) &
(fsdeth_1 != _IC_NODATA) &
(fsdeth_3 != _IC_NODATA) &
(fsdeth_4 != _IC_NODATA))
fdeth = numpy.empty(aglivc.shape, dtype=numpy.float32)
fdeth[:] = _TARGET_NODATA
fdeth[valid_mask] = fsdeth_1[valid_mask] * (1. - bgwfunc[valid_mask])
shading_mask = ((aglivc > fsdeth_4) & valid_mask)
fdeth[shading_mask] = fdeth[shading_mask] + fsdeth_3[shading_mask]
fdeth[valid_mask] = | numpy.minimum(fdeth[valid_mask], 1.) | numpy.minimum |
# coding=utf-8
# Copyright 2019 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.
r"""Player from PPO2 cnn checkpoint.
Example usage with play_game script:
python3 -m gfootball.play_game \
--players "ppo2_cnn:left_players=1,checkpoint=$YOUR_PATH,policy=$POLICY"
$POLICY should be one of: cnn, impala_cnn, gfootball_impala_cnn.
"""
from baselines.common.policies import build_policy
from gfootball.env import football_action_set
from gfootball.env import observation_preprocessing
from gfootball.env import player_base
from gfootball.examples import models
import gym
import joblib
import numpy as np
import tensorflow.compat.v1 as tf
class Player(player_base.PlayerBase):
"""An agent loaded from PPO2 cnn model checkpoint."""
def __init__(self, player_config, env_config):
player_base.PlayerBase.__init__(self, player_config)
self._action_set = (env_config['action_set']
if 'action_set' in env_config else 'default')
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
self._sess = tf.Session(config=config)
self._player_prefix = 'player_{}'.format(player_config['index'])
stacking = 4 if player_config.get('stacked', True) else 1
policy = player_config.get('policy', 'cnn')
self._stacker = ObservationStacker(stacking)
with tf.variable_scope(self._player_prefix):
with tf.variable_scope('ppo2_model'):
policy_fn = build_policy(DummyEnv(self._action_set, stacking), policy)
self._policy = policy_fn(nbatch=1, sess=self._sess)
_load_variables(player_config['checkpoint'], self._sess,
prefix=self._player_prefix + '/')
def __del__(self):
self._sess.close()
def take_action(self, observation):
assert len(observation) == 1, 'Multiple players control is not supported'
observation = observation_preprocessing.generate_smm(observation)
observation = self._stacker.get(observation)
action = self._policy.step(observation)[0][0]
actions = [football_action_set.action_set_dict[self._action_set][action]]
return actions
def reset(self):
self._stacker.reset()
def _load_variables(load_path, sess, prefix='', remove_prefix=True):
"""Loads variables from checkpoint of policy trained by baselines."""
# Forked from address below since we needed loading from different var names:
# https://github.com/openai/baselines/blob/master/baselines/common/tf_util.py
variables = [v for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
if v.name.startswith(prefix)]
loaded_params = joblib.load(load_path)
restores = []
for v in variables:
v_name = v.name[len(prefix):] if remove_prefix else v.name
restores.append(v.assign(loaded_params[v_name]))
sess.run(restores)
class ObservationStacker(object):
"""Utility class that produces stacked observations."""
def __init__(self, stacking):
self._stacking = stacking
self._data = []
def get(self, observation):
if self._data:
self._data.append(observation)
self._data = self._data[-self._stacking:]
else:
self._data = [observation] * self._stacking
return | np.concatenate(self._data, axis=-1) | numpy.concatenate |
import numpy as np
from numpy.testing import assert_allclose
from qiskit.quantum_info import random_density_matrix
from mps_tomo.uncert import R_hat, iteration, pauli_proj
from mps_tomo.utils import fidelity, pauli_group
def test_pauli_proj():
NUM_QUBITS = 3
SEED = 7777
TOL = 100 * np.spacing(np.complex128(1.0).real)
dens_mat = random_density_matrix(2 ** NUM_QUBITS, seed=SEED)
reconstructed = sum(pauli_proj(dens_mat, p) for p in pauli_group(NUM_QUBITS))
assert_allclose(reconstructed, dens_mat, rtol=0.0, atol=TOL)
def test_R_hat():
TOL = 100 * np.spacing(np.complex128(1.0).real)
SEED = 7777
np.random.seed(SEED)
sigmas = [np.random.randn(4, 4) + 1j * np.random.randn(4, 4) for i in range(3)]
example = (
np.kron(sigmas[0], np.eye(4))
+ np.kron(np.kron(np.eye(2), sigmas[1]), np.eye(2))
+ np.kron(np.eye(4), sigmas[2])
)
assert_allclose(R_hat(sigmas, 4), example, rtol=0.0, atol=TOL)
def test_iteration_pure_W():
NUM_QUBITS = 5
SEED = 7777
TOL = 0.01
K = 2
np.random.seed(SEED)
dim = 2 ** NUM_QUBITS
state = np.zeros(dim, dtype=np.complex128)
for i in range(NUM_QUBITS):
state[1 << i] = 1
state /= np.linalg.norm(state)
dens_mat = np.outer(state, state.conj())
def reduce(qubit):
left_size = 2 ** qubit
reduced_size = 2 ** K
right_size = np.size(dens_mat, axis=0) // (left_size * reduced_size)
reshaped = np.reshape(
dens_mat,
(left_size, reduced_size, right_size, left_size, reduced_size, right_size),
)
return np.einsum("aibajb->ij", reshaped)
sigmas = (reduce(q) for q in range(NUM_QUBITS - K + 1))
y_vec = iteration(K, sigmas, NUM_QUBITS, max_its=100, delta=0.1)
overlap = np.abs(state.conj() @ y_vec) ** 2
assert_allclose(overlap, 1, rtol=0.0, atol=TOL)
def test_iteration_depolarising_W():
NUM_QUBITS = 5
SEED = 7777
TOL = 0.15
K = 2
DEPOLARISATION = 0.1
np.random.seed(SEED)
dim = 2 ** NUM_QUBITS
state = np.zeros(dim, dtype=np.complex128)
for i in range(NUM_QUBITS):
state[1 << i] = 1
state /= np.linalg.norm(state)
dens_mat = np.outer(state, state.conj())
dens_mat = (
DEPOLARISATION * (1 / dim) * np.eye(dim) + (1 - DEPOLARISATION) * dens_mat
)
purity = | np.trace(dens_mat @ dens_mat) | numpy.trace |
import tensorflow as tf
import numpy as np
import datetime as time
# class for the core of the architecture
class GNN:
def __init__(self, net, input_dim, output_dim, state_dim, max_it=50, optimizer=tf.train.AdamOptimizer, learning_rate=0.01, threshold=0.01, graph_based=False,
param=str(time.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')), config=None, tensorboard=False, mask_flag=False):
"""
create GNN instance. Feed this parameters:
:net: Net instance - it contains state network, output network, initialized weights, loss function and metric;
:input_dim: dimension of the input
:output_dim: dimension of the output
:state_dim: dimension for the state
:max_it: maximum number of iteration of the state convergence procedure
:optimizer: optimizer instance
:learning_rate: learning rate value
:threshold: value to establish the state convergence
:graph_based: flag to denote a graph based problem
:param: name of the experiment
:config: ConfigProto protocol buffer object, to set configuration options for a session
:tensorboard: boolean flag to activate tensorboard
"""
np.random.seed(0)
tf.set_random_seed(0)
self.tensorboard = tensorboard
self.max_iter = max_it
self.net = net
self.optimizer = optimizer(learning_rate, name="optim")
self.state_threshold = threshold
self.input_dim = input_dim
self.output_dim = output_dim
self.state_dim = state_dim
self.graph_based = graph_based
self.mask_flag = mask_flag
self.build()
self.session = tf.Session(config=config)
#self.session = tf.Session()
self.session.run(tf.global_variables_initializer())
self.init_l = tf.local_variables_initializer()
# parameter to monitor the learning via tensorboard and to save the model
if self.tensorboard:
self.merged_all = tf.summary.merge_all(key='always')
self.merged_train = tf.summary.merge_all(key='train')
self.merged_val = tf.summary.merge_all(key='val')
self.writer = tf.summary.FileWriter('tmp/' + param, self.session.graph)
# self.saver = tf.train.Saver()
# self.save_path = "tmp/" + param + "saves/model.ckpt"
def VariableState(self):
'''Define placeholders for input, output, state, state_old, arch-node conversion matrix'''
# placeholder for input and output
self.comp_inp = tf.placeholder(tf.float32, shape=(None, self.input_dim), name="input")
self.y = tf.placeholder(tf.float32, shape=(None, self.output_dim), name="target")
if self.mask_flag:
self.mask = tf.placeholder(tf.float32, name="mask")
# state(t) & state(t-1)
self.state = tf.placeholder(tf.float32, shape=(None, self.state_dim), name="state")
self.state_old = tf.placeholder(tf.float32, shape=(None, self.state_dim), name="old_state")
# arch-node conversion matrix
self.ArcNode = tf.sparse_placeholder(tf.float32, name="ArcNode")
# node-graph conversion matrix
if self.graph_based:
self.NodeGraph = tf.sparse_placeholder(tf.float32, name="NodeGraph")
else:
self.NodeGraph = tf.placeholder(tf.float32, name="NodeGraph")
def build(self):
'''build the architecture, setting variable, loss, training'''
# network
self.VariableState()
self.loss_op = self.Loop()
# loss
with tf.variable_scope('loss'):
if self.mask_flag:
self.loss = self.net.Loss(self.loss_op[0], self.y, mask=self.mask)
self.val_loss = self.net.Loss(self.loss_op[0], self.y, mask=self.mask)
else:
self.loss = self.net.Loss(self.loss_op[0], self.y)
# val loss
self.val_loss = self.net.Loss(self.loss_op[0], self.y)
if self.tensorboard:
self.summ_loss = tf.summary.scalar('loss', self.loss, collections=['train'])
self.summ_val_loss = tf.summary.scalar('val_loss', self.val_loss, collections=['val'])
# optimizer
with tf.variable_scope('train'):
self.grads = self.optimizer.compute_gradients(self.loss)
self.train_op = self.optimizer.apply_gradients(self.grads, name='train_op')
if self.tensorboard:
for index, grad in enumerate(self.grads):
tf.summary.histogram("{}-grad".format(self.grads[index][1].name), self.grads[index],
collections=['always'])
# metrics
with tf.variable_scope('metrics'):
if self.mask_flag:
self.metrics = self.net.Metric(self.y, self.loss_op[0], mask=self.mask)
else:
self.metrics = self.net.Metric(self.y, self.loss_op[0])
# val metric
with tf.variable_scope('val_metric'):
if self.mask_flag:
self.val_met = self.net.Metric(self.y, self.loss_op[0], mask=self.mask)
else:
self.val_met = self.net.Metric(self.y, self.loss_op[0])
if self.tensorboard:
self.summ_val_met = tf.summary.scalar('val_metric', self.val_met, collections=['always'])
def convergence(self, a, state, old_state, k):
with tf.variable_scope('Convergence'):
# body of the while cicle used to iteratively calculate state
# assign current state to old state
old_state = state
# grub states of neighboring node
gat = tf.gather(old_state, tf.cast(a[:, 1], tf.int32))
# slice to consider only label of the node and that of it's neighbor
# sl = tf.slice(a, [0, 1], [tf.shape(a)[0], tf.shape(a)[1] - 1])
# equivalent code
sl = a[:, 2:]
# concat with retrieved state
inp = tf.concat([sl, gat], axis=1)
# evaluate next state and multiply by the arch-node conversion matrix to obtain per-node states
layer1 = self.net.netSt(inp)
state = tf.sparse_tensor_dense_matmul(self.ArcNode, layer1)
# update the iteration counter
k = k + 1
return a, state, old_state, k
def condition(self, a, state, old_state, k):
# evaluate condition on the convergence of the state
with tf.variable_scope('condition'):
# evaluate distance by state(t) and state(t-1)
outDistance = tf.sqrt(tf.reduce_sum(tf.square(tf.subtract(state, old_state)), 1) + 0.00000000001)
# vector showing item converged or not (given a certain threshold)
checkDistanceVec = tf.greater(outDistance, self.state_threshold)
c1 = tf.reduce_any(checkDistanceVec)
c2 = tf.less(k, self.max_iter)
return tf.logical_and(c1, c2)
def Loop(self):
# call to loop for the state computation and compute the output
# compute state
with tf.variable_scope('Loop'):
k = tf.constant(0)
res, st, old_st, num = tf.while_loop(self.condition, self.convergence,
[self.comp_inp, self.state, self.state_old, k])
if self.tensorboard:
self.summ_iter = tf.summary.scalar('iteration', num, collections=['always'])
if self.graph_based:
# stf = tf.transpose(tf.matmul(tf.transpose(st), self.NodeGraph))
stf = tf.sparse_tensor_dense_matmul(self.NodeGraph, st)
else:
stf = st
out = self.net.netOut(stf)
return out, num
def Train(self, inputs, ArcNode, target, step, nodegraph=0.0, mask=None):
''' train methods: has to receive the inputs, arch-node matrix conversion, target,
and optionally nodegraph indicator '''
# Creating a SparseTEnsor with the feeded ArcNode Matrix
arcnode_ = tf.SparseTensorValue(indices=ArcNode.indices, values=ArcNode.values,
dense_shape=ArcNode.dense_shape)
if self.graph_based:
nodegraph = tf.SparseTensorValue(indices=nodegraph.indices, values=nodegraph.values,
dense_shape=nodegraph.dense_shape)
if self.mask_flag:
fd = {self.NodeGraph: nodegraph, self.comp_inp: inputs,
self.state: np.zeros((ArcNode.dense_shape[0], self.state_dim)),
self.state_old: | np.ones((ArcNode.dense_shape[0], self.state_dim)) | numpy.ones |
import sys
import importlib
import argparse
import numpy as np
import random
import cmath
import math
from dft import dft, inv_dft
from fft import fft, inv_fft
from rsa import *
#arguments for dft, fft, inverse dft and inverse fft
parameters1 = []
parameters2 = []
i=4
while i<2048:
param1 = list(np.random.randint(low = 0, high = 1000, size = i))
parameters1.append(param1)
param2 = list(np.random.randint(low = 0, high = 1000, size = i))
parameters2.append(param2)
i=i*2
#arguments for RSA encryption and decryption
VC = [[5,8,12,56], [0j, (2+1.1102230246251565e-16j), (1.4997597826618576e-32-2.4492935982947064e-16j), (2+4.440892098500626e-16j)]]
bits = []
for i in range(7, 11):
bits.append(2**i)
def test_case():
try:
for test in range(len(parameters1)):
VA = dft(parameters1[test])
np.allclose(VA, np.fft.fft(parameters1[test]))
print("Test Case", (test+1), "for the function DFT passed")
except:
print("Test Case", (test+1), "for the function DFT failed")
try:
for test in range(len(parameters1)):
VA = fft(parameters1[test])
np.allclose(VA, np.fft.fft(parameters1[test]))
print("Test Case", (test+1), "for the function FFT passed")
except:
print("Test Case", (test+1), "for the function FFT failed")
def test_case2():
try:
for test in range(len(VC)):
mat = VC[test]
mat2 = rsaHelper(mat)
mat = np.array(mat)
mat2 = np.array(mat2)
| np.array_equiv(mat, mat2) | numpy.array_equiv |
# -*- coding: utf-8 -*-
#
# Test basic functionality of ComputationalRoutine class
#
# Builtin/3rd party package imports
import os
import tempfile
import time
import pytest
import numpy as np
from glob import glob
from scipy import signal
# Local imports
from syncopy import __acme__
if __acme__:
import dask.distributed as dd
from syncopy.datatype import AnalogData
from syncopy.datatype.base_data import Selector
from syncopy.io import load
from syncopy.shared.computational_routine import ComputationalRoutine
from syncopy.shared.kwarg_decorators import unwrap_io, unwrap_cfg, unwrap_select
from syncopy.tests.misc import generate_artificial_data
# Decorator to decide whether or not to run dask-related tests
skip_without_acme = pytest.mark.skipif(not __acme__, reason="acme not available")
@unwrap_io
def lowpass(arr, b, a=None, noCompute=None, chunkShape=None):
if noCompute:
return arr.shape, arr.dtype
res = signal.filtfilt(b, a, arr.T, padlen=200).T
return res
class LowPassFilter(ComputationalRoutine):
computeFunction = staticmethod(lowpass)
def process_metadata(self, data, out):
if data.selection is not None:
chanSec = data.selection.channel
trl = data.selection.trialdefinition
else:
chanSec = slice(None)
trl = np.zeros((len(self.trialList), 3), dtype=int)
trial_lengths = np.diff(data.sampleinfo)
cnt = 0
for row, tlen in enumerate(trial_lengths):
trl[row, 0] = cnt
trl[row, 1] = cnt + tlen
trl[row, 2] = data._t0[row]
cnt += tlen
if not self.keeptrials:
trl = np.array([[0, out.data.shape[0], trl[0, 2]]], dtype=int)
out.trialdefinition = trl
out.samplerate = data.samplerate
out.channel = np.array(data.channel[chanSec])
@unwrap_cfg
@unwrap_select
def filter_manager(data, b=None, a=None,
out=None, select=None, chan_per_worker=None, keeptrials=True,
parallel=False, parallel_store=None, log_dict=None):
newOut = False
if out is None:
newOut = True
out = AnalogData(dimord=AnalogData._defaultDimord)
myfilter = LowPassFilter(b, a=a)
myfilter.initialize(data, out._stackingDim, chan_per_worker=chan_per_worker, keeptrials=keeptrials)
myfilter.compute(data, out,
parallel=parallel,
parallel_store=parallel_store,
log_dict=log_dict)
return out if newOut else None
class TestComputationalRoutine():
# Construct linear combination of low- and high-frequency sine waves
# and use an IIR filter to reconstruct the low-frequency component
nChannels = 32
nTrials = 8
fData = 2
fNoise = 64
fs = 1000
t = np.linspace(-1, 1, fs)
orig = np.sin(2 * np.pi * fData * t)
sig = orig + np.sin(2 * np.pi * fNoise * t)
cutoff = 50
b, a = signal.butter(8, 2 * cutoff / fs)
# Blow up the signal to have "channels" and "trials" and inflate the low-
# frequency component accordingly for ad-hoc comparisons later
sig = np.repeat(sig.reshape(-1, 1), axis=1, repeats=nChannels)
sig = np.tile(sig, (nTrials, 1))
orig = np.repeat(orig.reshape(-1, 1), axis=1, repeats=nChannels)
orig = np.tile(orig, (nTrials, 1))
# Construct artificial equidistant trial-definition array
trl = np.zeros((nTrials, 3), dtype="int")
for ntrial in range(nTrials):
trl[ntrial, :] = np.array([ntrial * fs, (ntrial + 1) * fs, -500])
# Create reference AnalogData objects with equidistant trial spacing
sigdata = AnalogData(data=sig, samplerate=fs, trialdefinition=trl,
dimord=["time", "channel"])
origdata = AnalogData(data=orig, samplerate=fs, trialdefinition=trl,
dimord=["time", "channel"])
# Set by-worker channel-count for channel-parallelization
chanPerWrkr = 7
# Data selections to be tested w/`sigdata`
sigdataSelections = [None,
{"trials": [3, 1, 0],
"channel": ["channel" + str(i) for i in range(12, 28)][::-1]},
{"trials": [0, 1, 2],
"channel": range(0, int(nChannels / 2)),
"toilim": [-0.25, 0.25]}]
# Data selections to be tested w/`artdata` generated below (use fixed but arbitrary
# random number seed to randomly select time-points for `toi` (with repetitions)
seed = np.random.RandomState(13)
artdataSelections = [None,
{"trials": [3, 1, 0],
"channel": ["channel" + str(i) for i in range(12, 28)][::-1],
"toi": None},
{"trials": [0, 1, 2],
"channel": range(0, int(nChannels / 2)),
"toilim": [-0.5, 0.6]}]
# Error tolerances and respective quality metrics (depend on data selection!)
tols = [1e-6, 1e-6, 1e-2]
metrix = [np.max, np.max, np.mean]
def test_sequential_equidistant(self):
for sk, select in enumerate(self.sigdataSelections):
sel = Selector(self.sigdata, select)
out = filter_manager(self.sigdata, self.b, self.a, select=select)
# check correct signal filtering (especially wrt data-selection)
if select is None:
reference = self.orig
else:
ref = []
for tk, trlno in enumerate(sel.trials):
ref.append(self.origdata.trials[trlno][sel.time[tk], sel.channel])
# check for correct time selection
assert np.array_equal(out.time[tk], self.sigdata.time[trlno][sel.time[tk]])
reference = np.vstack(ref)
assert self.metrix[sk](np.abs(out.data - reference)) < self.tols[sk]
assert np.array_equal(out.channel, self.sigdata.channel[sel.channel])
# ensure pre-selection is equivalent to in-place selection
if select is None:
selected = self.sigdata.selectdata()
else:
selected = self.sigdata.selectdata(**select)
out_sel = filter_manager(selected, self.b, self.a)
assert np.array_equal(out.data, out_sel.data)
assert | np.array_equal(out.channel, out_sel.channel) | numpy.array_equal |
"""
This module uses models from the Khalil paper.
"""
from __future__ import division
from scipy.special import cbrt
import numpy as np
from lmfit import Parameters
def qi_error(Q,Q_err,Q_e_real,Q_e_real_err,Q_e_imag,Q_e_imag_err):
"""
Compute error on Qi
Khalil et al defines Qi as 1/Qi = 1/Qr - Real(1/Qe), where Qe is
the complex coupling Q. This can be rewritten as:
$$ Qi = 1/(1/Q_r - \frac{Q_{e,real}}{Q_{e,real}^2 - Q_{e,imag}^2} $$
Assuming the errors are independent (which they seem to mostly be),
the error on Qi will then be:
$$ \Delta Q_i = \sqrt( (\Delta Q \diff{Qi}{Q})^2 + (\Delta Q_{e,real} \diff{Qi}{Q_{e,real}})^2 + (\Delta Q_{e,imag} \diff{Qi}{Q_{e,imag}})^2 )$$
The derivatives are:
$$ \diff{Qi}{Q} = \frac{(Qer^2-Qei^2)^2}{(Q Qer - Qer^2 + Qei^2)^2} $$
$$ \diff{Qi}{Qer} = -\frac{Qe^2(Qer^2 + Qei^2)}{(Q Qer - Qer^2 + Qei^2)^2} $$
$$ \diff{Qi}{Qei} = \frac{2 Q^2 Qer Qei}{(Q Qer - Qer^2 + Qei^2)^2} $$
"""
dQ = Q_err
Qer = Q_e_real
dQer = Q_e_real_err
Qei = Q_e_imag
dQei = Q_e_imag_err
denom = (Q*Qer - Qer**2 + Qei**2)**2
dQi_dQ = (Qer**2 - Qei**2)**2 / denom
dQi_dQer = (Q**2 * (Qer**2 + Qei**2)) / denom
dQi_dQei = (2 * Q**2 * Qer * Qei) / denom
dQi = np.sqrt((dQ * dQi_dQ)**2 + (dQer * dQi_dQer)**2 + (dQei * dQi_dQei)**2)
return dQi
def cable_delay(params, f):
"""
This assumes that signals go as exp(i \omega t) so that a time
delay corresponds to negative phase. In our sweeps the phase
advances with frequency, so I think that currently either the
convention is reversed in the readout or we have a time lead.
If *f* is in MHz, *delay* will be in microseconds.
If *f* is in Hz, *delay* will be in seconds.
Parameter *phi* is the phase at f = f_min.
"""
delay = params['delay'].value
phi = params['phi'].value
f_min = params['f_phi'].value
return np.exp(1j * (-2 * np.pi * (f - f_min) * delay + phi))
def generic_s21(params, f):
"""
This is Equation 11, except that the parameter A is a complex
prefactor intended to encapsulate the 1 + \hat{\epsilon} as well
as any external gains and phase shifts.
"""
A = (params['A_mag'].value *
np.exp(1j * params['A_phase'].value))
f_0 = params['f_0'].value
Q = params['Q'].value
Q_e = (params['Q_e_real'].value +
1j * params['Q_e_imag'].value)
return A * (1 - (Q * Q_e**-1 /
(1 + 2j * Q * (f - f_0) / f_0)))
def create_model(f_0 = 100e6, Q = 1e4,
Q_e = 2e4, A = 1.0,
delay = 0.0, a = 0.0):
p = Parameters()
A_mag = np.abs(A)
phi = np.angle(A)
Q_e_real = np.real(Q_e)
Q_e_imag = | np.imag(Q_e) | numpy.imag |
#!/usr/bin/python3
# test_numpy.py
# testing script for writing various numpy tensors to QG8 files using
# python -m pytest -rP tests/test_numpy.py
#
# Author : <NAME> <<EMAIL>>
# Date created : 18 July 2021
#
# Copyright 2021 University of Strasbourg
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
from qg8.core import *
from qg8.constants import *
from qg8 import from_numpy
graph = qg8_graph_create()
tests = []
# TEST 1
data = 324
dtype = 'int64'
test = {"description": "TEST1: Constant integer saved as rank 1 tensor " + dtype,
"first_val": np.array(data, dtype),
"last_val": | np.array(data, dtype) | numpy.array |
# Copyright <NAME> 2019
# Author: <NAME>
"""
This script contains the utilities for plotting kernel functions.
"""
from matplotlib import pyplot as plt
import numpy as np
def rational_quadratic(alpha, lengthscale, kernel_variance, r):
"""
The rational quadratic kernel as featured in equation 4.19 on pg. 86 of Rasmussen and Williams. The rational quadratic
kernel can be seen as a scale mixture (an infinite sum) of squared exponential kernels with different characteristic lengthscales.
:param alpha: as alpha goes to infinity the RQ kernel becomes the SQE kernel.
:param lengthscale: the lengthscale
:param kernel_variance: the kernel variance
:param r: The absolute distance in input space
:return: The kernel function evaluated at a list of values r.
"""
fract = (r/lengthscale)**2 * 1/(2*alpha)
k_rq = (1 + fract)**(-alpha)
k_rq *= kernel_variance
return k_rq
def ornstein_uhlenbeck(lengthscale, kernel_variance, r):
"""
The Ornstein-Uhlenbeck kernel (special case of exponential kernel in 1 dimension) defined on pg. 85 of Rasmussen
and Williams.
:param lengthscale: The lengthscale
:param kernel_variance: The kernel variance
:param r: The absolute distance in input space
:return: The kernel function evaluated at a list of values r.
"""
k_ou = np.exp(-r/lengthscale)
k_ou *= kernel_variance
return k_ou
def squared_exponential(lengthscale, kernel_variance, r):
"""
The Squared exponential (RBF) kernel.
:param lengthscale: The lengthscale
:param kernel_variance: The kernel variance
:param r:
:return: The kernel function evaluated at a list of values r.
"""
scaled_squared_dist = (r/lengthscale)**2
k_sqe = np.exp(-0.5*scaled_squared_dist)
k_sqe *= kernel_variance
return k_sqe
def matern12(lengthscale, kernel_variance, r):
"""
The Matern -1/2 kernel.
:param lengthscale: The lengthscale
:param kernel_variance: The kernel variance
:param r: The absolute distance in input space
:return: the kernel function evaluated at a list of values r.
"""
scaled_distance = (r/lengthscale)
k = kernel_variance*np.exp(-scaled_distance)
return k
kernel = 'RQ' # One of ['Matern', 'RQ']
if __name__ == '__main__':
r_vals = | np.arange(0, 10000, 10) | numpy.arange |
# Copyright 2021 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""unit tests for numpy array operations"""
import functools
import pytest
import numpy as onp
import mindspore.numpy as mnp
from mindspore.nn import Cell
class Cases():
def __init__(self):
self.all_shapes = [
0, 1, 2, (), (1,), (2,), (1, 2, 3), [], [1], [2], [1, 2, 3]
]
self.onp_dtypes = [onp.int32, 'int32', int,
onp.float32, 'float32', float,
onp.uint32, 'uint32',
onp.bool_, 'bool', bool]
self.mnp_dtypes = [mnp.int32, 'int32', int,
mnp.float32, 'float32', float,
mnp.uint32, 'uint32',
mnp.bool_, 'bool', bool]
self.array_sets = [1, 1.1, True, [1, 0, True], [1, 1.0, 2], (1,),
[(1, 2, 3), (4, 5, 6)], onp.random.random( # pylint: disable=no-member
(100, 100)).astype(onp.float32),
onp.random.random((100, 100)).astype(onp.bool)]
self.arrs = [
rand_int(2),
rand_int(2, 3),
rand_int(2, 3, 4),
rand_int(2, 3, 4, 5),
]
# scalars expanded across the 0th dimension
self.scalars = [
rand_int(),
rand_int(1),
rand_int(1, 1),
rand_int(1, 1, 1),
]
# arrays of the same size expanded across the 0th dimension
self.expanded_arrs = [
rand_int(2, 3),
rand_int(1, 2, 3),
rand_int(1, 1, 2, 3),
rand_int(1, 1, 1, 2, 3),
]
# arrays with dimensions of size 1
self.nested_arrs = [
rand_int(1),
rand_int(1, 2),
rand_int(3, 1, 8),
rand_int(1, 3, 9, 1),
]
# arrays which can be broadcast
self.broadcastables = [
rand_int(5),
rand_int(6, 1),
rand_int(7, 1, 5),
rand_int(8, 1, 6, 1)
]
# boolean arrays which can be broadcast
self.bool_broadcastables = [
rand_bool(),
rand_bool(1),
rand_bool(5),
rand_bool(6, 1),
rand_bool(7, 1, 5),
rand_bool(8, 1, 6, 1),
]
self.mnp_prototypes = [
mnp.ones((2, 3, 4)),
mnp.ones((0, 3, 0, 2, 5)),
onp.ones((2, 7, 0)),
onp.ones(()),
[mnp.ones(3), (1, 2, 3), onp.ones(3), [4, 5, 6]],
([(1, 2), mnp.ones(2)], (onp.ones(2), [3, 4])),
]
self.onp_prototypes = [
onp.ones((2, 3, 4)),
onp.ones((0, 3, 0, 2, 5)),
onp.ones((2, 7, 0)),
onp.ones(()),
[onp.ones(3), (1, 2, 3), onp.ones(3), [4, 5, 6]],
([(1, 2), onp.ones(2)], (onp.ones(2), [3, 4])),
]
def match_array(actual, expected, error=0):
if error > 0:
onp.testing.assert_almost_equal(actual.tolist(), expected.tolist(),
decimal=error)
else:
onp.testing.assert_equal(actual.tolist(), expected.tolist())
def check_all_results(onp_results, mnp_results, error=0):
"""Check all results from numpy and mindspore.numpy"""
for i, _ in enumerate(onp_results):
match_array(onp_results[i], mnp_results[i].asnumpy())
def run_non_kw_test(mnp_fn, onp_fn):
"""Run tests on functions with non keyword arguments"""
test_case = Cases()
for i in range(len(test_case.arrs)):
arrs = test_case.arrs[:i]
match_res(mnp_fn, onp_fn, *arrs)
for i in range(len(test_case.scalars)):
arrs = test_case.scalars[:i]
match_res(mnp_fn, onp_fn, *arrs)
for i in range(len(test_case.expanded_arrs)):
arrs = test_case.expanded_arrs[:i]
match_res(mnp_fn, onp_fn, *arrs)
for i in range(len(test_case.nested_arrs)):
arrs = test_case.nested_arrs[:i]
match_res(mnp_fn, onp_fn, *arrs)
def rand_int(*shape):
"""return an random integer array with parameter shape"""
res = onp.random.randint(low=1, high=5, size=shape)
if isinstance(res, onp.ndarray):
return res.astype(onp.float32)
return float(res)
# return an random boolean array
def rand_bool(*shape):
return onp.random.rand(*shape) > 0.5
def match_res(mnp_fn, onp_fn, *arrs, **kwargs):
"""Checks results from applying mnp_fn and onp_fn on arrs respectively"""
mnp_arrs = map(functools.partial(mnp.asarray, dtype='float32'), arrs)
mnp_res = mnp_fn(*mnp_arrs, **kwargs)
onp_res = onp_fn(*arrs, **kwargs)
match_all_arrays(mnp_res, onp_res)
def match_all_arrays(mnp_res, onp_res, error=0):
if isinstance(mnp_res, (tuple, list)):
for actual, expected in zip(mnp_res, onp_res):
match_array(actual.asnumpy(), expected, error)
else:
match_array(mnp_res.asnumpy(), onp_res, error)
def match_meta(actual, expected):
# float64 and int64 are not supported, and the defualt type for
# float and int are float32 and int32, respectively
if expected.dtype == onp.float64:
expected = expected.astype(onp.float32)
elif expected.dtype == onp.int64:
expected = expected.astype(onp.int32)
assert actual.shape == expected.shape
assert actual.dtype == expected.dtype
# Test np.transpose and np.ndarray.transpose
def mnp_transpose(input_tensor):
a = mnp.transpose(input_tensor, (0, 2, 1))
b = mnp.transpose(input_tensor, [2, 1, 0])
c = mnp.transpose(input_tensor, (1, 0, 2))
d = mnp.transpose(input_tensor)
return a, b, c, d
def onp_transpose(input_array):
a = onp.transpose(input_array, (0, 2, 1))
b = onp.transpose(input_array, [2, 1, 0])
c = onp.transpose(input_array, (1, 0, 2))
d = onp.transpose(input_array)
return a, b, c, d
@pytest.mark.level1
@pytest.mark.platform_arm_ascend_training
@pytest.mark.platform_x86_ascend_training
@pytest.mark.platform_x86_gpu_training
@pytest.mark.platform_x86_cpu
@pytest.mark.env_onecard
def test_transpose():
onp_array = onp.random.random((3, 4, 5)).astype('float32')
mnp_array = mnp.asarray(onp_array)
o_transposed = onp_transpose(onp_array)
m_transposed = mnp_transpose(mnp_array)
check_all_results(o_transposed, m_transposed)
# Test np.expand_dims
def mnp_expand_dims(input_tensor):
a = mnp.expand_dims(input_tensor, 0)
b = mnp.expand_dims(input_tensor, -1)
c = mnp.expand_dims(input_tensor, axis=2)
d = mnp.expand_dims(input_tensor, axis=-2)
return a, b, c, d
def onp_expand_dims(input_array):
a = onp.expand_dims(input_array, 0)
b = onp.expand_dims(input_array, -1)
c = onp.expand_dims(input_array, axis=2)
d = onp.expand_dims(input_array, axis=-2)
return a, b, c, d
@pytest.mark.level1
@pytest.mark.platform_arm_ascend_training
@pytest.mark.platform_x86_ascend_training
@pytest.mark.platform_x86_gpu_training
@pytest.mark.platform_x86_cpu
@pytest.mark.env_onecard
def test_expand_dims():
onp_array = onp.random.random((3, 4, 5)).astype('float32')
mnp_array = mnp.asarray(onp_array)
o_expanded = onp_expand_dims(onp_array)
m_expanded = mnp_expand_dims(mnp_array)
check_all_results(o_expanded, m_expanded)
# Test np.squeeze
def mnp_squeeze(input_tensor):
a = mnp.squeeze(input_tensor)
b = mnp.squeeze(input_tensor, 0)
c = mnp.squeeze(input_tensor, axis=None)
d = mnp.squeeze(input_tensor, axis=-3)
e = mnp.squeeze(input_tensor, (2,))
f = mnp.squeeze(input_tensor, (0, 2))
return a, b, c, d, e, f
def onp_squeeze(input_array):
a = onp.squeeze(input_array)
b = onp.squeeze(input_array, 0)
c = onp.squeeze(input_array, axis=None)
d = onp.squeeze(input_array, axis=-3)
e = onp.squeeze(input_array, (2,))
f = onp.squeeze(input_array, (0, 2))
return a, b, c, d, e, f
@pytest.mark.level1
@pytest.mark.platform_arm_ascend_training
@pytest.mark.platform_x86_ascend_training
@pytest.mark.platform_x86_gpu_training
@pytest.mark.platform_x86_cpu
@pytest.mark.env_onecard
def test_squeeze():
onp_array = onp.random.random((1, 3, 1, 4, 2)).astype('float32')
mnp_array = mnp.asarray(onp_array)
o_squeezed = onp_squeeze(onp_array)
m_squeezed = mnp_squeeze(mnp_array)
check_all_results(o_squeezed, m_squeezed)
onp_array = onp.random.random((1, 1, 1, 1, 1)).astype('float32')
mnp_array = mnp.asarray(onp_array)
o_squeezed = onp_squeeze(onp_array)
m_squeezed = mnp_squeeze(mnp_array)
check_all_results(o_squeezed, m_squeezed)
# Test np.rollaxis
def mnp_rollaxis(input_tensor):
a = mnp.rollaxis(input_tensor, 0, 1)
b = mnp.rollaxis(input_tensor, 0, 2)
c = mnp.rollaxis(input_tensor, 2, 1)
d = mnp.rollaxis(input_tensor, 2, 2)
e = mnp.rollaxis(input_tensor, 0)
f = mnp.rollaxis(input_tensor, 1)
return a, b, c, d, e, f
def onp_rollaxis(input_array):
a = onp.rollaxis(input_array, 0, 1)
b = | onp.rollaxis(input_array, 0, 2) | numpy.rollaxis |
import os
import sys
import numpy as np
MOVIE_LENS_PATH = os.path.join('Datasets', 'MovieLens', 'ml-1m', 'ratings.dat')
TEST_INDICES_PATH = os.path.join('Datasets', '1m-indices.txt')
TEST_PATH = os.path.join('Datasets', '1m-test.txt')
TRAIN_PATH = os.path.join('Datasets', '1m-train.txt')
def ReadMovieLens(path):
data_set = []
mx_film = -1
f = open(path, 'r')
for l in f:
l = l.strip()
# User ID
u_st = l.index('::')
u_idx = int(l[0:u_st])
# Movie ID
m_st = l.index('::', u_st + 2)
m_idx = int(l[u_st + 2 : m_st])
mx_film = max(mx_film, m_idx)
# Rating
r_st = l.index('::', m_st + 2)
u_rate = int(l[m_st + 2 : r_st])
data_set.append((u_idx - 1, m_idx - 1, u_rate))
f.close()
return data_set, mx_film
if __name__ == '__main__':
# Read dataset.
ml_dataset, mx_film = ReadMovieLens(MOVIE_LENS_PATH)
print('len(dataset) : ', len(ml_dataset))
print('dataset[0] :', ml_dataset[0])
print('dataset[-1] :', ml_dataset[-1])
print('max movie :', mx_film + 1)
# Make rating matrix.
num_users = ml_dataset[-1][0] + 1
num_movies = mx_film + 1
print(num_users, num_movies)
mat = np.zeros((num_users, num_movies), dtype=int)
for rec in ml_dataset:
u_idx = rec[0]
m_idx = rec[1]
rate = rec[2]
if mat[u_idx][m_idx] != 0:
print('mat[u_idx:{}][m_idx:{}] = rate:{}'.format(u_idx, m_idx, rate))
mat[u_idx][m_idx] = rate
# Count num of ratings and find positive ratings.
rate_counts = np.count_nonzero(mat, 1)
print('mat.shape : {}'.format(mat.shape))
print('rate_counts.shape : {}'.format(rate_counts.shape))
num_neg_users = 0
neg_users = []
for y in range(mat.shape[0]):
rate_cnt = 0
num_gt_4_rates = 0
for x in range(mat.shape[1]):
rate = mat[y][x]
rate_cnt += 1 if rate != 0 else 0
num_gt_4_rates += 1 if rate > 3 else 0
if num_gt_4_rates < 10:
num_neg_users += 1
neg_users.append(y)
print('negative user #{} -> user:{} rate_cnt:{} num+4:{}'.format(num_neg_users, y, rate_cnt, num_gt_4_rates))
print('min_rate_cnt', min(rate_counts), 'max_rate_cnt', max(rate_counts))
print('num_neg_users', num_neg_users)
# Calculate number of test users.
num_rem_users = num_users - num_neg_users
num_tests = 200
percent = int(float(num_tests) / num_rem_users * 100.0)
print('{}% users for test : {} of {}'.format(percent, num_tests, num_rem_users))
# Select test users.
test_users = []
while len(test_users) < num_tests:
r = int( | np.random.uniform(0, num_users) | numpy.random.uniform |
import matplotlib.pyplot as plt
import numpy as np
import os
from sklearn.linear_model import LinearRegression
from sklearn.decomposition import PCA
n = 200
beta = np.array([1.5, 2.5])
p = | np.shape(beta) | numpy.shape |
#!/usr/bin/python
# -*- coding: utf-8 -*-
##########################################################################################
# author: <NAME>
# contact: <EMAIL>
# date: 2021-05-10
# file: mpl_arrows_absScale_aspect_2.py
# tested with python 3.7.6 in conjunction with mpl version 3.4.2
##########################################################################################
import os
import platform
import datetime
import numpy as np
import matplotlib as mpl
from matplotlib import pyplot as plt
from matplotlib.ticker import FuncFormatter
mpl.ticker._mathdefault = lambda x: '\\mathdefault{%s}'%x
today = datetime.datetime.now().strftime("%Y-%m-%d")
BASEDIR = os.path.dirname(os.path.abspath(__file__))
OUTDIR = os.path.join(BASEDIR, 'out')
os.makedirs(OUTDIR, exist_ok = True)
def cleanFormatter(x, pos):
'''
will format 0.0 as 0 and
will format 1.0 as 1
'''
return '{:g}'.format(x)
def getFigureProps(width, height, lFrac = 0.17, rFrac = 0.9, bFrac = 0.17, tFrac = 0.9):
'''
True size scaling auxiliary function to setup mpl plots with a desired size.
Specify widht and height in cm.
lFrac = left fraction in [0, 1]
rFrac = right fraction in [0, 1]
bFrac = bottom fraction in [0, 1]
tFrac = top fraction in [0, 1]
returns:
fWidth = figure width
fHeight = figure height
These figure width and height values can then be used to create a figure instance
of the desired size, such that the actual plotting canvas has the specified
target width and height, as provided by the input parameters of this function.
'''
axesWidth = width / 2.54 # convert to inches
axesHeight = height / 2.54 # convert to inches
fWidth = axesWidth / (rFrac - lFrac)
fHeight = axesHeight / (tFrac - bFrac)
return fWidth, fHeight, lFrac, rFrac, bFrac, tFrac
def Plot(X, outname, outdir, pColors, titlestr = None,
grid = False, drawLegend = False, xFormat = None, yFormat = None,
savePDF = True, savePNG = False, datestamp = True):
mpl.rcParams['xtick.top'] = False
mpl.rcParams['xtick.bottom'] = True
mpl.rcParams['ytick.right'] = False
mpl.rcParams['xtick.direction'] = 'out'
mpl.rcParams['ytick.direction'] = 'out'
mpl.rc('font', **{'size': 10})
mpl.rc('legend', **{'fontsize': 7.0})
mpl.rc('axes', linewidth = 0.5)
# mpl.rc('font', **{'family' : 'sans-serif', 'sans-serif' : ['Myriad Pro']})
mpl.rc('font', **{'family' : 'sans-serif', 'sans-serif' : ['Helvetica']})
mpl.rcParams['pdf.fonttype'] = 42
mpl.rcParams['text.usetex'] = False
mpl.rcParams['mathtext.fontset'] = 'cm'
mpl.rcParams['text.latex.preamble'] = \
r'\usepackage{cmbright}' + \
r'\usepackage{amsmath}'
######################################################################################
# set up figure
fWidth, fHeight, lFrac, rFrac, bFrac, tFrac =\
getFigureProps(width = 3.0, height = 3.0,
lFrac = 0.22, rFrac = 0.95,
bFrac = 0.20, tFrac = 0.95)
f, ax1 = plt.subplots(1)
f.set_size_inches(fWidth, fHeight)
f.subplots_adjust(left = lFrac, right = rFrac)
f.subplots_adjust(bottom = bFrac, top = tFrac)
# minimal layout
ax1.spines['right'].set_visible(False)
ax1.spines['top'].set_visible(False)
######################################################################################
labelfontsize = 6.0
for tick in ax1.xaxis.get_major_ticks():
tick.label.set_fontsize(labelfontsize)
for tick in ax1.yaxis.get_major_ticks():
tick.label.set_fontsize(labelfontsize)
ax1.tick_params('both', length = 2.0, width = 0.5, which = 'major', pad = 3.0)
ax1.tick_params('both', length = 1.5, width = 0.25, which = 'minor', pad = 3.0)
ax1.tick_params(axis = 'x', which = 'major', pad = 1.5)
ax1.tick_params(axis = 'y', which = 'major', pad = 1.5, zorder = 10)
######################################################################################
# labeling
if titlestr:
plt.title(titlestr)
ax1.set_xlabel(r'x label', fontsize = 6.0)
ax1.set_ylabel(r'y label', fontsize = 6.0)
ax1.xaxis.labelpad = 4.0
ax1.yaxis.labelpad = 4.0
######################################################################################
# plotting
lineWidth = 0.5
'''
mpl.arrows example
In this example the arrow position and in particular the arrow head size are
specified by absolute scaling.
'''
Lx = xFormat[1] - xFormat[0]
Ly = yFormat[1] - yFormat[0]
ratio = Lx / Ly
######################################################################################
# horizontal reference line
ax1.plot([1.2, 1.6], [0.5, 0.5],
color = pColors[0],
alpha = 1.0,
lw = lineWidth,
zorder = 2,
label = r'')
ax1.plot([1.2, 1.2], [0.45, 0.75],
linewidth = lineWidth,
color = '#CCCCCC',
zorder = 1)
# horizontal arrows
dx = 0.4 # x displacement of the arrow head
hWidth = 0.05
hLength = 0.05 * ratio
ax1.arrow(1.2, 0.6, dx, 0.0,
lw = 0.5,
color = 'k',
head_width = hWidth,
head_length = hLength,
length_includes_head = True,
clip_on = False,
zorder = 3)
ax1.arrow(1.2, 0.7, dx, 0.0,
lw = 0.5,
color = 'k',
head_width = hWidth,
head_length = hLength,
length_includes_head = False,
clip_on = False,
zorder = 3)
######################################################################################
# vertical reference line
ax1.plot([0.2, 0.2], [0.6, 0.8],
color = pColors[0],
alpha = 1.0,
lw = lineWidth,
zorder = 2,
label = r'')
ax1.plot([0.1, 0.7], [0.6, 0.6],
linewidth = lineWidth,
color = '#CCCCCC',
zorder = 1)
hWidth = 0.05 * ratio
hLength = 0.05
# vertical arrows
dy = 0.2 # y displacement of the arrow head
ax1.arrow(0.4, 0.6, 0.0, dy,
lw = 0.5,
color = 'k',
head_width = hWidth,
head_length = hLength,
length_includes_head = True,
clip_on = False,
zorder = 3)
ax1.arrow(0.6, 0.6, 0.0, dy,
lw = 0.5,
color = 'k',
head_width = hWidth,
head_length = hLength,
length_includes_head = False,
clip_on = False,
zorder = 3)
######################################################################################
# annotations
ax1.annotate(r'horizontal arrows',
xy = (0.6, 0.78),
xycoords = 'axes fraction',
fontsize = 4.0,
horizontalalignment = 'left')
ax1.annotate(r'vertical arrows',
xy = (0.1, 0.90),
xycoords = 'axes fraction',
fontsize = 4.0,
horizontalalignment = 'left')
######################################################################################
# legend
if drawLegend:
leg = ax1.legend(# bbox_to_anchor = [0.7, 0.8],
# loc = 'upper left',
handlelength = 1.5,
scatterpoints = 1,
markerscale = 1.0,
ncol = 1)
leg.draw_frame(False)
plt.gca().add_artist(leg)
######################################################################################
# set plot range and scale
if xFormat:
xmin, xmax, xTicksMin, xTicksMax, dxMajor, dxMinor = xFormat
ax1.set_xlim(xmin, xmax)
major_x_ticks = np.arange(xTicksMin, xTicksMax, dxMajor)
minor_x_ticks = | np.arange(xTicksMin, xTicksMax, dxMinor) | numpy.arange |
# Source Generated with Decompyle++
# File: SPSO2011.cpython-34.pyc (Python 3.4)
from copy import deepcopy
from operator import attrgetter
import numpy as np
class Point:
def __init__(self, fitness, position):
self.fitness = fitness
self.position = position
class Particle:
def __init__(self, fitness, position, velocity):
self.current = Point(fitness, position)
self.velocity = velocity
self.previous_best = deepcopy(self.current)
self.previous_best_neighbor = deepcopy(self.current)
class PSO:
def __init__(self, obj, n_points, dimension, **kwargs):
self.obj = obj
self.dimension = dimension
self.n_points = n_points
self.min_bounds = kwargs.get('min_bounds', np.array([0] * dimension))
self.max_bounds = kwargs.get('max_bounds', np.array([1] * dimension))
# Speed limit for SPSO2006
#self.max_velocity = np.abs(self.max_bounds - self.min_bounds)
#self.min_velocity = -(self.max_velocity)
# Parameters for update
self.config = kwargs.get('config', 'SPSO2011')
self.topology = self.random_topology(K=3)
self.w = 1.0 / (2.0 * np.log(2.0))
self.c = 0.5 + np.log(2.0)
# Parameters for termiantion
self.iteration = 0
self.update_count = 0
self.update_order = np.random.permutation(self.n_points)
self.should_terminate = False
self.best_fitness = float('Inf')
# Initialize swarm
init_positions = kwargs.get('init_positions', None)
init_fitnesses = kwargs.get('init_fitnesses', None)
if init_positions is not None and init_fitnesses is not None:
assert len(init_fitnesses) == n_points
assert len(init_positions) == n_points
assert len(init_positions[0]) == dimension
self.swarm = []
for f, x in zip(init_fitnesses, init_positions):
v = [ np.random.uniform(self.min_bounds[d] - x[d], self.max_bounds[d] - x[d])
for d in range(self.dimension) ]
self.swarm.append( Particle( f, np.array(x), np.array(v) ) )
else:
self.swarm = self.init_swarm()
# Ensure exploitation state if particles are within hypersphere
self.exploitation = np.zeros(self.n_points)
def init_swarm(self):
swarm = []
for i in range(self.n_points):
x = [ | np.random.uniform(self.min_bounds[d], self.max_bounds[d]) | numpy.random.uniform |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.