def setUp(self):
"""
A function run before each unit test in this class.
"""
self.inertia = 11.75
self.symmetry = 2
self.quantum = False
self.mode = LinearRotor(
inertia=(self.inertia, "amu*angstrom^2"),
symmetry=self.symmetry,
quantum=self.quantum,
)
def setUp(self):
"""
A function run before each unit test in this class.
"""
self.inertia = 11.75
self.symmetry = 2
self.quantum = False
self.mode = LinearRotor(inertia=(self.inertia, "amu*angstrom^2"), symmetry=self.symmetry, quantum=self.quantum)
class TestLinearRotor(unittest.TestCase):
"""
Contains unit tests of the LinearRotor class.
"""
def setUp(self):
"""
A function run before each unit test in this class.
"""
self.inertia = 11.75
self.symmetry = 2
self.quantum = False
self.mode = LinearRotor(
inertia=(self.inertia, "amu*angstrom^2"),
symmetry=self.symmetry,
quantum=self.quantum,
)
def test_getRotationalConstant(self):
"""
Test getting the LinearRotor.rotationalConstant property.
"""
Bexp = 1.434692
Bact = self.mode.rotationalConstant.value_si
self.assertAlmostEqual(Bexp, Bact, 4)
def test_setRotationalConstant(self):
"""
Test setting the LinearRotor.rotationalConstant property.
"""
B = self.mode.rotationalConstant
B.value_si *= 2
self.mode.rotationalConstant = B
Iexp = 0.5 * self.inertia
Iact = self.mode.inertia.value_si * constants.Na * 1e23
self.assertAlmostEqual(Iexp, Iact, 4)
def test_getLevelEnergy(self):
"""
Test the LinearRotor.getLevelEnergy() method.
"""
B = self.mode.rotationalConstant.value_si * constants.h * constants.c * 100.
B *= constants.Na
for J in range(0, 100):
Eexp = B * J * (J + 1)
Eact = self.mode.getLevelEnergy(J)
if J == 0:
self.assertEqual(Eact, 0)
else:
self.assertAlmostEqual(Eexp, Eact, delta=1e-4 * Eexp)
def test_getLevelDegeneracy(self):
"""
Test the LinearRotor.getLevelDegeneracy() method.
"""
for J in range(0, 100):
gexp = 2 * J + 1
gact = self.mode.getLevelDegeneracy(J)
self.assertEqual(gexp, gact)
def test_getPartitionFunction_classical(self):
"""
Test the LinearRotor.getPartitionFunction() method for a classical
rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Qexplist = numpy.array([72.6691, 121.115, 242.230, 363.346, 484.461])
for T, Qexp in zip(Tlist, Qexplist):
Qact = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-4 * Qexp)
def test_getPartitionFunction_quantum(self):
"""
Test the LinearRotor.getPartitionFunction() method for a quantum
rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Qexplist = numpy.array([72.8360, 121.282, 242.391, 363.512, 484.627])
for T, Qexp in zip(Tlist, Qexplist):
Qact = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-4 * Qexp)
def test_getHeatCapacity_classical(self):
"""
Test the LinearRotor.getHeatCapacity() method using a classical rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Cvexplist = numpy.array([1, 1, 1, 1, 1]) * constants.R
for T, Cvexp in zip(Tlist, Cvexplist):
Cvact = self.mode.getHeatCapacity(T)
self.assertAlmostEqual(Cvexp, Cvact, delta=1e-4 * Cvexp)
def test_getHeatCapacity_quantum(self):
"""
Test the LinearRotor.getHeatCapacity() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Cvexplist = numpy.array([1, 1, 1, 1, 1]) * constants.R
for T, Cvexp in zip(Tlist, Cvexplist):
Cvact = self.mode.getHeatCapacity(T)
self.assertAlmostEqual(Cvexp, Cvact, delta=1e-4 * Cvexp)
def test_getEnthalpy_classical(self):
"""
Test the LinearRotor.getEnthalpy() method using a classical rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Hexplist = numpy.array([1, 1, 1, 1, 1]) * constants.R * Tlist
for T, Hexp in zip(Tlist, Hexplist):
Hact = self.mode.getEnthalpy(T)
self.assertAlmostEqual(Hexp, Hact, delta=1e-4 * Hexp)
def test_getEnthalpy_quantum(self):
"""
Test the LinearRotor.getEnthalpy() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Hexplist = numpy.array([
0.997705, 0.998624, 0.999312, 0.999541, 0.999656
]) * constants.R * Tlist
for T, Hexp in zip(Tlist, Hexplist):
Hact = self.mode.getEnthalpy(T)
self.assertAlmostEqual(Hexp, Hact, delta=1e-4 * Hexp)
def test_getEntropy_classical(self):
"""
Test the LinearRotor.getEntropy() method using a classical rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Sexplist = numpy.array([5.28592, 5.79674, 6.48989, 6.89535, 7.18304
]) * constants.R
for T, Sexp in zip(Tlist, Sexplist):
Sact = self.mode.getEntropy(T)
self.assertAlmostEqual(Sexp, Sact, delta=1e-4 * Sexp)
def test_getEntropy_quantum(self):
"""
Test the LinearRotor.getEntropy() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Sexplist = numpy.array([5.28592, 5.79674, 6.48989, 6.89535, 7.18304
]) * constants.R
for T, Sexp in zip(Tlist, Sexplist):
Sact = self.mode.getEntropy(T)
self.assertAlmostEqual(Sexp, Sact, delta=1e-4 * Sexp)
def test_getSumOfStates_classical(self):
"""
Test the LinearRotor.getSumOfStates() method using a classical rotor.
"""
self.mode.quantum = False
Elist = numpy.arange(0, 2000 * 11.96, 1.0 * 11.96)
densStates = self.mode.getDensityOfStates(Elist)
sumStates = self.mode.getSumOfStates(Elist)
for n in range(1, len(Elist)):
self.assertAlmostEqual(
numpy.sum(densStates[0:n]) / sumStates[n], 1.0, 3)
def test_getSumOfStates_quantum(self):
"""
Test the LinearRotor.getSumOfStates() method using a quantum rotor.
"""
self.mode.quantum = True
Elist = numpy.arange(0, 4000. * 11.96, 2.0 * 11.96)
densStates = self.mode.getDensityOfStates(Elist)
sumStates = self.mode.getSumOfStates(Elist)
for n in range(1, len(Elist)):
self.assertAlmostEqual(
numpy.sum(densStates[0:n + 1]) / sumStates[n], 1.0, 3)
def test_getDensityOfStates_classical(self):
"""
Test the LinearRotor.getDensityOfStates() method using a classical
rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 400, 500])
Elist = numpy.arange(0, 4000. * 11.96, 1.0 * 11.96)
for T in Tlist:
densStates = self.mode.getDensityOfStates(Elist)
Qact = numpy.sum(densStates * numpy.exp(-Elist / constants.R / T))
Qexp = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-2 * Qexp)
def test_getDensityOfStates_quantum(self):
"""
Test the LinearRotor.getDensityOfStates() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 400, 500])
Elist = numpy.arange(0, 4000. * 11.96, 2.0 * 11.96)
for T in Tlist:
densStates = self.mode.getDensityOfStates(Elist)
Qact = numpy.sum(densStates * numpy.exp(-Elist / constants.R / T))
Qexp = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-2 * Qexp)
def test_repr(self):
"""
Test that a LinearRotor object can be reconstructed from its repr()
output with no loss of information.
"""
mode = None
exec('mode = {0!r}'.format(self.mode))
self.assertAlmostEqual(self.mode.inertia.value, mode.inertia.value, 6)
self.assertEqual(self.mode.inertia.units, mode.inertia.units)
self.assertEqual(self.mode.symmetry, mode.symmetry)
self.assertEqual(self.mode.quantum, mode.quantum)
def test_pickle(self):
"""
Test that a LinearRotor object can be pickled and unpickled with no
loss of information.
"""
import cPickle
mode = cPickle.loads(cPickle.dumps(self.mode, -1))
self.assertAlmostEqual(self.mode.inertia.value, mode.inertia.value, 6)
self.assertEqual(self.mode.inertia.units, mode.inertia.units)
self.assertEqual(self.mode.symmetry, mode.symmetry)
self.assertEqual(self.mode.quantum, mode.quantum)
class TestLinearRotor(unittest.TestCase):
"""
Contains unit tests of the LinearRotor class.
"""
def setUp(self):
"""
A function run before each unit test in this class.
"""
self.inertia = 11.75
self.symmetry = 2
self.quantum = False
self.mode = LinearRotor(inertia=(self.inertia, "amu*angstrom^2"), symmetry=self.symmetry, quantum=self.quantum)
def test_getRotationalConstant(self):
"""
Test getting the LinearRotor.rotationalConstant property.
"""
Bexp = 1.434692
Bact = self.mode.rotationalConstant.value_si
self.assertAlmostEqual(Bexp, Bact, 4)
def test_setRotationalConstant(self):
"""
Test setting the LinearRotor.rotationalConstant property.
"""
B = self.mode.rotationalConstant
B.value_si *= 2
self.mode.rotationalConstant = B
Iexp = 0.5 * self.inertia
Iact = self.mode.inertia.value_si * constants.Na * 1e23
self.assertAlmostEqual(Iexp, Iact, 4)
def test_getLevelEnergy(self):
"""
Test the LinearRotor.getLevelEnergy() method.
"""
B = self.mode.rotationalConstant.value_si * constants.h * constants.c * 100.0
B *= constants.Na
for J in range(0, 100):
Eexp = B * J * (J + 1)
Eact = self.mode.getLevelEnergy(J)
if J == 0:
self.assertEqual(Eact, 0)
else:
self.assertAlmostEqual(Eexp, Eact, delta=1e-4 * Eexp)
def test_getLevelDegeneracy(self):
"""
Test the LinearRotor.getLevelDegeneracy() method.
"""
for J in range(0, 100):
gexp = 2 * J + 1
gact = self.mode.getLevelDegeneracy(J)
self.assertEqual(gexp, gact)
def test_getPartitionFunction_classical(self):
"""
Test the LinearRotor.getPartitionFunction() method for a classical
rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Qexplist = numpy.array([72.6691, 121.115, 242.230, 363.346, 484.461])
for T, Qexp in zip(Tlist, Qexplist):
Qact = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-4 * Qexp)
def test_getPartitionFunction_quantum(self):
"""
Test the LinearRotor.getPartitionFunction() method for a quantum
rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Qexplist = numpy.array([72.8360, 121.282, 242.391, 363.512, 484.627])
for T, Qexp in zip(Tlist, Qexplist):
Qact = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-4 * Qexp)
def test_getHeatCapacity_classical(self):
"""
Test the LinearRotor.getHeatCapacity() method using a classical rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Cvexplist = numpy.array([1, 1, 1, 1, 1]) * constants.R
for T, Cvexp in zip(Tlist, Cvexplist):
Cvact = self.mode.getHeatCapacity(T)
self.assertAlmostEqual(Cvexp, Cvact, delta=1e-4 * Cvexp)
def test_getHeatCapacity_quantum(self):
"""
Test the LinearRotor.getHeatCapacity() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Cvexplist = numpy.array([1, 1, 1, 1, 1]) * constants.R
for T, Cvexp in zip(Tlist, Cvexplist):
Cvact = self.mode.getHeatCapacity(T)
self.assertAlmostEqual(Cvexp, Cvact, delta=1e-4 * Cvexp)
def test_getEnthalpy_classical(self):
"""
Test the LinearRotor.getEnthalpy() method using a classical rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Hexplist = numpy.array([1, 1, 1, 1, 1]) * constants.R * Tlist
for T, Hexp in zip(Tlist, Hexplist):
Hact = self.mode.getEnthalpy(T)
self.assertAlmostEqual(Hexp, Hact, delta=1e-4 * Hexp)
def test_getEnthalpy_quantum(self):
"""
Test the LinearRotor.getEnthalpy() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Hexplist = numpy.array([0.997705, 0.998624, 0.999312, 0.999541, 0.999656]) * constants.R * Tlist
for T, Hexp in zip(Tlist, Hexplist):
Hact = self.mode.getEnthalpy(T)
self.assertAlmostEqual(Hexp, Hact, delta=1e-4 * Hexp)
def test_getEntropy_classical(self):
"""
Test the LinearRotor.getEntropy() method using a classical rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Sexplist = numpy.array([5.28592, 5.79674, 6.48989, 6.89535, 7.18304]) * constants.R
for T, Sexp in zip(Tlist, Sexplist):
Sact = self.mode.getEntropy(T)
self.assertAlmostEqual(Sexp, Sact, delta=1e-4 * Sexp)
def test_getEntropy_quantum(self):
"""
Test the LinearRotor.getEntropy() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 500, 1000, 1500, 2000])
Sexplist = numpy.array([5.28592, 5.79674, 6.48989, 6.89535, 7.18304]) * constants.R
for T, Sexp in zip(Tlist, Sexplist):
Sact = self.mode.getEntropy(T)
self.assertAlmostEqual(Sexp, Sact, delta=1e-4 * Sexp)
def test_getSumOfStates_classical(self):
"""
Test the LinearRotor.getSumOfStates() method using a classical rotor.
"""
self.mode.quantum = False
Elist = numpy.arange(0, 2000 * 11.96, 1.0 * 11.96)
densStates = self.mode.getDensityOfStates(Elist)
sumStates = self.mode.getSumOfStates(Elist)
for n in range(1, len(Elist)):
self.assertAlmostEqual(numpy.sum(densStates[0:n]) / sumStates[n], 1.0, 3)
def test_getSumOfStates_quantum(self):
"""
Test the LinearRotor.getSumOfStates() method using a quantum rotor.
"""
self.mode.quantum = True
Elist = numpy.arange(0, 4000.0 * 11.96, 2.0 * 11.96)
densStates = self.mode.getDensityOfStates(Elist)
sumStates = self.mode.getSumOfStates(Elist)
for n in range(1, len(Elist)):
self.assertAlmostEqual(numpy.sum(densStates[0 : n + 1]) / sumStates[n], 1.0, 3)
def test_getDensityOfStates_classical(self):
"""
Test the LinearRotor.getDensityOfStates() method using a classical
rotor.
"""
self.mode.quantum = False
Tlist = numpy.array([300, 400, 500])
Elist = numpy.arange(0, 4000.0 * 11.96, 1.0 * 11.96)
for T in Tlist:
densStates = self.mode.getDensityOfStates(Elist)
Qact = numpy.sum(densStates * numpy.exp(-Elist / constants.R / T))
Qexp = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-2 * Qexp)
def test_getDensityOfStates_quantum(self):
"""
Test the LinearRotor.getDensityOfStates() method using a quantum rotor.
"""
self.mode.quantum = True
Tlist = numpy.array([300, 400, 500])
Elist = numpy.arange(0, 4000.0 * 11.96, 2.0 * 11.96)
for T in Tlist:
densStates = self.mode.getDensityOfStates(Elist)
Qact = numpy.sum(densStates * numpy.exp(-Elist / constants.R / T))
Qexp = self.mode.getPartitionFunction(T)
self.assertAlmostEqual(Qexp, Qact, delta=1e-2 * Qexp)
def test_repr(self):
"""
Test that a LinearRotor object can be reconstructed from its repr()
output with no loss of information.
"""
mode = None
exec("mode = {0!r}".format(self.mode))
self.assertAlmostEqual(self.mode.inertia.value, mode.inertia.value, 6)
self.assertEqual(self.mode.inertia.units, mode.inertia.units)
self.assertEqual(self.mode.symmetry, mode.symmetry)
self.assertEqual(self.mode.quantum, mode.quantum)
def test_pickle(self):
"""
Test that a LinearRotor object can be pickled and unpickled with no
loss of information.
"""
import cPickle
mode = cPickle.loads(cPickle.dumps(self.mode, -1))
self.assertAlmostEqual(self.mode.inertia.value, mode.inertia.value, 6)
self.assertEqual(self.mode.inertia.units, mode.inertia.units)
self.assertEqual(self.mode.symmetry, mode.symmetry)
self.assertEqual(self.mode.quantum, mode.quantum)
class TestLinearRotor(unittest.TestCase):
"""
Contains unit tests of the LinearRotor class.
"""
def setUp(self):
"""
A function run before each unit test in this class.
"""
self.inertia = 11.75
self.symmetry = 2
self.quantum = False
self.mode = LinearRotor(
inertia=(self.inertia, "amu*angstrom^2"),
symmetry=self.symmetry,
quantum=self.quantum,
)
def test_get_rotational_constant(self):
"""
Test getting the LinearRotor.rotationalConstant property.
"""
b_exp = 1.434692
b_act = self.mode.rotationalConstant.value_si
self.assertAlmostEqual(b_exp, b_act, 4)
def test_set_rotational_constant(self):
"""
Test setting the LinearRotor.rotationalConstant property.
"""
rotational_constant = self.mode.rotationalConstant
rotational_constant.value_si *= 2
self.mode.rotationalConstant = rotational_constant
i_exp = 0.5 * self.inertia
i_act = self.mode.inertia.value_si * constants.Na * 1e23
self.assertAlmostEqual(i_exp, i_act, 4)
def test_get_level_energy(self):
"""
Test the LinearRotor.get_level_energy() method.
"""
rotational_constant = self.mode.rotationalConstant.value_si * constants.h * constants.c * 100.
rotational_constant *= constants.Na
for j in range(0, 100):
e_exp = rotational_constant * j * (j + 1)
e_act = self.mode.get_level_energy(j)
if j == 0:
self.assertEqual(e_act, 0)
else:
self.assertAlmostEqual(e_exp, e_act, delta=1e-4 * e_exp)
def test_get_level_degeneracy(self):
"""
Test the LinearRotor.get_level_degeneracy() method.
"""
for j in range(0, 100):
g_exp = 2 * j + 1
g_act = self.mode.get_level_degeneracy(j)
self.assertEqual(g_exp, g_act)
def test_get_partition_function_classical(self):
"""
Test the LinearRotor.get_partition_function() method for a classical
rotor.
"""
self.mode.quantum = False
t_list = np.array([300, 500, 1000, 1500, 2000])
q_exp_list = np.array([72.6691, 121.115, 242.230, 363.346, 484.461])
for temperature, q_exp in zip(t_list, q_exp_list):
q_act = self.mode.get_partition_function(temperature)
self.assertAlmostEqual(q_exp, q_act, delta=1e-4 * q_exp)
def test_get_partition_function_quantum(self):
"""
Test the LinearRotor.get_partition_function() method for a quantum
rotor.
"""
self.mode.quantum = True
t_list = np.array([300, 500, 1000, 1500, 2000])
q_exp_list = np.array([72.8360, 121.282, 242.391, 363.512, 484.627])
for temperature, q_exp in zip(t_list, q_exp_list):
q_act = self.mode.get_partition_function(temperature)
self.assertAlmostEqual(q_exp, q_act, delta=1e-4 * q_exp)
def test_get_heat_capacity_classical(self):
"""
Test the LinearRotor.get_heat_capacity() method using a classical rotor.
"""
self.mode.quantum = False
t_list = np.array([300, 500, 1000, 1500, 2000])
cv_exp_list = np.array([1, 1, 1, 1, 1]) * constants.R
for temperature, cv_exp in zip(t_list, cv_exp_list):
cv_act = self.mode.get_heat_capacity(temperature)
self.assertAlmostEqual(cv_exp, cv_act, delta=1e-4 * cv_exp)
def test_get_heat_capacity_quantum(self):
"""
Test the LinearRotor.get_heat_capacity() method using a quantum rotor.
"""
self.mode.quantum = True
t_list = np.array([300, 500, 1000, 1500, 2000])
cv_exp_list = np.array([1, 1, 1, 1, 1]) * constants.R
for temperature, cv_exp in zip(t_list, cv_exp_list):
cv_act = self.mode.get_heat_capacity(temperature)
self.assertAlmostEqual(cv_exp, cv_act, delta=1e-4 * cv_exp)
def test_get_enthalpy_classical(self):
"""
Test the LinearRotor.get_enthalpy() method using a classical rotor.
"""
self.mode.quantum = False
t_list = np.array([300, 500, 1000, 1500, 2000])
h_exp_list = np.array([1, 1, 1, 1, 1]) * constants.R * t_list
for temperature, h_exp in zip(t_list, h_exp_list):
h_act = self.mode.get_enthalpy(temperature)
self.assertAlmostEqual(h_exp, h_act, delta=1e-4 * h_exp)
def test_get_enthalpy_quantum(self):
"""
Test the LinearRotor.get_enthalpy() method using a quantum rotor.
"""
self.mode.quantum = True
t_list = np.array([300, 500, 1000, 1500, 2000])
h_exp_list = np.array([
0.997705, 0.998624, 0.999312, 0.999541, 0.999656
]) * constants.R * t_list
for temperature, h_exp in zip(t_list, h_exp_list):
h_act = self.mode.get_enthalpy(temperature)
self.assertAlmostEqual(h_exp, h_act, delta=1e-4 * h_exp)
def test_get_entropy_classical(self):
"""
Test the LinearRotor.get_entropy() method using a classical rotor.
"""
self.mode.quantum = False
t_list = np.array([300, 500, 1000, 1500, 2000])
s_exp_list = np.array([5.28592, 5.79674, 6.48989, 6.89535, 7.18304
]) * constants.R
for temperature, s_exp in zip(t_list, s_exp_list):
s_act = self.mode.get_entropy(temperature)
self.assertAlmostEqual(s_exp, s_act, delta=1e-4 * s_exp)
def test_get_entropy_quantum(self):
"""
Test the LinearRotor.get_entropy() method using a quantum rotor.
"""
self.mode.quantum = True
t_list = np.array([300, 500, 1000, 1500, 2000])
s_exp_list = np.array([5.28592, 5.79674, 6.48989, 6.89535, 7.18304
]) * constants.R
for temperature, s_exp in zip(t_list, s_exp_list):
s_act = self.mode.get_entropy(temperature)
self.assertAlmostEqual(s_exp, s_act, delta=1e-4 * s_exp)
def test_get_sum_of_states_classical(self):
"""
Test the LinearRotor.get_sum_of_states() method using a classical rotor.
"""
self.mode.quantum = False
e_list = np.arange(0, 2000 * 11.96, 1.0 * 11.96)
dens_states = self.mode.get_density_of_states(e_list)
sum_states = self.mode.get_sum_of_states(e_list)
for n in range(1, len(e_list)):
self.assertAlmostEqual(
np.sum(dens_states[0:n]) / sum_states[n], 1.0, 3)
def test_get_sum_of_states_quantum(self):
"""
Test the LinearRotor.get_sum_of_states() method using a quantum rotor.
"""
self.mode.quantum = True
e_list = np.arange(0, 4000. * 11.96, 2.0 * 11.96)
dens_states = self.mode.get_density_of_states(e_list)
sum_states = self.mode.get_sum_of_states(e_list)
for n in range(1, len(e_list)):
self.assertAlmostEqual(
np.sum(dens_states[0:n + 1]) / sum_states[n], 1.0, 3)
def test_get_dsensity_of_states_classical(self):
"""
Test the LinearRotor.get_density_of_states() method using a classical rotor.
"""
self.mode.quantum = False
t_list = np.array([300, 400, 500])
e_list = np.arange(0, 4000. * 11.96, 1.0 * 11.96)
for temperature in t_list:
dens_states = self.mode.get_density_of_states(e_list)
q_act = np.sum(dens_states *
np.exp(-e_list / constants.R / temperature))
q_exp = self.mode.get_partition_function(temperature)
self.assertAlmostEqual(q_exp, q_act, delta=1e-2 * q_exp)
def test_get_dsensity_of_states_quantum(self):
"""
Test the LinearRotor.get_density_of_states() method using a quantum rotor.
"""
self.mode.quantum = True
t_list = np.array([300, 400, 500])
e_list = np.arange(0, 4000. * 11.96, 2.0 * 11.96)
for temperature in t_list:
dens_states = self.mode.get_density_of_states(e_list)
q_act = np.sum(dens_states *
np.exp(-e_list / constants.R / temperature))
q_exp = self.mode.get_partition_function(temperature)
self.assertAlmostEqual(q_exp, q_act, delta=1e-2 * q_exp)
def test_repr(self):
"""
Test that a LinearRotor object can be reconstructed from its repr()
output with no loss of information.
"""
namespace = {}
exec('mode = {0!r}'.format(self.mode), globals(), namespace)
self.assertIn('mode', namespace)
mode = namespace['mode']
self.assertAlmostEqual(self.mode.inertia.value, mode.inertia.value, 6)
self.assertEqual(self.mode.inertia.units, mode.inertia.units)
self.assertEqual(self.mode.symmetry, mode.symmetry)
self.assertEqual(self.mode.quantum, mode.quantum)
def test_pickle(self):
"""
Test that a LinearRotor object can be pickled and unpickled with no
loss of information.
"""
import pickle
mode = pickle.loads(pickle.dumps(self.mode, -1))
self.assertAlmostEqual(self.mode.inertia.value, mode.inertia.value, 6)
self.assertEqual(self.mode.inertia.units, mode.inertia.units)
self.assertEqual(self.mode.symmetry, mode.symmetry)
self.assertEqual(self.mode.quantum, mode.quantum)
