class TestNonlinearRotor(unittest.TestCase):
"""
Contains unit tests of the NonlinearRotor class.
"""
def setUp(self):
"""
A function run before each unit test in this class.
"""
self.inertia = np.array([3.415, 16.65, 20.07])
self.symmetry = 4
self.quantum = False
self.mode = NonlinearRotor(
inertia=(self.inertia, "amu*angstrom^2"),
symmetry=self.symmetry,
quantum=self.quantum,
)
def test_get_rotational_constant(self):
"""
Test getting the NonlinearRotor.rotationalConstant property.
"""
b_exp = np.array([4.93635, 1.0125, 0.839942])
b_act = self.mode.rotationalConstant.value_si
for rotational_constant0, rotational_constant in zip(b_exp, b_act):
self.assertAlmostEqual(rotational_constant0, rotational_constant,
4)
def test_set_rotational_constant(self):
"""
Test setting the NonlinearRotor.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
for inertia0, inertia in zip(i_exp, i_act):
self.assertAlmostEqual(inertia0, inertia, 4)
def test_get_partition_function_classical(self):
"""
Test the NonlinearRotor.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([651.162, 1401.08, 3962.84, 7280.21, 11208.6])
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 NonlinearRotor.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.5, 1.5, 1.5, 1.5, 1.5]) * 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 NonlinearRotor.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.5, 1.5, 1.5, 1.5, 1.5]) * 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 NonlinearRotor.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([7.97876, 8.74500, 9.78472, 10.3929, 10.8244
]) * 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 NonlinearRotor.get_sum_of_states() method using a classical rotor.
"""
self.mode.quantum = False
e_list = np.arange(0, 1000 * 11.96, 1 * 11.96)
sum_states = self.mode.get_sum_of_states(e_list)
dens_states = self.mode.get_density_of_states(e_list)
for n in range(10, len(e_list)):
self.assertTrue(
0.8 < np.sum(dens_states[0:n]) / sum_states[n] < 1.25,
'{0} != {1}'.format(np.sum(dens_states[0:n]), sum_states[n]))
def test_get_sensity_of_states_classical(self):
"""
Test the NonlinearRotor.get_density_of_states() method using a classical
rotor.
"""
self.mode.quantum = False
e_list = np.arange(0, 1000 * 11.96, 1 * 11.96)
dens_states = self.mode.get_density_of_states(e_list)
temperature = 100
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 NonlinearRotor 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.assertEqual(self.mode.inertia.value.shape,
mode.inertia.value.shape)
for inertia_0, inertia in zip(self.mode.inertia.value,
mode.inertia.value):
self.assertAlmostEqual(inertia_0, inertia, 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 NonlinearRotor object can be pickled and unpickled with
no loss of information.
"""
import pickle
mode = pickle.loads(pickle.dumps(self.mode, -1))
self.assertEqual(self.mode.inertia.value.shape,
mode.inertia.value.shape)
for inertia_0, inertia in zip(self.mode.inertia.value,
mode.inertia.value):
self.assertAlmostEqual(inertia_0, inertia, 6)
self.assertEqual(self.mode.inertia.units, mode.inertia.units)
self.assertEqual(self.mode.symmetry, mode.symmetry)
self.assertEqual(self.mode.quantum, mode.quantum)
