def setUp(self): """ A function run before each unit test in this class. """ self.Tmin = 350.0 self.Tmax = 1500.0 self.comment = "Comment" self.arrhenius = [ Arrhenius( A=(9.3e-14, "cm^3/(molecule*s)"), n=0.0, Ea=(4740 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), Arrhenius( A=(1.4e-9, "cm^3/(molecule*s)"), n=0.0, Ea=(11200 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), ] self.kinetics = MultiArrhenius( arrhenius=self.arrhenius, Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment ) self.single_kinetics = MultiArrhenius( arrhenius=self.arrhenius[:1], Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment )
def setUp(self): """ A function run before each unit test in this class. """ self.Tmin = 350. self.Tmax = 1500. self.comment = 'Comment' self.arrhenius = [ Arrhenius( A=(9.3e-14, "cm^3/(molecule*s)"), n=0.0, Ea=(4740 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), Arrhenius( A=(1.4e-9, "cm^3/(molecule*s)"), n=0.0, Ea=(11200 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), ] self.kinetics = MultiArrhenius( arrhenius=self.arrhenius, Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ) self.single_kinetics = MultiArrhenius( arrhenius=self.arrhenius[:1], Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, )
def get_arrhenius_from_param(params, settings, arrh_type='Arrhenius'): """ Get Arrhenius object given params and settings Args: params (dict) : A dictionary contains the information about A factor, n, Ea, T0 and multiplier settings (dict): A dictionary contains the information about variable units, T and P range, description arrh_type (str): The type of Arrhenius object to be added, supporting Arrhenius, MultiArrhenius, and PdepArrehnius Returns: (Arrhenius object): The Arrhenius object generated """ args = {} if 'Tmin' in settings and settings['Tmin']: args['Tmin'] = (settings['Tmin'], settings['T_unit']) if 'Tmax' in settings and settings['Tmax']: args['Tmax'] = (settings['Tmax'], settings['T_unit']) if 'Pmin' in settings and settings['Pmin']: args['Pmin'] = (settings['Pmin'], settings['P_unit']) if 'Pmax' in settings and settings['Pmax']: args['Pmax'] = (settings['Pmax'], settings['P_unit']) if 'comment' in settings and settings['comment']: args['comment'] = settings['comment'] if arrh_type == 'Arrhenius': args['A'] = (params['A'], settings['A_unit']) args['n'] = params['n'] args['Ea'] = (params['Ea'], settings['E_unit']) if 'T0' in params and params['T0']: args['T0'] = (params['T0'], settings['T_unit']) if 'uncertainty' in params and params['uncertainty']: args['uncertainty'] = params['uncertainty'] return Arrhenius(**args) elif arrh_type == 'MultiArrhenius': args['arrhenius'] = params['arrhenius'] return MultiArrhenius(**args) elif arrh_type == 'PdepArrhenius': args['arrhenius'] = params['arrhenius'] args['pressures'] = (params['pressures'], settings['P_unit']) if 'highPlimit' and params['highPlimit']: args['highPlimit'] = params['highPlimit'] return PDepArrhenius(**args)
class TestMultiArrhenius(unittest.TestCase): """ Contains unit tests of the :class:`MultiArrhenius` class. """ def setUp(self): """ A function run before each unit test in this class. """ self.Tmin = 350. self.Tmax = 1500. self.comment = 'Comment' self.arrhenius = [ Arrhenius( A=(9.3e-14, "cm^3/(molecule*s)"), n=0.0, Ea=(4740 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), Arrhenius( A=(1.4e-9, "cm^3/(molecule*s)"), n=0.0, Ea=(11200 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), ] self.kinetics = MultiArrhenius( arrhenius=self.arrhenius, Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ) self.single_kinetics = MultiArrhenius( arrhenius=self.arrhenius[:1], Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ) def test_arrhenius(self): """ Test that the MultiArrhenius A property was properly set. """ self.assertEqual(self.kinetics.arrhenius, self.arrhenius) def test_Tmin(self): """ Test that the MultiArrhenius Tmin property was properly set. """ self.assertAlmostEqual(self.kinetics.Tmin.value_si, self.Tmin, 6) def test_Tmax(self): """ Test that the MultiArrhenius Tmax property was properly set. """ self.assertAlmostEqual(self.kinetics.Tmax.value_si, self.Tmax, 6) def test_comment(self): """ Test that the MultiArrhenius comment property was properly set. """ self.assertEqual(self.kinetics.comment, self.comment) def test_isTemperatureValid(self): """ Test the MultiArrhenius.isTemperatureValid() method. """ Tdata = numpy.array( [200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800, 2000]) validdata = numpy.array( [False, True, True, True, True, True, True, False, False, False], numpy.bool) for T, valid in zip(Tdata, validdata): valid0 = self.kinetics.isTemperatureValid(T) self.assertEqual(valid0, valid) def test_getRateCoefficient(self): """ Test the MultiArrhenius.getRateCoefficient() method. """ Tlist = numpy.array( [200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800, 2000]) kexplist = numpy.array([ 2.85400e-06, 4.00384e-01, 2.73563e+01, 8.50699e+02, 1.20181e+04, 7.56312e+04, 2.84724e+05, 7.71702e+05, 1.67743e+06, 3.12290e+06 ]) for T, kexp in zip(Tlist, kexplist): kact = self.kinetics.getRateCoefficient(T) self.assertAlmostEqual(kexp, kact, delta=1e-4 * kexp) def test_pickle(self): """ Test that a MultiArrhenius object can be pickled and unpickled with no loss of information. """ import cPickle kinetics = cPickle.loads(cPickle.dumps(self.kinetics, -1)) self.assertEqual(len(self.kinetics.arrhenius), len(kinetics.arrhenius)) for arrh0, arrh in zip(self.kinetics.arrhenius, kinetics.arrhenius): self.assertAlmostEqual(arrh0.A.value, arrh.A.value, delta=1e-18) self.assertEqual(arrh0.A.units, arrh.A.units) self.assertAlmostEqual(arrh0.n.value, arrh.n.value, 4) self.assertAlmostEqual(arrh0.Ea.value, arrh.Ea.value, 4) self.assertEqual(arrh0.Ea.units, arrh.Ea.units) self.assertAlmostEqual(arrh0.T0.value, arrh.T0.value, 4) self.assertEqual(arrh0.T0.units, arrh.T0.units) self.assertAlmostEqual(self.kinetics.Tmin.value, kinetics.Tmin.value, 4) self.assertEqual(self.kinetics.Tmin.units, kinetics.Tmin.units) self.assertAlmostEqual(self.kinetics.Tmax.value, kinetics.Tmax.value, 4) self.assertEqual(self.kinetics.Tmax.units, kinetics.Tmax.units) self.assertEqual(self.kinetics.comment, kinetics.comment) def test_repr(self): """ Test that a MultiArrhenius object can be reconstructed from its repr() output with no loss of information. """ kinetics = None exec('kinetics = {0!r}'.format(self.kinetics)) self.assertEqual(len(self.kinetics.arrhenius), len(kinetics.arrhenius)) for arrh0, arrh in zip(self.kinetics.arrhenius, kinetics.arrhenius): self.assertAlmostEqual(arrh0.A.value, arrh.A.value, delta=1e-18) self.assertEqual(arrh0.A.units, arrh.A.units) self.assertAlmostEqual(arrh0.n.value, arrh.n.value, 4) self.assertAlmostEqual(arrh0.Ea.value, arrh.Ea.value, 4) self.assertEqual(arrh0.Ea.units, arrh.Ea.units) self.assertAlmostEqual(arrh0.T0.value, arrh.T0.value, 4) self.assertEqual(arrh0.T0.units, arrh.T0.units) self.assertAlmostEqual(self.kinetics.Tmin.value, kinetics.Tmin.value, 4) self.assertEqual(self.kinetics.Tmin.units, kinetics.Tmin.units) self.assertAlmostEqual(self.kinetics.Tmax.value, kinetics.Tmax.value, 4) self.assertEqual(self.kinetics.Tmax.units, kinetics.Tmax.units) self.assertEqual(self.kinetics.comment, kinetics.comment) def test_toArrhenius(self): """ Test that we can convert to an Arrhenius """ answer = self.single_kinetics.arrhenius[0] fitted = self.single_kinetics.toArrhenius() self.assertAlmostEqual(fitted.A.value_si, answer.A.value_si, delta=1e0) self.assertAlmostEqual(fitted.n.value_si, answer.n.value_si, 1, 4) self.assertAlmostEqual(fitted.Ea.value_si, answer.Ea.value_si, 2) self.assertAlmostEqual(fitted.T0.value_si, answer.T0.value_si, 4) def test_toArrheniusTrange(self): """ Test the toArrhenius temperature range is set correctly. """ answer = self.single_kinetics.arrhenius[0] fitted = self.single_kinetics.toArrhenius(Tmin=800, Tmax=1200) self.assertAlmostEqual(fitted.Tmin.value_si, 800.0) self.assertAlmostEqual(fitted.Tmax.value_si, 1200.0) for T in [800, 1000, 1200]: self.assertAlmostEqual( fitted.getRateCoefficient(T) / answer.getRateCoefficient(T), 1.0) def test_toArrheniusMultiple(self): """ Test the toArrhenius fitting multiple kinetics over a small range, see if we're within 5% at a few points """ answer = self.kinetics fitted = self.kinetics.toArrhenius(Tmin=800, Tmax=1200) self.assertAlmostEqual(fitted.Tmin.value_si, 800.0) self.assertAlmostEqual(fitted.Tmax.value_si, 1200.0) for T in [800, 1000, 1200]: self.assertAlmostEqual(fitted.getRateCoefficient(T) / answer.getRateCoefficient(T), 1.0, delta=0.05) def test_changeRate(self): """ Test the MultiArrhenius.changeRate() method. """ Tlist = numpy.array([ 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500 ]) k0list = numpy.array( [self.kinetics.getRateCoefficient(T) for T in Tlist]) self.kinetics.changeRate(2) for T, kexp in zip(Tlist, k0list): kact = self.kinetics.getRateCoefficient(T) self.assertAlmostEqual(2 * kexp, kact, delta=1e-6 * kexp)
def test_process_duplicate_reactions(self): """ Test that duplicate reactions are handled correctly when loading a Chemkin file. """ s1 = Species().from_smiles('CC') s2 = Species().from_smiles('[CH3]') s3 = Species().from_smiles('[OH]') s4 = Species().from_smiles('C[CH2]') s5 = Species().from_smiles('O') r1 = Reaction(reactants=[s1], products=[s2, s2], duplicate=False, kinetics=Arrhenius()) r2 = Reaction(reactants=[s1, s3], products=[s4, s5], duplicate=True, kinetics=Arrhenius()) r3 = Reaction(reactants=[s1, s3], products=[s4, s5], duplicate=True, kinetics=Arrhenius()) r4 = Reaction(reactants=[s1, s3], products=[s4, s5], duplicate=False, kinetics=Arrhenius()) r5 = LibraryReaction(reactants=[s1, s3], products=[s4, s5], duplicate=True, kinetics=Arrhenius(), library='lib1') r6 = LibraryReaction(reactants=[s1, s3], products=[s4, s5], duplicate=True, kinetics=Arrhenius(), library='lib2') r7 = LibraryReaction(reactants=[s1, s3], products=[s4, s5], duplicate=True, kinetics=Chebyshev(), library='lib1') r8 = LibraryReaction(reactants=[s1, s3], products=[s4, s5], duplicate=True, kinetics=Arrhenius(), library='lib1') r9 = LibraryReaction( reactants=[s1, s3], products=[s4, s5], duplicate=False, kinetics=MultiArrhenius( arrhenius=[Arrhenius(), Arrhenius()]), library='lib1') reaction_list_with_duplicate = [r1, r2, r3] reaction_list_with_duplicate2 = [r1, r2, r3] reaction_list_unmarked_duplicate = [r1, r2, r4] reaction_list_unequal_libraries = [r1, r5, r6] reaction_list_mixed_kinetics = [r1, r5, r7] reaction_list_mergeable = [r1, r5, r8] reaction_list_merged = [r1, r9] # Test that duplicates are not removed for non-library reactions _process_duplicate_reactions(reaction_list_with_duplicate) self.assertEqual(reaction_list_with_duplicate, reaction_list_with_duplicate2) # Test that unmarked duplicate reactions are detected if both # reactions are p-dep or p-indep self.assertRaisesRegexp(ChemkinError, 'Encountered unmarked duplicate reaction', _process_duplicate_reactions, reaction_list_unmarked_duplicate) # Test that unequal libraries are recognized self.assertRaisesRegexp(ChemkinError, 'from different libraries', _process_duplicate_reactions, reaction_list_unequal_libraries) # Test that an error is raised for reactions with kinetics # that cannot be merged self.assertRaisesRegexp(ChemkinError, 'Mixed kinetics for duplicate reaction', _process_duplicate_reactions, reaction_list_mixed_kinetics) # Test that duplicate library reactions are merged successfully _process_duplicate_reactions(reaction_list_mergeable) self.assertEqual(len(reaction_list_mergeable), len(reaction_list_merged)) self.assertEqual(reaction_list_mergeable[0], reaction_list_merged[0]) rtest = reaction_list_mergeable[1] rtrue = reaction_list_merged[1] self.assertEqual(rtest.reactants, rtrue.reactants) self.assertEqual(rtest.products, rtrue.products) self.assertEqual(rtest.duplicate, rtrue.duplicate) self.assertEqual(rtest.library, rtrue.library) self.assertTrue(isinstance(rtest.kinetics, MultiArrhenius)) self.assertTrue( all(isinstance(k, Arrhenius) for k in rtest.kinetics.arrhenius))
class TestMultiArrhenius(unittest.TestCase): """ Contains unit tests of the :class:`MultiArrhenius` class. """ def setUp(self): """ A function run before each unit test in this class. """ self.Tmin = 350.0 self.Tmax = 1500.0 self.comment = "" self.arrhenius = [ Arrhenius( A=(9.3e-14, "cm^3/(molecule*s)"), n=0.0, Ea=(4740 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), Arrhenius( A=(1.4e-9, "cm^3/(molecule*s)"), n=0.0, Ea=(11200 * constants.R * 0.001, "kJ/mol"), T0=(1, "K"), Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment, ), ] self.kinetics = MultiArrhenius( arrhenius=self.arrhenius, Tmin=(self.Tmin, "K"), Tmax=(self.Tmax, "K"), comment=self.comment ) def test_arrhenius(self): """ Test that the MultiArrhenius A property was properly set. """ self.assertEqual(self.kinetics.arrhenius, self.arrhenius) def test_Tmin(self): """ Test that the MultiArrhenius Tmin property was properly set. """ self.assertAlmostEqual(self.kinetics.Tmin.value_si, self.Tmin, 6) def test_Tmax(self): """ Test that the MultiArrhenius Tmax property was properly set. """ self.assertAlmostEqual(self.kinetics.Tmax.value_si, self.Tmax, 6) def test_comment(self): """ Test that the MultiArrhenius comment property was properly set. """ self.assertEqual(self.kinetics.comment, self.comment) def test_isTemperatureValid(self): """ Test the MultiArrhenius.isTemperatureValid() method. """ Tdata = numpy.array([200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800, 2000]) validdata = numpy.array([False, True, True, True, True, True, True, False, False, False], numpy.bool) for T, valid in zip(Tdata, validdata): valid0 = self.kinetics.isTemperatureValid(T) self.assertEqual(valid0, valid) def test_getRateCoefficient(self): """ Test the MultiArrhenius.getRateCoefficient() method. """ Tlist = numpy.array([200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800, 2000]) kexplist = numpy.array( [ 2.85400e-06, 4.00384e-01, 2.73563e01, 8.50699e02, 1.20181e04, 7.56312e04, 2.84724e05, 7.71702e05, 1.67743e06, 3.12290e06, ] ) for T, kexp in zip(Tlist, kexplist): kact = self.kinetics.getRateCoefficient(T) self.assertAlmostEqual(kexp, kact, delta=1e-4 * kexp) def test_pickle(self): """ Test that a MultiArrhenius object can be pickled and unpickled with no loss of information. """ import cPickle kinetics = cPickle.loads(cPickle.dumps(self.kinetics)) self.assertEqual(len(self.kinetics.arrhenius), len(kinetics.arrhenius)) for arrh0, arrh in zip(self.kinetics.arrhenius, kinetics.arrhenius): self.assertAlmostEqual(arrh0.A.value, arrh.A.value, delta=1e-18) self.assertEqual(arrh0.A.units, arrh.A.units) self.assertAlmostEqual(arrh0.n.value, arrh.n.value, 4) self.assertAlmostEqual(arrh0.Ea.value, arrh.Ea.value, 4) self.assertEqual(arrh0.Ea.units, arrh.Ea.units) self.assertAlmostEqual(arrh0.T0.value, arrh.T0.value, 4) self.assertEqual(arrh0.T0.units, arrh.T0.units) self.assertAlmostEqual(self.kinetics.Tmin.value, kinetics.Tmin.value, 4) self.assertEqual(self.kinetics.Tmin.units, kinetics.Tmin.units) self.assertAlmostEqual(self.kinetics.Tmax.value, kinetics.Tmax.value, 4) self.assertEqual(self.kinetics.Tmax.units, kinetics.Tmax.units) self.assertEqual(self.kinetics.comment, kinetics.comment) def test_repr(self): """ Test that a MultiArrhenius object can be reconstructed from its repr() output with no loss of information. """ kinetics = None exec("kinetics = {0!r}".format(self.kinetics)) self.assertEqual(len(self.kinetics.arrhenius), len(kinetics.arrhenius)) for arrh0, arrh in zip(self.kinetics.arrhenius, kinetics.arrhenius): self.assertAlmostEqual(arrh0.A.value, arrh.A.value, delta=1e-18) self.assertEqual(arrh0.A.units, arrh.A.units) self.assertAlmostEqual(arrh0.n.value, arrh.n.value, 4) self.assertAlmostEqual(arrh0.Ea.value, arrh.Ea.value, 4) self.assertEqual(arrh0.Ea.units, arrh.Ea.units) self.assertAlmostEqual(arrh0.T0.value, arrh.T0.value, 4) self.assertEqual(arrh0.T0.units, arrh.T0.units) self.assertAlmostEqual(self.kinetics.Tmin.value, kinetics.Tmin.value, 4) self.assertEqual(self.kinetics.Tmin.units, kinetics.Tmin.units) self.assertAlmostEqual(self.kinetics.Tmax.value, kinetics.Tmax.value, 4) self.assertEqual(self.kinetics.Tmax.units, kinetics.Tmax.units) self.assertEqual(self.kinetics.comment, kinetics.comment)
class TestMultiArrhenius(unittest.TestCase): """ Contains unit tests of the :class:`MultiArrhenius` class. """ def setUp(self): """ A function run before each unit test in this class. """ self.Tmin = 350. self.Tmax = 1500. self.comment = 'Comment' self.arrhenius = [ Arrhenius( A = (9.3e-14,"cm^3/(molecule*s)"), n = 0.0, Ea = (4740*constants.R*0.001,"kJ/mol"), T0 = (1,"K"), Tmin = (self.Tmin,"K"), Tmax = (self.Tmax,"K"), comment = self.comment, ), Arrhenius( A = (1.4e-9,"cm^3/(molecule*s)"), n = 0.0, Ea = (11200*constants.R*0.001,"kJ/mol"), T0 = (1,"K"), Tmin = (self.Tmin,"K"), Tmax = (self.Tmax,"K"), comment = self.comment, ), ] self.kinetics = MultiArrhenius( arrhenius = self.arrhenius, Tmin = (self.Tmin,"K"), Tmax = (self.Tmax,"K"), comment = self.comment, ) self.single_kinetics = MultiArrhenius( arrhenius = self.arrhenius[:1], Tmin = (self.Tmin,"K"), Tmax = (self.Tmax,"K"), comment = self.comment, ) def test_arrhenius(self): """ Test that the MultiArrhenius A property was properly set. """ self.assertEqual(self.kinetics.arrhenius, self.arrhenius) def test_Tmin(self): """ Test that the MultiArrhenius Tmin property was properly set. """ self.assertAlmostEqual(self.kinetics.Tmin.value_si, self.Tmin, 6) def test_Tmax(self): """ Test that the MultiArrhenius Tmax property was properly set. """ self.assertAlmostEqual(self.kinetics.Tmax.value_si, self.Tmax, 6) def test_comment(self): """ Test that the MultiArrhenius comment property was properly set. """ self.assertEqual(self.kinetics.comment, self.comment) def test_isTemperatureValid(self): """ Test the MultiArrhenius.isTemperatureValid() method. """ Tdata = numpy.array([200,400,600,800,1000,1200,1400,1600,1800,2000]) validdata = numpy.array([False,True,True,True,True,True,True,False,False,False], numpy.bool) for T, valid in zip(Tdata, validdata): valid0 = self.kinetics.isTemperatureValid(T) self.assertEqual(valid0, valid) def test_getRateCoefficient(self): """ Test the MultiArrhenius.getRateCoefficient() method. """ Tlist = numpy.array([200,400,600,800,1000,1200,1400,1600,1800,2000]) kexplist = numpy.array([2.85400e-06, 4.00384e-01, 2.73563e+01, 8.50699e+02, 1.20181e+04, 7.56312e+04, 2.84724e+05, 7.71702e+05, 1.67743e+06, 3.12290e+06]) for T, kexp in zip(Tlist, kexplist): kact = self.kinetics.getRateCoefficient(T) self.assertAlmostEqual(kexp, kact, delta=1e-4*kexp) def test_pickle(self): """ Test that a MultiArrhenius object can be pickled and unpickled with no loss of information. """ import cPickle kinetics = cPickle.loads(cPickle.dumps(self.kinetics,-1)) self.assertEqual(len(self.kinetics.arrhenius), len(kinetics.arrhenius)) for arrh0, arrh in zip(self.kinetics.arrhenius, kinetics.arrhenius): self.assertAlmostEqual(arrh0.A.value, arrh.A.value, delta=1e-18) self.assertEqual(arrh0.A.units, arrh.A.units) self.assertAlmostEqual(arrh0.n.value, arrh.n.value, 4) self.assertAlmostEqual(arrh0.Ea.value, arrh.Ea.value, 4) self.assertEqual(arrh0.Ea.units, arrh.Ea.units) self.assertAlmostEqual(arrh0.T0.value, arrh.T0.value, 4) self.assertEqual(arrh0.T0.units, arrh.T0.units) self.assertAlmostEqual(self.kinetics.Tmin.value, kinetics.Tmin.value, 4) self.assertEqual(self.kinetics.Tmin.units, kinetics.Tmin.units) self.assertAlmostEqual(self.kinetics.Tmax.value, kinetics.Tmax.value, 4) self.assertEqual(self.kinetics.Tmax.units, kinetics.Tmax.units) self.assertEqual(self.kinetics.comment, kinetics.comment) def test_repr(self): """ Test that a MultiArrhenius object can be reconstructed from its repr() output with no loss of information. """ kinetics = None exec('kinetics = {0!r}'.format(self.kinetics)) self.assertEqual(len(self.kinetics.arrhenius), len(kinetics.arrhenius)) for arrh0, arrh in zip(self.kinetics.arrhenius, kinetics.arrhenius): self.assertAlmostEqual(arrh0.A.value, arrh.A.value, delta=1e-18) self.assertEqual(arrh0.A.units, arrh.A.units) self.assertAlmostEqual(arrh0.n.value, arrh.n.value, 4) self.assertAlmostEqual(arrh0.Ea.value, arrh.Ea.value, 4) self.assertEqual(arrh0.Ea.units, arrh.Ea.units) self.assertAlmostEqual(arrh0.T0.value, arrh.T0.value, 4) self.assertEqual(arrh0.T0.units, arrh.T0.units) self.assertAlmostEqual(self.kinetics.Tmin.value, kinetics.Tmin.value, 4) self.assertEqual(self.kinetics.Tmin.units, kinetics.Tmin.units) self.assertAlmostEqual(self.kinetics.Tmax.value, kinetics.Tmax.value, 4) self.assertEqual(self.kinetics.Tmax.units, kinetics.Tmax.units) self.assertEqual(self.kinetics.comment, kinetics.comment) def test_toArrhenius(self): """ Test that we can convert to an Arrhenius """ answer = self.single_kinetics.arrhenius[0] fitted = self.single_kinetics.toArrhenius() self.assertAlmostEqual(fitted.A.value_si, answer.A.value_si, delta=1e0) self.assertAlmostEqual(fitted.n.value_si, answer.n.value_si, 1, 4) self.assertAlmostEqual(fitted.Ea.value_si, answer.Ea.value_si, 2) self.assertAlmostEqual(fitted.T0.value_si, answer.T0.value_si, 4) def test_toArrheniusTrange(self): """ Test the toArrhenius temperature range is set correctly. """ answer = self.single_kinetics.arrhenius[0] fitted = self.single_kinetics.toArrhenius(Tmin=800, Tmax=1200) self.assertAlmostEqual(fitted.Tmin.value_si, 800.0) self.assertAlmostEqual(fitted.Tmax.value_si, 1200.0) for T in [800,1000,1200]: self.assertAlmostEqual(fitted.getRateCoefficient(T) / answer.getRateCoefficient(T), 1.0) def test_toArrheniusMultiple(self): """ Test the toArrhenius fitting multiple kinetics over a small range, see if we're within 5% at a few points """ answer = self.kinetics fitted = self.kinetics.toArrhenius(Tmin=800, Tmax=1200) self.assertAlmostEqual(fitted.Tmin.value_si, 800.0) self.assertAlmostEqual(fitted.Tmax.value_si, 1200.0) for T in [800,1000,1200]: self.assertAlmostEqual(fitted.getRateCoefficient(T) / answer.getRateCoefficient(T), 1.0, delta=0.05) def test_changeRate(self): """ Test the MultiArrhenius.changeRate() method. """ Tlist = numpy.array([300,400,500,600,700,800,900,1000,1100,1200,1300,1400,1500]) k0list = numpy.array([self.kinetics.getRateCoefficient(T) for T in Tlist]) self.kinetics.changeRate(2) for T, kexp in zip(Tlist, k0list): kact = self.kinetics.getRateCoefficient(T) self.assertAlmostEqual(2*kexp, kact, delta=1e-6*kexp)