Esempio n. 1
0
 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 = SphericalTopRotor(
         inertia=(self.inertia, "amu*angstrom^2"),
         symmetry=self.symmetry,
         quantum=self.quantum,
     )
Esempio n. 2
0
 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 = SphericalTopRotor(
         inertia=(self.inertia, "amu*angstrom^2"), symmetry=self.symmetry, quantum=self.quantum
     )
Esempio n. 3
0
class TestSphericalTopRotor(unittest.TestCase):
    """
    Contains unit tests of the SphericalTopRotor 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 = SphericalTopRotor(
            inertia=(self.inertia, "amu*angstrom^2"),
            symmetry=self.symmetry,
            quantum=self.quantum,
        )

    def test_getRotationalConstant(self):
        """
        Test getting the SphericalTopRotor.rotationalConstant property.
        """
        Bexp = 1.434692
        Bact = self.mode.rotationalConstant.value_si
        self.assertAlmostEqual(Bexp, Bact, 4)

    def test_setRotationalConstant(self):
        """
        Test setting the SphericalTopRotor.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 SphericalTopRotor.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 SphericalTopRotor.getLevelDegeneracy() method.
        """
        for J in range(0, 100):
            gexp = (2 * J + 1)**2
            gact = self.mode.getLevelDegeneracy(J)
            self.assertEqual(gexp, gact, '{0} != {1}'.format(gact, gexp))

    def test_getPartitionFunction_classical(self):
        """
        Test the SphericalTopRotor.getPartitionFunction() method for a classical
        rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Qexplist = numpy.array([1552.74, 3340.97, 9449.69, 17360.2, 26727.8])
        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 SphericalTopRotor.getPartitionFunction() method for a quantum
        rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Qexplist = numpy.array([1555.42, 3344.42, 9454.57, 17366.2, 26734.7])
        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 SphericalTopRotor.getHeatCapacity() method using a classical rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Cvexplist = numpy.array([1.5, 1.5, 1.5, 1.5, 1.5]) * 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 SphericalTopRotor.getHeatCapacity() method using a quantum rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Cvexplist = numpy.array([1.5, 1.5, 1.5, 1.5, 1.5]) * 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 SphericalTopRotor.getEnthalpy() method using a classical rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Hexplist = numpy.array([1.5, 1.5, 1.5, 1.5, 1.5]) * 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 SphericalTopRotor.getEnthalpy() method using a quantum rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Hexplist = numpy.array([1.49828, 1.49897, 1.49948, 1.49966, 1.49974
                                ]) * 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 SphericalTopRotor.getEntropy() method using a classical rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Sexplist = numpy.array([8.84778, 9.61402, 10.6537, 11.2619, 11.6935
                                ]) * 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 SphericalTopRotor.getEntropy() method using a quantum rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Sexplist = numpy.array([8.84778, 9.61402, 10.6537, 11.2619, 11.6935
                                ]) * 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 SphericalTopRotor.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(20, len(Elist)):
            self.assertAlmostEqual(
                numpy.sum(densStates[0:n + 1]) / sumStates[n], 1.0, 1)

    def test_getSumOfStates_quantum(self):
        """
        Test the SphericalTopRotor.getSumOfStates() method using a quantum rotor.
        """
        self.mode.quantum = True
        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 + 1]) / sumStates[n], 1.0, 3)

    def test_getDensityOfStates_classical(self):
        """
        Test the SphericalTopRotor.getDensityOfStates() method using a classical
        rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 400, 500])
        Elist = numpy.arange(0, 2000 * 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 SphericalTopRotor.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 SphericalTopRotor 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 SphericalTopRotor 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)
Esempio n. 4
0
class TestSphericalTopRotor(unittest.TestCase):
    """
    Contains unit tests of the SphericalTopRotor 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 = SphericalTopRotor(
            inertia=(self.inertia, "amu*angstrom^2"), symmetry=self.symmetry, quantum=self.quantum
        )

    def test_getRotationalConstant(self):
        """
        Test getting the SphericalTopRotor.rotationalConstant property.
        """
        Bexp = 1.434692
        Bact = self.mode.rotationalConstant.value_si
        self.assertAlmostEqual(Bexp, Bact, 4)

    def test_setRotationalConstant(self):
        """
        Test setting the SphericalTopRotor.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 SphericalTopRotor.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 SphericalTopRotor.getLevelDegeneracy() method.
        """
        for J in range(0, 100):
            gexp = (2 * J + 1) ** 2
            gact = self.mode.getLevelDegeneracy(J)
            self.assertEqual(gexp, gact, "{0} != {1}".format(gact, gexp))

    def test_getPartitionFunction_classical(self):
        """
        Test the SphericalTopRotor.getPartitionFunction() method for a classical
        rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Qexplist = numpy.array([1552.74, 3340.97, 9449.69, 17360.2, 26727.8])
        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 SphericalTopRotor.getPartitionFunction() method for a quantum
        rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Qexplist = numpy.array([1555.42, 3344.42, 9454.57, 17366.2, 26734.7])
        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 SphericalTopRotor.getHeatCapacity() method using a classical rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Cvexplist = numpy.array([1.5, 1.5, 1.5, 1.5, 1.5]) * 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 SphericalTopRotor.getHeatCapacity() method using a quantum rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Cvexplist = numpy.array([1.5, 1.5, 1.5, 1.5, 1.5]) * 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 SphericalTopRotor.getEnthalpy() method using a classical rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Hexplist = numpy.array([1.5, 1.5, 1.5, 1.5, 1.5]) * 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 SphericalTopRotor.getEnthalpy() method using a quantum rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Hexplist = numpy.array([1.49828, 1.49897, 1.49948, 1.49966, 1.49974]) * 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 SphericalTopRotor.getEntropy() method using a classical rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Sexplist = numpy.array([8.84778, 9.61402, 10.6537, 11.2619, 11.6935]) * 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 SphericalTopRotor.getEntropy() method using a quantum rotor.
        """
        self.mode.quantum = True
        Tlist = numpy.array([300, 500, 1000, 1500, 2000])
        Sexplist = numpy.array([8.84778, 9.61402, 10.6537, 11.2619, 11.6935]) * 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 SphericalTopRotor.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(20, len(Elist)):
            self.assertAlmostEqual(numpy.sum(densStates[0 : n + 1]) / sumStates[n], 1.0, 1)

    def test_getSumOfStates_quantum(self):
        """
        Test the SphericalTopRotor.getSumOfStates() method using a quantum rotor.
        """
        self.mode.quantum = True
        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 + 1]) / sumStates[n], 1.0, 3)

    def test_getDensityOfStates_classical(self):
        """
        Test the SphericalTopRotor.getDensityOfStates() method using a classical
        rotor.
        """
        self.mode.quantum = False
        Tlist = numpy.array([300, 400, 500])
        Elist = numpy.arange(0, 2000 * 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 SphericalTopRotor.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 SphericalTopRotor 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 SphericalTopRotor 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)
