def setUp(self):
"""
A function run before each unit test in this class. This tests the creation of several both ScalarQuantity
and ArrayQuantity objects
"""
self.Cp = quantity.Quantity(
[-6.51, -5.19333, -4.47333, -3.76, -3.44333, -2.94667, -2.47],
'cal/(mol*K)', '+|-',
[2.72057, 3.42407, 4.84068, 5.11681, 5.13207, 5.8757, 8.29108])
self.v = quantity.Quantity([5, 10, 12], 'cm/s', '*|/', [1.2, 0.4, 1])
self.H = quantity.Quantity(33.1097, 'kcal/mol', '+|-', 24.8344)
self.A = quantity.Quantity(7.25e+13, 'cm^3/(mol*s)', '*|/', 5)
self.Cp_array = quantity.ArrayQuantity(
[-6.51, -5.19333, -4.47333, -3.76, -3.44333, -2.94667, -2.47],
'cal/(mol*K)',
[2.72057, 3.42407, 4.84068, 5.11681, 5.13207, 5.8757, 8.29108],
'+|-')
self.v_array = quantity.ArrayQuantity([5, 10, 12], 'cm/s',
[1.2, 0.4, 1], '*|/')
self.H_scalar = quantity.ScalarQuantity(
33.1097,
'kcal/mol',
24.8344,
'+|-',
)
self.A_scalar = quantity.ScalarQuantity(7.25e+13, 'cm^3/(mol*s)', 5,
'*|/')
def __init__(self, network,
Tmin=None, Tmax=None, Tcount=0, Tlist=None,
Pmin=None, Pmax=None, Pcount=0, Plist=None,
maximumGrainSize=None, minimumGrainCount=0,
method=None, interpolationModel=None, maximumAtoms=None,
activeKRotor=True, activeJRotor=True, rmgmode=False, sensitivity_conditions=None):
self.network = network
self.Tmin = Tmin
self.Tmax = Tmax
self.Tcount = Tcount
if Tlist is not None:
self.Tlist = Tlist
self.Tmin = (np.min(self.Tlist.value_si), "K")
self.Tmax = (np.max(self.Tlist.value_si), "K")
self.Tcount = len(self.Tlist.value_si)
else:
self.Tlist = None
self.Pmin = Pmin
self.Pmax = Pmax
self.Pcount = Pcount
if Plist is not None:
self.Plist = Plist
self.Pmin = (np.min(self.Plist.value_si) * 1e-5, "bar")
self.Pmax = (np.max(self.Plist.value_si) * 1e-5, "bar")
self.Pcount = len(self.Plist.value_si)
else:
self.Plist = None
self.maximum_grain_size = maximumGrainSize
self.minimum_grain_count = minimumGrainCount
self.Emin = None
self.Emax = None
self.Elist = None
self.method = method
self.interpolation_model = interpolationModel
self.maximum_atoms = maximumAtoms
self.active_k_rotor = activeKRotor
self.active_j_rotor = activeJRotor
self.rmgmode = rmgmode
if sensitivity_conditions is not None:
if not isinstance(sensitivity_conditions[0], list):
sensitivity_conditions = [sensitivity_conditions] # allow `[T, P]` as conditions input
self.sensitivity_conditions = [[quantity.Quantity(condition[0]), quantity.Quantity(condition[1])]
for condition in sensitivity_conditions]
else:
self.sensitivity_conditions = None
if self.Tlist is None and self.Tmin is not None and self.Tmax is not None and self.Tcount is not None:
self.generate_T_list()
if self.Plist is None and self.Pmin is not None and self.Pmax is not None and self.Pcount is not None:
self.generate_P_list()
def __init__(self,
reaction,
Tmin=None,
Tmax=None,
Tlist=None,
Tcount=0,
sensitivity_conditions=None):
self.usedTST = False
self.Tmin = Tmin if Tmin is not None else (298, 'K')
self.Tmax = Tmax if Tmax is not None else (2500, 'K')
self.Tcount = Tcount if Tcount > 3 else 50
if Tlist is not None:
self.Tlist = Tlist
self.Tmin = (min(self.Tlist.value_si), 'K')
self.Tmax = (max(self.Tlist.value_si), 'K')
self.Tcount = len(self.Tlist.value_si)
else:
self.Tlist = (1 / np.linspace(1 / self.Tmax.value_si,
1 / self.Tmin.value_si, self.Tcount),
'K')
self.reaction = reaction
self.k_units = None
if sensitivity_conditions is not None:
self.sensitivity_conditions = [
quantity.Quantity(condition)
for condition in sensitivity_conditions
]
else:
self.sensitivity_conditions = None
self.arkane_species = ArkaneSpecies(
species=self.reaction.transition_state)
def test_scalar_repr(self):
"""
Test that the ScalarQuantity objects can be recreated using their __repr__ function
"""
# Test that the values can be reconstituted
H = quantity.Quantity(eval(repr(self.H)))
self.assertEqual(H.value_si, self.H.value_si)
self.assertEqual(H.uncertainty_si, self.H.uncertainty_si)
self.assertEqual(H.uncertaintyType, self.H.uncertaintyType)
self.assertEqual(H.units, self.H.units)
A = quantity.Quantity(eval(repr(self.A)))
self.assertEqual(A.value_si, self.A.value_si)
self.assertEqual(A.uncertainty_si, self.A.uncertainty_si)
self.assertEqual(A.uncertaintyType, self.A.uncertaintyType)
self.assertEqual(A.units, self.A.units)
# Test that the __repr__ strings are the same
self.assertEqual(repr(H), repr(self.H))
self.assertEqual(repr(self.H), repr(self.H_scalar))
self.assertEqual(repr(A), repr(self.A))
self.assertEqual(repr(self.A), repr(self.A_scalar))
def test_array_repr(self):
"""
Test that the ArrayQuantity objects can be recreated using their __repr__ function
"""
# Test that the values can be reconstituted
Cp = quantity.Quantity(eval(repr(self.Cp)))
numpy.testing.assert_array_almost_equal(Cp.value_si, self.Cp.value_si)
numpy.testing.assert_array_almost_equal(Cp.uncertainty_si, self.Cp.uncertainty_si)
self.assertEqual(Cp.uncertaintyType, self.Cp.uncertaintyType)
self.assertEqual(Cp.units, self.Cp.units)
v = quantity.Quantity(eval(repr(self.v)))
numpy.testing.assert_array_almost_equal(v.value_si, self.v.value_si)
numpy.testing.assert_array_almost_equal(v.uncertainty_si, self.v.uncertainty_si)
self.assertEqual(v.uncertaintyType, self.v.uncertaintyType)
self.assertEqual(v.units, self.v.units)
# Test that the __repr__ strings are the same
self.assertEqual(repr(Cp),repr(self.Cp))
self.assertEqual(repr(self.Cp),repr(self.Cp_array))
self.assertEqual(repr(v),repr(self.v))
self.assertEqual(repr(self.v),repr(self.v_array))
def __init__(self, job, output_directory):
self.job = job
self.output_directory = output_directory
self.sensitivity_path = os.path.join(output_directory, 'sensitivity')
self.conditions = self.job.sensitivity_conditions
self.f_rates = [self.job.reaction.kinetics.get_rate_coefficient(condition.value_si)
for condition in self.conditions]
kr = self.job.reaction.generate_reverse_rate_coefficient()
self.r_rates = [kr.get_rate_coefficient(condition.value_si) for condition in self.conditions]
self.f_sa_rates = {}
self.r_sa_rates = {}
self.f_sa_coefficients = {}
self.r_sa_coefficients = {}
self.perturbation = quantity.Quantity(1, 'kcal/mol')
self.execute()
def __init__(self,
reaction,
Tmin=None,
Tmax=None,
Tlist=None,
Tcount=0,
sensitivity_conditions=None):
self.usedTST = False
if Tmin is not None:
self.Tmin = quantity.Quantity(Tmin)
else:
self.Tmin = None
if Tmax is not None:
self.Tmax = quantity.Quantity(Tmax)
else:
self.Tmax = None
self.Tcount = Tcount
if Tlist is not None:
self.Tlist = quantity.Quantity(Tlist)
self.Tmin = quantity.Quantity(numpy.min(self.Tlist.value_si), "K")
self.Tmax = quantity.Quantity(numpy.max(self.Tlist.value_si), "K")
self.Tcount = len(self.Tlist.value_si)
else:
if Tmin and Tmax is not None:
if self.Tcount <= 3.:
self.Tcount = 50
stepsize = (self.Tmax.value_si -
self.Tmin.value_si) / self.Tcount
self.Tlist = quantity.Quantity(
numpy.arange(self.Tmin.value_si,
self.Tmax.value_si + stepsize, stepsize), "K")
else:
self.Tlist = None
self.reaction = reaction
self.kunits = None
if sensitivity_conditions is not None:
self.sensitivity_conditions = [
quantity.Quantity(condition)
for condition in sensitivity_conditions
]
else:
self.sensitivity_conditions = None
def __init__(self, job, output_directory, perturbation):
self.job = job
self.output_directory = output_directory
self.sensitivity_path = os.path.join(output_directory, 'sensitivity')
self.conditions = self.job.sensitivity_conditions
self.rates = {}
for rxn in self.job.network.net_reactions:
self.rates[str(rxn)] = []
for condition in self.conditions:
self.rates[str(rxn)].append(rxn.kinetics.get_rate_coefficient(condition[0].value_si,
condition[1].value_si))
self.sa_rates = {}
self.sa_coefficients = {}
for rxn in self.job.network.net_reactions:
self.sa_rates[str(rxn)] = {}
self.sa_coefficients[str(rxn)] = {}
self.perturbation = quantity.Quantity(perturbation, 'kcal/mol')
self.execute()
def __init__(self, reaction,
Tmin=None,
Tmax=None,
Tlist=None,
Tcount=0):
if Tmin is not None:
self.Tmin = quantity.Quantity(Tmin)
else:
self.Tmin = None
if Tmax is not None:
self.Tmax = quantity.Quantity(Tmax)
else:
self.Tmax = None
self.Tcount = Tcount
if Tlist is not None:
self.Tlist = quantity.Quantity(Tlist)
self.Tmin = quantity.Quantity(numpy.min(self.Tlist.value_si),"K")
self.Tmax = quantity.Quantity(numpy.max(self.Tlist.value_si),"K")
self.Tcount = len(self.Tlist.value_si)
else:
if Tmin and Tmax is not None:
if self.Tcount <= 3.:
self.Tcount = 50
stepsize = (self.Tmax.value_si-self.Tmin.value_si)/self.Tcount
self.Tlist = quantity.Quantity(numpy.arange(self.Tmin.value_si, self.Tmax.value_si+stepsize, stepsize),"K")
else:
self.Tlist = None
self.reaction = reaction
self.kunits = None
