Ejemplo n.º 1
0
    def test_solve(self):
        """
        Test the simple batch reactor with a simple kinetic model. Here we
        choose a kinetic model consisting of the hydrogen abstraction reaction
        CH4 + C2H5 <=> CH3 + C2H6.
        """
        ch4 = Species(
            molecule=[Molecule().from_smiles("C")],
            thermo=ThermoData(
                Tdata=([300, 400, 500, 600, 800, 1000, 1500], "K"),
                Cpdata=([8.615, 9.687, 10.963, 12.301, 14.841, 16.976,
                         20.528], "cal/(mol*K)"),
                H298=(-17.714, "kcal/mol"),
                S298=(44.472, "cal/(mol*K)")))
        ch3 = Species(molecule=[Molecule().from_smiles("[CH3]")],
                      thermo=ThermoData(
                          Tdata=([300, 400, 500, 600, 800, 1000, 1500], "K"),
                          Cpdata=([
                              9.397, 10.123, 10.856, 11.571, 12.899, 14.055,
                              16.195
                          ], "cal/(mol*K)"),
                          H298=(9.357, "kcal/mol"),
                          S298=(45.174, "cal/(mol*K)")))
        c2h6 = Species(molecule=[Molecule().from_smiles("CC")],
                       thermo=ThermoData(
                           Tdata=([300, 400, 500, 600, 800, 1000, 1500], "K"),
                           Cpdata=([
                               12.684, 15.506, 18.326, 20.971, 25.500, 29.016,
                               34.595
                           ], "cal/(mol*K)"),
                           H298=(-19.521, "kcal/mol"),
                           S298=(54.799, "cal/(mol*K)")))
        c2h5 = Species(molecule=[Molecule().from_smiles("C[CH2]")],
                       thermo=ThermoData(
                           Tdata=([300, 400, 500, 600, 800, 1000, 1500], "K"),
                           Cpdata=([
                               11.635, 13.744, 16.085, 18.246, 21.885, 24.676,
                               29.107
                           ], "cal/(mol*K)"),
                           H298=(29.496, "kcal/mol"),
                           S298=(56.687, "cal/(mol*K)")))

        rxn1 = Reaction(reactants=[c2h6, ch3],
                        products=[c2h5, ch4],
                        kinetics=Arrhenius(A=(686.375 * 6, 'm^3/(mol*s)'),
                                           n=4.40721,
                                           Ea=(7.82799, 'kcal/mol'),
                                           T0=(298.15, 'K')))

        core_species = [ch4, ch3, c2h6, c2h5]
        edge_species = []
        core_reactions = [rxn1]
        edge_reactions = []

        T = 1000
        P = 1.0e5
        rxn_system = SimpleReactor(T,
                                   P,
                                   initial_mole_fractions={
                                       c2h5: 0.1,
                                       ch3: 0.1,
                                       ch4: 0.4,
                                       c2h6: 0.4
                                   },
                                   n_sims=1,
                                   termination=[])

        rxn_system.initialize_model(core_species, core_reactions, edge_species,
                                    edge_reactions)

        tlist = np.array([10**(i / 10.0) for i in range(-130, -49)],
                         np.float64)

        # Integrate to get the solution at each time point
        t = []
        y = []
        reaction_rates = []
        species_rates = []
        for t1 in tlist:
            rxn_system.advance(t1)
            t.append(rxn_system.t)
            # You must make a copy of y because it is overwritten by DASSL at
            # each call to advance()
            y.append(rxn_system.y.copy())
            reaction_rates.append(rxn_system.core_reaction_rates.copy())
            species_rates.append(rxn_system.core_species_rates.copy())

        # Convert the solution vectors to np arrays
        t = np.array(t, np.float64)
        y = np.array(y, np.float64)
        reaction_rates = np.array(reaction_rates, np.float64)
        species_rates = np.array(species_rates, np.float64)
        V = constants.R * rxn_system.T.value_si * np.sum(
            y) / rxn_system.P.value_si

        # Check that we're computing the species fluxes correctly
        for i in range(t.shape[0]):
            self.assertAlmostEqual(reaction_rates[i, 0],
                                   species_rates[i, 0],
                                   delta=1e-6 * reaction_rates[i, 0])
            self.assertAlmostEqual(reaction_rates[i, 0],
                                   -species_rates[i, 1],
                                   delta=1e-6 * reaction_rates[i, 0])
            self.assertAlmostEqual(reaction_rates[i, 0],
                                   -species_rates[i, 2],
                                   delta=1e-6 * reaction_rates[i, 0])
            self.assertAlmostEqual(reaction_rates[i, 0],
                                   species_rates[i, 3],
                                   delta=1e-6 * reaction_rates[i, 0])

        # Check that we've reached equilibrium
        self.assertAlmostEqual(reaction_rates[-1, 0], 0.0, delta=1e-2)

        # Unit test for the jacobian function:
        # Solve a reaction system and check if the analytical jacobian matches the finite difference jacobian

        h2 = Species(molecule=[Molecule().from_smiles("[H][H]")],
                     thermo=ThermoData(
                         Tdata=([300, 400, 500, 600, 800, 1000, 1500], "K"),
                         Cpdata=([6.89, 6.97, 6.99, 7.01, 7.08, 7.22,
                                  7.72], "cal/(mol*K)"),
                         H298=(0, "kcal/mol"),
                         S298=(31.23, "cal/(mol*K)")))

        rxn_list = [
            Reaction(reactants=[c2h6],
                     products=[ch3, ch3],
                     kinetics=Arrhenius(A=(686.375 * 6, '1/s'),
                                        n=4.40721,
                                        Ea=(7.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[ch3, ch3],
                     products=[c2h6],
                     kinetics=Arrhenius(A=(686.375 * 6, 'm^3/(mol*s)'),
                                        n=4.40721,
                                        Ea=(7.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h6, ch3],
                     products=[c2h5, ch4],
                     kinetics=Arrhenius(A=(46.375 * 6, 'm^3/(mol*s)'),
                                        n=3.40721,
                                        Ea=(6.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h5, ch4],
                     products=[c2h6, ch3],
                     kinetics=Arrhenius(A=(46.375 * 6, 'm^3/(mol*s)'),
                                        n=3.40721,
                                        Ea=(6.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h5, ch4],
                     products=[ch3, ch3, ch3],
                     kinetics=Arrhenius(A=(246.375 * 6, 'm^3/(mol*s)'),
                                        n=1.40721,
                                        Ea=(3.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[ch3, ch3, ch3],
                     products=[c2h5, ch4],
                     kinetics=Arrhenius(A=(246.375 * 6, 'm^6/(mol^2*s)'),
                                        n=1.40721,
                                        Ea=(3.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h6, ch3, ch3],
                     products=[c2h5, c2h5, h2],
                     kinetics=Arrhenius(A=(146.375 * 6, 'm^6/(mol^2*s)'),
                                        n=2.40721,
                                        Ea=(8.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h5, c2h5, h2],
                     products=[c2h6, ch3, ch3],
                     kinetics=Arrhenius(A=(146.375 * 6, 'm^6/(mol^2*s)'),
                                        n=2.40721,
                                        Ea=(8.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h6, c2h6],
                     products=[ch3, ch4, c2h5],
                     kinetics=Arrhenius(A=(1246.375 * 6, 'm^3/(mol*s)'),
                                        n=0.40721,
                                        Ea=(8.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[ch3, ch4, c2h5],
                     products=[c2h6, c2h6],
                     kinetics=Arrhenius(A=(46.375 * 6, 'm^6/(mol^2*s)'),
                                        n=0.10721,
                                        Ea=(8.82799, 'kcal/mol'),
                                        T0=(298.15, 'K')))
        ]

        for rxn in rxn_list:
            core_species = [ch4, ch3, c2h6, c2h5, h2]
            edge_species = []
            core_reactions = [rxn]

            rxn_system0 = SimpleReactor(T,
                                        P,
                                        initial_mole_fractions={
                                            ch4: 0.2,
                                            ch3: 0.1,
                                            c2h6: 0.35,
                                            c2h5: 0.15,
                                            h2: 0.2
                                        },
                                        n_sims=1,
                                        termination=[])
            rxn_system0.initialize_model(core_species, core_reactions,
                                         edge_species, edge_reactions)
            dydt0 = rxn_system0.residual(0.0, rxn_system0.y,
                                         np.zeros(rxn_system0.y.shape))[0]
            num_core_species = len(core_species)
            dN = .000001 * sum(rxn_system0.y)
            dN_array = dN * np.eye(num_core_species)

            dydt = []
            for i in range(num_core_species):
                rxn_system0.y[i] += dN
                dydt.append(
                    rxn_system0.residual(0.0, rxn_system0.y,
                                         np.zeros(rxn_system0.y.shape))[0])
                rxn_system0.y[i] -= dN  # reset y to original y0

            # Let the solver compute the jacobian
            solver_jacobian = rxn_system0.jacobian(0.0, rxn_system0.y, dydt0,
                                                   0.0)
            # Compute the jacobian using finite differences
            jacobian = np.zeros((num_core_species, num_core_species))
            for i in range(num_core_species):
                for j in range(num_core_species):
                    jacobian[i, j] = (dydt[j][i] - dydt0[i]) / dN
                    self.assertAlmostEqual(jacobian[i, j],
                                           solver_jacobian[i, j],
                                           delta=abs(1e-4 * jacobian[i, j]))

        # print 'Solver jacobian'
        # print solver_jacobian
        # print 'Numerical jacobian'
        # print jacobian

        # Unit test for the compute rate derivative
        rxn_list = [
            Reaction(reactants=[c2h6],
                     products=[ch3, ch3],
                     kinetics=Arrhenius(A=(686.375e6, '1/s'),
                                        n=4.40721,
                                        Ea=(7.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h6, ch3],
                     products=[c2h5, ch4],
                     kinetics=Arrhenius(A=(46.375 * 6, 'm^3/(mol*s)'),
                                        n=3.40721,
                                        Ea=(6.82799, 'kcal/mol'),
                                        T0=(298.15, 'K'))),
            Reaction(reactants=[c2h6, ch3, ch3],
                     products=[c2h5, c2h5, h2],
                     kinetics=Arrhenius(A=(146.375 * 6, 'm^6/(mol^2*s)'),
                                        n=2.40721,
                                        Ea=(8.82799, 'kcal/mol'),
                                        T0=(298.15, 'K')))
        ]

        core_species = [ch4, ch3, c2h6, c2h5, h2]
        edge_species = []
        core_reactions = rxn_list

        rxn_system0 = SimpleReactor(T,
                                    P,
                                    initial_mole_fractions={
                                        ch4: 0.2,
                                        ch3: 0.1,
                                        c2h6: 0.35,
                                        c2h5: 0.15,
                                        h2: 0.2
                                    },
                                    n_sims=1,
                                    termination=[])
        rxn_system0.initialize_model(core_species, core_reactions,
                                     edge_species, edge_reactions)
        dfdt0 = rxn_system0.residual(0.0, rxn_system0.y,
                                     np.zeros(rxn_system0.y.shape))[0]
        solver_dfdk = rxn_system0.compute_rate_derivative()
        # print 'Solver d(dy/dt)/dk'
        # print solver_dfdk

        integration_time = 1e-8
        rxn_system0.termination.append(TerminationTime(
            (integration_time, 's')))
        model_settings = ModelSettings(tol_keep_in_edge=0,
                                       tol_move_to_core=1,
                                       tol_interrupt_simulation=0)
        simulator_settings = SimulatorSettings()
        rxn_system0.simulate(core_species,
                             core_reactions, [], [], [], [],
                             model_settings=model_settings,
                             simulator_settings=simulator_settings)

        y0 = rxn_system0.y

        dfdk = np.zeros((num_core_species, len(rxn_list)))  # d(dy/dt)/dk

        for i in range(len(rxn_list)):
            k0 = rxn_list[i].get_rate_coefficient(T, P)
            rxn_list[i].kinetics.A.value_si = rxn_list[
                i].kinetics.A.value_si * (1 + 1e-3)
            dk = rxn_list[i].get_rate_coefficient(T, P) - k0

            rxn_system = SimpleReactor(T,
                                       P,
                                       initial_mole_fractions={
                                           ch4: 0.2,
                                           ch3: 0.1,
                                           c2h6: 0.35,
                                           c2h5: 0.15,
                                           h2: 0.2
                                       },
                                       n_sims=1,
                                       termination=[])
            rxn_system.initialize_model(core_species, core_reactions,
                                        edge_species, edge_reactions)

            dfdt = rxn_system.residual(0.0, rxn_system.y,
                                       np.zeros(rxn_system.y.shape))[0]
            dfdk[:, i] = (dfdt - dfdt0) / dk

            rxn_system.termination.append(
                TerminationTime((integration_time, 's')))
            model_settings = ModelSettings(tol_keep_in_edge=0,
                                           tol_move_to_core=1,
                                           tol_interrupt_simulation=0)
            simulator_settings = SimulatorSettings()

            rxn_system.simulate(core_species,
                                core_reactions, [], [], [], [],
                                model_settings=model_settings,
                                simulator_settings=simulator_settings)

            rxn_list[i].kinetics.A.value_si = rxn_list[
                i].kinetics.A.value_si / (1 + 1e-3)  # reset A factor

        for i in range(num_core_species):
            for j in range(len(rxn_list)):
                self.assertAlmostEqual(dfdk[i, j],
                                       solver_dfdk[i, j],
                                       delta=abs(1e-3 * dfdk[i, j]))
Ejemplo n.º 2
0
    def test_specific_collider_model(self):
        """
        Test the solver's ability to simulate a model with specific third body species collision efficiencies.
        """
        chem_file = os.path.join(os.path.dirname(__file__), 'files',
                                 'specific_collider_model', 'chem.inp')
        dictionary_file = os.path.join(os.path.dirname(__file__), 'files',
                                       'specific_collider_model',
                                       'species_dictionary.txt')
        species_list, reaction_list = load_chemkin_file(
            chem_file, dictionary_file)

        smiles_dict = {
            'Ar': '[Ar]',
            'N2(1)': 'N#N',
            'O2': '[O][O]',
            'H': '[H]',
            'CH3': '[CH3]',
            'CH4': 'C'
        }
        species_dict = {}
        for name, smiles in smiles_dict.items():
            mol = Molecule(smiles=smiles)
            for species in species_list:
                if species.is_isomorphic(mol):
                    species_dict[name] = species
                    break

        T = 1000  # K
        P = 10  # Pa
        initial_mole_fractions = {
            species_dict['Ar']: 2.0,
            species_dict['N2(1)']: 1.0,
            species_dict['O2']: 0.5,
            species_dict['H']: 0.1,
            species_dict['CH3']: 0.1,
            species_dict['CH4']: 0.001
        }

        # Initialize the model
        rxn_system = SimpleReactor(
            T,
            P,
            initial_mole_fractions=initial_mole_fractions,
            n_sims=1,
            termination=None)
        rxn_system.initialize_model(species_list, reaction_list, [], [])

        # Advance to time = 0.1 s
        rxn_system.advance(0.1)
        # Compare simulated mole fractions with expected mole fractions from CHEMKIN
        simulated_mole_fracs = rxn_system.y / np.sum(rxn_system.y)
        expected_mole_fracs = np.array([
            0.540394532, 0.270197216, 0.135098608, 0.027019722, 0.027019722,
            0.000270202
        ])
        # order: Ar, N2, O2, H, CH3, CH4
        for i in range(len(simulated_mole_fracs)):
            self.assertAlmostEqual(simulated_mole_fracs[i],
                                   expected_mole_fracs[i], 6)

        # Advance to time = 5 s
        rxn_system.advance(5)
        # Compare simulated mole fractions with expected mole fractions from CHEMKIN
        expected_mole_fracs = np.array([
            0.540394573, 0.270197287, 0.135098693, 0.027019519, 0.027019519,
            0.00027041
        ])
        # order: Ar, N2, O2, H, CH3, CH4
        for i in range(len(simulated_mole_fracs)):
            self.assertAlmostEqual(simulated_mole_fracs[i],
                                   expected_mole_fracs[i], 6)

        # Try a new set of conditions
        T = 850  # K
        P = 200  # Pa
        initial_mole_fractions = {
            species_dict['Ar']: 1.0,
            species_dict['N2(1)']: 0.5,
            species_dict['O2']: 0.5,
            species_dict['H']: 0.001,
            species_dict['CH3']: 0.01,
            species_dict['CH4']: 0.5
        }

        # Initialize the model
        rxn_system = SimpleReactor(
            T,
            P,
            initial_mole_fractions=initial_mole_fractions,
            n_sims=1,
            termination=None)
        rxn_system.initialize_model(species_list, reaction_list, [], [])

        # Advance to time = 5 s
        rxn_system.advance(5)
        # Compare simulated mole fractions with expected mole fractions from CHEMKIN
        simulated_mole_fracs = rxn_system.y / np.sum(rxn_system.y)
        expected_mole_fracs = np.array([
            0.398247713, 0.199123907, 0.199123907, 0.000398169, 0.003982398,
            0.199123907
        ])
        # order: Ar, N2, O2, H, CH3, CH4
        for i in range(len(simulated_mole_fracs)):
            self.assertAlmostEqual(simulated_mole_fracs[i],
                                   expected_mole_fracs[i], 6)
Ejemplo n.º 3
0
    def test_collider_model(self):
        """
        Test the solver's ability to simulate a model with collision efficiencies.
        """
        chem_file = os.path.join(os.path.dirname(__file__), 'files',
                                 'collider_model', 'chem.inp')
        dictionary_file = os.path.join(os.path.dirname(__file__), 'files',
                                       'collider_model',
                                       'species_dictionary.txt')
        species_list, reaction_list = load_chemkin_file(
            chem_file, dictionary_file)

        smiles_dict = {
            'H': '[H]',
            'HO2': '[O]O',
            'O2': '[O][O]',
            'Ar': '[Ar]',
            'N2': 'N#N',
            'CO2': 'O=C=O',
            'CH3': '[CH3]',
            'CH4': 'C'
        }
        species_dict = {}
        for name, smiles in smiles_dict.items():
            mol = Molecule(smiles=smiles)
            for species in species_list:
                if species.is_isomorphic(mol):
                    species_dict[name] = species
                    break

        T = 1000  # K
        P = 10  # Pa
        initial_mole_fractions = {
            species_dict['O2']: 0.5,
            species_dict['H']: 0.5,
            species_dict['CO2']: 1.0,
            species_dict['Ar']: 4.0
        }

        # Initialize the model
        rxn_system = SimpleReactor(
            T,
            P,
            initial_mole_fractions=initial_mole_fractions,
            n_sims=1,
            termination=None)
        rxn_system.initialize_model(species_list, reaction_list, [], [])

        # Advance to time = 0.1 s
        rxn_system.advance(0.1)
        # Compare simulated mole fractions with expected mole fractions from CHEMKIN
        simulated_mole_fracs = rxn_system.y / np.sum(rxn_system.y)
        expected_mole_fracs = np.array([
            0.6666667, 0, 0, 0, 0.1666667, 0, 0.08333333, 0.08333333,
            2.466066000000000E-10, 0, 0, 0, 0, 0
        ])
        for i in range(len(simulated_mole_fracs)):
            self.assertAlmostEqual(simulated_mole_fracs[i],
                                   expected_mole_fracs[i])

        # Advance to time = 5 s
        rxn_system.advance(5)
        # Compare simulated mole fractions with expected mole fractions from CHEMKIN
        expected_mole_fracs = np.array([
            0.6666667, 0, 0, 0, 0.1666667, 0, 0.08333332, 0.08333332,
            1.233033000000000E-08, 0, 0, 0, 0, 0
        ])
        for i in range(len(simulated_mole_fracs)):
            self.assertAlmostEqual(simulated_mole_fracs[i],
                                   expected_mole_fracs[i])

        # Try a new set of conditions

        T = 850  # K
        P = 200  # Pa
        initial_mole_fractions = {
            species_dict['O2']: 0.5,
            species_dict['H']: 1,
            species_dict['CO2']: 1,
            species_dict['N2']: 4,
            species_dict['CH3']: 1
        }

        # Initialize the model
        rxn_system = SimpleReactor(
            T,
            P,
            initial_mole_fractions=initial_mole_fractions,
            n_sims=1,
            termination=None)
        rxn_system.initialize_model(species_list, reaction_list, [], [])

        # Advance to time = 5 s
        rxn_system.advance(5)

        # Compare simulated mole fractions with expected mole fractions from CHEMKIN
        simulated_mole_fracs = rxn_system.y / np.sum(rxn_system.y)
        expected_mole_fracs = np.array([
            0, 0, 0, 0.5487241, 0.137181, 0, 0.1083234, 0.0685777,
            1.280687000000000E-05, 0, 0, 0, 0.1083362, 0.02884481
        ])
        for i in range(len(simulated_mole_fracs)):
            self.assertAlmostEqual(simulated_mole_fracs[i],
                                   expected_mole_fracs[i])