Esempio n. 5
0
class TestSphericalTopRotor(unittest.TestCase):
    """
    Contains unit tests of the SphericalTopRotor 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 = SphericalTopRotor(
            inertia=(self.inertia, "amu*angstrom^2"),
            symmetry=self.symmetry,
            quantum=self.quantum,
        )

    def test_get_rotational_constant(self):
        """
        Test getting the SphericalTopRotor.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 SphericalTopRotor.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 SphericalTopRotor.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 SphericalTopRotor.get_level_degeneracy() method.
        """
        for j in range(0, 100):
            g_exp = (2 * j + 1)**2
            g_act = self.mode.get_level_degeneracy(j)
            self.assertEqual(g_exp, g_act)

    def test_get_partition_function_classical(self):
        """
        Test the SphericalTopRotor.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([1552.74, 3340.97, 9449.69, 17360.2, 26727.8])
        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 SphericalTopRotor.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([1555.42, 3344.42, 9454.57, 17366.2, 26734.7])
        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 SphericalTopRotor.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_heat_capacity_quantum(self):
        """
        Test the SphericalTopRotor.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.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 SphericalTopRotor.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_enthalpy_quantum(self):
        """
        Test the SphericalTopRotor.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([1.49828, 1.49897, 1.49948, 1.49966, 1.49974
                               ]) * 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 SphericalTopRotor.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([8.84778, 9.61402, 10.6537, 11.2619, 11.6935
                               ]) * 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 SphericalTopRotor.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([8.84778, 9.61402, 10.6537, 11.2619, 11.6935
                               ]) * 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 SphericalTopRotor.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(20, len(e_list)):
            self.assertAlmostEqual(
                np.sum(dens_states[0:n + 1]) / sum_states[n], 1.0, 1)

    def test_get_sum_of_states_quantum(self):
        """
        Test the SphericalTopRotor.get_sum_of_states() method using a quantum rotor.
        """
        self.mode.quantum = True
        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 + 1]) / sum_states[n], 1.0, 3)

    def test_get_density_of_states_classical(self):
        """
        Test the SphericalTopRotor.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, 2000 * 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_density_of_states_quantum(self):
        """
        Test the SphericalTopRotor.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 SphericalTopRotor 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 SphericalTopRotor 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)