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)