diff --git a/documentation/source/users/rmg/input.rst b/documentation/source/users/rmg/input.rst index 40663fc8d4b..ba0d5a9ca1f 100644 --- a/documentation/source/users/rmg/input.rst +++ b/documentation/source/users/rmg/input.rst @@ -1073,13 +1073,17 @@ Miscellaneous options:: units='si', generateOutputHTML=True, generatePlots=False, - generatePESDiagrams=False, + generatePESDiagrams=False, saveSimulationProfiles=True, verboseComments=False, saveEdgeSpecies=True, keepIrreversible=True, trimolecularProductReversible=False, - saveSeedModulus=-1 + saveSeedModulus=-1, + generateChemkin=True, + generateRMSYAML=True, + generateCanteraYAML1=False, + generateCanteraYAML2=False, ) The ``name`` field is the name of any generated seed mechanisms @@ -1090,8 +1094,10 @@ Setting ``saveSeedToDatabase`` to ``True`` tells RMG (if generating a seed) to a The ``units`` field is set to ``si``. Currently there are no other unit options. -Setting ``generateOutputHTML`` to ``True`` will let RMG know that you want to save 2-D images (png files in the local ``species`` folder) of all species in the generated core model. It will save a visualized -HTML file for your model containing all the species and reactions. Turning this feature off by setting it to ``False`` may save memory if running large jobs. +Setting ``generateOutputHTML`` to ``True`` will let RMG know that you want to save 2-D images (png files in the local ``species`` folder) of all species in the generated core model. +It will save a visualized HTML file for your model containing all the species and reactions. +Turning this feature off by setting it to ``False`` may save memory if running large jobs. +It can be configured using a dictionary of settings in place of the ``True`` statement, as described below. Setting ``generatePlots`` to ``True`` will generate a number of plots describing the statistics of the RMG job, including the reaction model core and edge size and memory use versus execution time. These will be placed in the output directory in the plot/ folder. @@ -1099,9 +1105,9 @@ Setting ``generatePESDiagrams`` to ``True`` will generate potential energy surfa Setting ``saveSimulationProfiles`` to ``True`` will make RMG save csv files of the simulation in .csv files in the ``solver/`` folder. The filename will be ``simulation_1_26.csv`` where the first number corresponds to the reaciton system, and the second number corresponds to the total number of species at the point of the simulation. Therefore, the highest second number will indicate the latest simulation that RMG has complete while enlarging the core model. The information inside the csv file will provide the time, reactor volume in m^3, as well as mole fractions of the individual species. -Setting ``verboseComments`` to ``True`` will make RMG generate chemkin files with complete verbose commentary for the kinetic and thermo parameters. This will be helpful in debugging what values are being averaged for the kinetics. Note that this may produce very large files. +Setting ``verboseComments`` to ``True`` will make RMG generate chemkin files with complete verbose commentary for the kinetic and thermo parameters. This will be helpful in debugging what values are being averaged for the kinetics. Note that this may produce very large files. This is a global fallback; individual writers can override it (see below). -Setting ``saveEdgeSpecies`` to ``True`` will make RMG generate chemkin files of the edge reactions in addition to the core model in files such as ``chem_edge.inp`` and ``chem_edge_annotated.inp`` files located inside the ``chemkin`` folder. These files will be helpful in viewing RMG's estimate for edge reactions and seeing if certain reactions one expects are actually in the edge or not. +Setting ``saveEdgeSpecies`` to ``True`` will make RMG generate chemkin files of the edge reactions in addition to the core model in files such as ``chem_edge.inp`` and ``chem_edge_annotated.inp`` files located inside the ``chemkin`` folder. These files will be helpful in viewing RMG's estimate for edge reactions and seeing if certain reactions one expects are actually in the edge or not. This is a global fallback; individual writers can override it (see below). Setting ``keepIrreversible`` to ``True`` will make RMG import library reactions as is, whether they are reversible or irreversible in the library. Otherwise, if ``False`` (default value), RMG will force all library reactions to be reversible, and will assign the forward rate from the relevant library. @@ -1109,6 +1115,76 @@ Setting ``trimolecularProductReversible`` to ``False`` will not allow families w Setting ``saveSeedModulus`` to ``-1`` will only save the seed from the last iteration at the end of an RMG job. Alternatively, the seed can be saved every ``n`` iterations by setting ``saveSeedModulus`` to ``n``. +Per-writer Output Configuration +-------------------------------- + +Each of the following options controls a separate output-format writer. +Each accepts ``True``, ``False``, or a Python dict with optional keys: + +* ``'saveInterval'`` *(int)* — positive N writes every N iterations (iteration + numbering starts at 0); ``-1`` writes only at the very end of the run. + Defaults to ``1`` (every iteration) for writers that are on by default. +* ``'verboseComments'`` *(bool, optional)* — overrides the global + ``verboseComments`` flag for this writer only. +* ``'saveEdge'`` *(bool, optional)* — overrides the global ``saveEdgeSpecies`` + flag for this writer only. + +Examples:: + + # Chemkin: save only at the end, with verbose comments and edge species + generateChemkin={'saveInterval': -1, 'verboseComments': True, 'saveEdge': True} + + # RMS YAML: save every 5 iterations + generateRMSYAML={'saveInterval': 5} + + # Cantera YAML v2: save every iteration with verbose comments + generateCanteraYAML2={'saveInterval': 1, 'verboseComments': True, 'saveEdge': False} + +``generateChemkin`` (default ``True``) + Controls the Chemkin writer. Output is written to the ``chemkin/`` folder. + When enabled, Cantera's ``ck2yaml`` converter is also run at the end of the + job to produce a ``cantera_from_ck/`` folder — see :ref:`output`. + +``generateRMSYAML`` (default ``True``) + Controls the RMS YAML writer. Output is written to the ``rms/`` folder. + +``generateCanteraYAML1`` (default ``False``) *(beta)* + Controls the *direct* Cantera YAML v1 writer. Output is written to the + ``cantera1/`` folder. Unlike the ``cantera_from_ck`` route (which converts + a Chemkin file via ``ck2yaml``), this writer constructs the YAML directly + from RMG's internal Python objects without going through Chemkin at all. + It runs at every iteration (or on the configured schedule) so you get a + history of the growing mechanism. + + .. warning:: + + This writer is in **beta**. The output should be valid Cantera YAML, but + it has been less extensively tested than the established + ``cantera_from_ck`` route. If both this writer and the Chemkin writer + are enabled, a ``comparison_report.txt`` is generated at the end of the + run comparing the two outputs numerically. Please report discrepancies + on the `RMG-Py issue tracker + `_. + +``generateCanteraYAML2`` (default ``False``) *(beta)* + Controls the *direct* Cantera YAML v2 writer. Output is written to the + ``cantera2/`` folder. Like ``generateCanteraYAML1``, this writer bypasses + the Chemkin intermediate, but instead uses the Cantera Python API + (``ct.Solution``) to construct and serialise the mechanism. It also runs + at every iteration (or on the configured schedule). + + .. warning:: + + This writer is in **beta**. It has been less extensively tested than the + established ``cantera_from_ck`` route. When enabled alongside the Chemkin + writer, a ``comparison_report.txt`` is generated at the end of the run. + Please report discrepancies on the `RMG-Py issue tracker + `_. + +``generateOutputHTML`` (default ``False``) + Controls the HTML species-visualisation writer. Output is written to the + ``species/`` folder. Accepts ``True``/``False`` or the same dict format. + Species Constraints ===================== diff --git a/documentation/source/users/rmg/output.rst b/documentation/source/users/rmg/output.rst index 57b6d818ee7..632a7fca75c 100755 --- a/documentation/source/users/rmg/output.rst +++ b/documentation/source/users/rmg/output.rst @@ -4,13 +4,17 @@ Analyzing the Output Files ************************** -You will see that a sucessfully executed RMG job will create multiple output files and folders: +You will see that a sucessfully executed RMG job will create multiple output files and folders: ``output.html`` (if ``generateOutputHTML=True`` is specified) +``/cantera_from_ck`` +``/cantera1`` (if ``generateCanteraYAML1=True`` is specified) +``/cantera2`` (if ``generateCanteraYAML2=True`` is specified) ``/chemkin`` -``/pdep`` +``/pdep`` ``/plot`` +``/rms`` ``/solver`` -``/species`` +``/species`` ``RMG.log`` ------------------ @@ -39,6 +43,92 @@ network. ------------------ The Solver Folder ------------------- -RMG currently includes a solver for isothermal batch reactors. This is in fact a critical part of the model enlargement algorithm. If you have included simulations in your input file, the solutions will be located in ``/solver``. You will probably only be interested in the files with the largest number tags. +------------------ +RMG currently includes a solver for isothermal batch reactors. This is in fact a critical part of the model enlargement algorithm. If you have included simulations in your input file, the solutions will be located in ``/solver``. You will probably only be interested in the files with the largest number tags. Please note that up to and including RMG-Py version 2.3.0 these files showed mole fraction of each species at each step, but they now show amount (number of moles) of each species; you must divide by the sum if you wish to get a mole fraction. + +------------------------------ +Cantera Output Folders +------------------------------ + +RMG can write mechanisms in `Cantera `_ YAML format via three distinct +routes, producing up to three output folders. All three require Cantera to be installed in +the conda environment (it is included in the standard ``rmg_env``). + +``/cantera_from_ck`` +^^^^^^^^^^^^^^^^^^^^ + +This folder is always produced when the Chemkin writer is enabled (``generateChemkin=True``, the default). +After the final RMG iteration, Cantera's own ``ck2yaml`` converter is used to translate the Chemkin-format files in ``/chemkin`` into Cantera YAML. +This is the most thoroughly tested route and is the recommended output for production use. + +``/cantera1`` *(beta)* +^^^^^^^^^^^^^^^^^^^^^^ + +.. note:: + + The ``cantera1`` writer is in **beta**. It uses the Cantera Python API to construct and + serialise the mechanism YAML, rather than writing the YAML by hand. It has been less + extensively tested than the ``cantera_from_ck`` route. Please report any discrepancies. + +This folder is created when ``generateCanteraYAML1=True`` is set in the ``options()`` block +(disabled by default). The writer runs after every RMG iteration (or on the schedule set by +``saveInterval``), so the folder accumulates a history of the growing mechanism. + +Files generated: + +* ``chem{NNNN}.yaml`` — mechanism snapshot at the iteration when the core contained *NNNN* + species (e.g. ``chem0042.yaml``) +* ``chem.yaml`` — copy of the latest snapshot; always reflects the current model state +* ``chem_annotated.yaml`` — annotated version with SMILES, source, and kinetics comments + (written when ``verboseComments=True`` for this writer) +* ``chem_edge{NNNN}.yaml`` / ``chem_edge.yaml`` / ``chem_edge_annotated.yaml`` — edge-model + equivalents (written when ``saveEdge=True``) +* ``comparison_report.txt`` — numerical comparison of ``chem.yaml`` against the + ``cantera_from_ck`` translation (written at the end of the run if both writers are enabled; + see below) + +``/cantera2`` *(beta)* +^^^^^^^^^^^^^^^^^^^^^^ + +.. note:: + + The ``cantera2`` writer is in **beta**. It generates Cantera YAML directly from RMG's + internal Python data structures, without going through the Chemkin intermediate. While + it should produce valid mechanisms, it has been less extensively tested than the + ``cantera_from_ck`` route. Please report any discrepancies. + +This folder is created when ``generateCanteraYAML2=True`` is set in the ``options()`` block +(disabled by default). Like ``cantera1``, it runs at every iteration (or on the configured +schedule). + +Files generated: + +* ``chem{NNNN}.yaml`` / ``chem.yaml`` — latest mechanism snapshot and its labelled history +* ``chem_annotated.yaml`` — annotated version (written when ``verboseComments=True``) +* ``chem_edge{NNNN}.yaml`` / ``chem_edge.yaml`` / ``chem_edge_annotated.yaml`` — edge-model + equivalents (written when ``saveEdge=True``) +* ``comparison_report.txt`` — numerical comparison against the ``cantera_from_ck`` + translation (written at the end of the run if both writers are enabled) + +Comparison Reports +^^^^^^^^^^^^^^^^^^ + +When a direct-writer folder (``cantera1`` or ``cantera2``) is used alongside the Chemkin +writer, RMG automatically compares the final ``chem.yaml`` from that folder against the +``cantera_from_ck/chem.yaml`` produced by ``ck2yaml``. The comparison checks differences +in the yaml data. Not all differences are necessarily problematic. Results are written to +``comparison_report.txt`` inside the relevant direct-writer folder. + +If you find that the two routes disagree in a problematic way, please open an issue on the +`RMG-Py GitHub repository `_ +and include the ``comparison_report.txt`` and a minimal reproducing ``input.py``. + +------------------------------ +The RMS YAML Folder +------------------------------ + +The ``/rms`` folder contains the mechanism in +`ReactionMechanismSimulator (RMS) `_ +YAML format. This writer is enabled by default (``generateRMSYAML=True``) and writes at +every iteration, unless configured otherwise by ``saveInterval``. diff --git a/documentation/source/users/rmg/running.rst b/documentation/source/users/rmg/running.rst index 0755c6199e7..43425fe38b4 100755 --- a/documentation/source/users/rmg/running.rst +++ b/documentation/source/users/rmg/running.rst @@ -48,9 +48,9 @@ at the command line will print the documentation from ``util.py``, which is repr -P, --postprocess postprocess profiling statistics from previous [failed] run; does not run the simulation -t DD:HH:MM:SS, --walltime DD:HH:MM:SS - set the maximum execution time + set the maximum execution time (overrides input.py if provided) -i MAXITER, --maxiter MAXITER - set the maximum number of RMG iterations + set the maximum number of RMG iterations (overrides input.py if provided) -n MAXPROC, --maxproc MAXPROC max number of processes used during reaction generation @@ -73,7 +73,7 @@ Run with multiprocessing for reaction generation and QMTP:: python rmg.py -n input.py -Run with setting a limit on the maximum execution time:: +Run with setting a limit on the maximum execution time (if specified, then the command-line value overrides any value read from ``input.py``):: python rmg.py -t input.py diff --git a/examples/rmg/1,3-hexadiene/input.py b/examples/rmg/1,3-hexadiene/input.py index f3706af0f7d..3e03b201c66 100644 --- a/examples/rmg/1,3-hexadiene/input.py +++ b/examples/rmg/1,3-hexadiene/input.py @@ -90,4 +90,9 @@ generateOutputHTML=False, generatePlots=False, generatePESDiagrams=True, + # Large model: write output every 5 iterations and skip edge species to reduce I/O + generateChemkin={'saveInterval': 1, 'saveEdge': False}, + generateRMSYAML={'saveInterval': 5}, + generateCanteraYAML1={'saveInterval': 5}, + generateCanteraYAML2={'saveInterval': 5}, ) diff --git a/examples/rmg/MR_test/input.py b/examples/rmg/MR_test/input.py index 956c7258379..bea097546a1 100644 --- a/examples/rmg/MR_test/input.py +++ b/examples/rmg/MR_test/input.py @@ -260,9 +260,9 @@ #Sets a time limit in the form DD:HH:MM:SS after which the RMG job will stop. Useful for profiling on jobs that #do not converge. #wallTime = '00:00:00', + #When keepIrreversible=False (default), forces RMG to import library reactions as reversible. + #Otherwise, if set to True, RMG will import library reactions while keeping the reversibility as specified. keepIrreversible=False, - #Forces RMG to import library reactions as reversible (default). Otherwise, if set to True, RMG will import library - #reactions while keeping the reversibility as as. ) # optional module allows for correction to unimolecular reaction rates at low pressures and/or temperatures. diff --git a/examples/rmg/ch3no2/input.py b/examples/rmg/ch3no2/input.py index 1e1de348eab..5cebce3dbdc 100644 --- a/examples/rmg/ch3no2/input.py +++ b/examples/rmg/ch3no2/input.py @@ -80,8 +80,13 @@ ) simulator(atol=1e-16,rtol=1e-8) + options( units='si', generateOutputHTML=False, generatePlots=False, + # Large model: write output every 5 iterations to reduce I/O + generateChemkin={'saveInterval': 5, 'saveEdge': False}, + generateRMSYAML={'saveInterval': 5}, + generateCanteraYAML2={'saveInterval': 10, 'saveEdge': True}, ) diff --git a/examples/rmg/commented/input.py b/examples/rmg/commented/input.py index 2c74b3700be..95c2c8eecc2 100644 --- a/examples/rmg/commented/input.py +++ b/examples/rmg/commented/input.py @@ -221,23 +221,47 @@ generatePESDiagrams=False, # saves mole fraction of species in 'solver/' to help you create plots saveSimulationProfiles=False, - # gets RMG to output comments on where kinetics were obtained in the chemkin file. - # useful for debugging kinetics but increases memory usage of the chemkin output file + # Global fallback for verbose comments (comments on where kinetics were obtained). + # Useful for debugging kinetics but increases output file size. + # Individual writers can override this with their own verboseComments key. verboseComments=False, - # gets RMG to generate edge species chemkin files. Uses lots of memory in output. - # Helpful for seeing why some reaction are not appearing in core model. + # Global fallback for saving edge-species files. Uses lots of memory in output. + # Helpful for seeing why some reactions are not appearing in the core model. + # Individual writers can override this with their own saveEdge key. saveEdgeSpecies=False, - # Sets a time limit in the form DD:HH:MM:SS after which the RMG job will stop. Useful for profiling on jobs that - # do not converge. - # wallTime = '00:00:00', - # Forces RMG to import library reactions as reversible (default). Otherwise, if set to True, RMG will import library - # reactions while keeping the reversibility as as. + # Sets a time limit in the form DD:HH:MM:SS after (or shortly before) which the RMG job will stop. + # Useful for profiling on jobs that do not converge. + wallTime = '00:00:00:00', + # If keepIrreversible=False (default) forces RMG to import library reactions as reversible. + # If set to True, RMG will import library reactions while keeping the reversibility as specified. keepIrreversible=False, # Allows families with three products to react in the diverse direction (default). trimolecularProductReversible=True, # Allows a seed to be saved every n iterations. # The default of -1 causes the iteration to only be saved at the end of the RMG job - saveSeedModulus=-1 + saveSeedModulus=-1, + # + # --- Per-writer output configuration --- + # Each writer accepts True/False or a dict with keys: + # 'saveInterval': N (positive = every N iterations; -1 = end of run only) + # 'verboseComments': True/False (overrides the global verboseComments above) + # 'saveEdge': True/False (overrides the global saveEdgeSpecies above) + # + # Chemkin writer: always on by default; saves every iteration. + generateChemkin=True, + # generateChemkin={'saveInterval': -1, 'verboseComments': True, 'saveEdge': True}, + # + # RMS YAML writer: always on by default; saves every iteration. + generateRMSYAML=True, + # generateRMSYAML={'saveInterval': -1}, + # + # Cantera YAML v1 writer: off by default. + generateCanteraYAML1=False, + # generateCanteraYAML1={'saveInterval': -1, 'verboseComments': True, 'saveEdge': False}, + # + # Cantera YAML v2 writer: off by default. + generateCanteraYAML2=False, + # generateCanteraYAML2={'saveInterval': 1, 'verboseComments': True, 'saveEdge': True}, ) # optional module allows for correction to unimolecular reaction rates at low pressures and/or temperatures. diff --git a/examples/rmg/diesel/input.py b/examples/rmg/diesel/input.py index 0492c2b8db2..4fae7410917 100644 --- a/examples/rmg/diesel/input.py +++ b/examples/rmg/diesel/input.py @@ -86,4 +86,9 @@ units='si', generateOutputHTML=False, generatePlots=False, + # Large model: write output every 5 iterations and skip edge species to reduce I/O + generateChemkin={'saveInterval': 5, 'saveEdge': False}, + generateRMSYAML={'saveInterval': 5}, + generateCanteraYAML1={'saveInterval': 10}, + generateCanteraYAML2={'saveInterval': 10}, ) diff --git a/examples/rmg/e85/input.py b/examples/rmg/e85/input.py index 66529b9280c..2b895c27374 100644 --- a/examples/rmg/e85/input.py +++ b/examples/rmg/e85/input.py @@ -87,5 +87,9 @@ units='si', generateOutputHTML=False, generatePlots=False, + generateChemkin={'saveInterval': 5, 'saveEdge': True}, + generateRMSYAML={'saveInterval': 5}, + generateCanteraYAML1={'saveInterval': 5}, + generateCanteraYAML2={'saveInterval': 5}, ) diff --git a/examples/rmg/heptane-eg5/input.py b/examples/rmg/heptane-eg5/input.py index ee19001b306..b3d9b50e775 100644 --- a/examples/rmg/heptane-eg5/input.py +++ b/examples/rmg/heptane-eg5/input.py @@ -3,7 +3,7 @@ thermoLibraries = ['primaryThermoLibrary'], reactionLibraries = [], seedMechanisms = [], - kineticsDepositories = ['training'], + kineticsDepositories = ['training'], kineticsFamilies = 'default', kineticsEstimator = 'rate rules', ) @@ -71,4 +71,12 @@ interpolation=('Chebyshev', 6, 4), ) - +options( + units='si', + generateOutputHTML={'saveInterval': 10, 'saveEdge': True}, + generatePlots=False, + generateChemkin={'saveInterval': 1, 'saveEdge': False}, + generateRMSYAML={'saveInterval': 5}, + generateCanteraYAML1={'saveInterval': 5, 'saveEdge': True}, + generateCanteraYAML2={'saveInterval': 10, 'saveEdge': True}, +) diff --git a/rmgpy/__main__.py b/rmgpy/__main__.py index 6127d761f80..5e85b6c99bf 100644 --- a/rmgpy/__main__.py +++ b/rmgpy/__main__.py @@ -62,11 +62,13 @@ def main(): kwargs = { 'restart': args.restart, - 'walltime': args.walltime, 'maxproc': args.maxproc, 'kineticsdatastore': args.kineticsdatastore, - 'max_iterations': args.maxiter, } + if args.walltime is not None: + kwargs['walltime'] = args.walltime + if args.maxiter is not None: + kwargs['max_iterations'] = args.maxiter if args.profile: import cProfile diff --git a/rmgpy/chemkin.pyx b/rmgpy/chemkin.pyx index 3699be19bb7..9aac0dcabf3 100644 --- a/rmgpy/chemkin.pyx +++ b/rmgpy/chemkin.pyx @@ -2277,10 +2277,12 @@ def save_chemkin(reaction_model, path, verbose_path, dictionary_path=None, trans save_transport_file(transport_path, species_list) -def save_chemkin_files(rmg): +def save_chemkin_files(rmg, config=None): """ Save the current reaction model to a set of Chemkin files. """ + verbose = config.verbose_comments if (config and config.verbose_comments is not None) else rmg.verbose_comments + save_edge = config.save_edge if (config and config.save_edge is not None) else rmg.save_edge_species # todo: make this an attribute or method of reactionModel is_surface_model = any([s.contains_surface_site() for s in rmg.reaction_model.core.species]) @@ -2315,7 +2317,7 @@ def save_chemkin_files(rmg): os.unlink(latest_chemkin_path) shutil.copy2(this_chemkin_path, latest_chemkin_path) - if rmg.save_edge_species: + if save_edge: logging.info('Saving current model core and edge to Chemkin file...') this_chemkin_path = os.path.join(rmg.output_directory, 'chemkin', 'chem_edge{0:04d}.inp'.format(len(rmg.reaction_model.core.species))) @@ -2324,7 +2326,7 @@ def save_chemkin_files(rmg): latest_dictionary_path = os.path.join(rmg.output_directory, 'chemkin', 'species_edge_dictionary.txt') latest_transport_path = None save_chemkin(rmg.reaction_model, this_chemkin_path, latest_chemkin_verbose_path, latest_dictionary_path, - latest_transport_path, rmg.save_edge_species) + latest_transport_path, save_edge) if is_surface_model: paths = [] @@ -2391,9 +2393,13 @@ class ChemkinWriter(object): rmg.detach(listener) """ - def __init__(self, output_directory=''): + def __init__(self, output_directory='', config=None): super(ChemkinWriter, self).__init__() + self.config = config make_output_subdirectory(output_directory, 'chemkin') def update(self, rmg): - save_chemkin_files(rmg) + if self.config is not None and not self.config.should_write( + rmg.reaction_model.iteration_num, rmg.is_final_save): + return + save_chemkin_files(rmg, config=self.config) diff --git a/rmgpy/kinetics/arrhenius.pyx b/rmgpy/kinetics/arrhenius.pyx index 6252b6ce950..69a49bde303 100644 --- a/rmgpy/kinetics/arrhenius.pyx +++ b/rmgpy/kinetics/arrhenius.pyx @@ -946,17 +946,24 @@ cdef class PDepArrhenius(PDepKineticsModel): def set_cantera_kinetics(self, ct_reaction, species_list): """ Sets a Cantera PlogReaction()'s `rates` attribute with - A list of tuples containing [(pressure in Pa, cantera arrhenius object), (..)] + a list of tuples containing [(pressure in Pa, cantera arrhenius object), ...]. + + A ``MultiArrhenius`` entry (from chemkin PLOG blocks with duplicate + pressures) is expanded into one tuple per inner Arrhenius; Cantera's + PlogRate sums duplicate-pressure entries at evaluation. """ import cantera as ct - import copy assert isinstance(ct_reaction.rate, ct.PlogRate), "Must have a Cantera PlogRate attribute" - pressures = copy.deepcopy(self._pressures.value_si) - ctArrhenius = [arr.to_cantera_kinetics(arrhenius_class=True) for arr in self.arrhenius] + rate_pairs = [] + for P, arr in zip(self._pressures.value_si, self.arrhenius): + if isinstance(arr, MultiArrhenius): + for sub in arr.arrhenius: + rate_pairs.append((P, sub.to_cantera_kinetics(arrhenius_class=True))) + else: + rate_pairs.append((P, arr.to_cantera_kinetics(arrhenius_class=True))) - new_rates = ct.PlogRate(list(zip(pressures, ctArrhenius))) - ct_reaction.rate = new_rates + ct_reaction.rate = ct.PlogRate(rate_pairs) ################################################################################ diff --git a/rmgpy/reaction.py b/rmgpy/reaction.py index 477e29cc965..63e1d278f1d 100644 --- a/rmgpy/reaction.py +++ b/rmgpy/reaction.py @@ -425,6 +425,19 @@ def to_cantera(self, species_list=None, use_chemkin_identifier=False): # Now we set the kinetics. self.kinetics.set_cantera_kinetics(ct_reaction, species_list) + # Coverage dependencies are not handled by set_cantera_kinetics; set them here. + # Cantera's coverage_dependencies E is in J/kmol; RMG's value_si is J/mol. + if hasattr(self.kinetics, 'coverage_dependence') and self.kinetics.coverage_dependence: + cov_deps = {} + for sp, params in self.kinetics.coverage_dependence.items(): + sp_label = sp.to_chemkin() if use_chemkin_identifier else sp.label + cov_deps[sp_label] = { + 'a': params['a'].value_si, + 'm': params['m'].value_si, + 'E': params['E'].value_si * 1000, # J/mol → J/kmol + } + ct_reaction.rate.coverage_dependencies = cov_deps + return ct_reaction def get_url(self): diff --git a/rmgpy/rmg/input.py b/rmgpy/rmg/input.py index 887c0f9eab8..97399c0dd03 100644 --- a/rmgpy/rmg/input.py +++ b/rmgpy/rmg/input.py @@ -53,7 +53,7 @@ ConstantVIdealGasReactor, Reactor, ) -from rmgpy.rmg.settings import ModelSettings, SimulatorSettings +from rmgpy.rmg.settings import ModelSettings, SimulatorSettings, WriterConfig from rmgpy.solver.liquid import LiquidReactor from rmgpy.solver.mbSampled import MBSampledReactor from rmgpy.solver.simple import SimpleReactor @@ -1418,10 +1418,65 @@ def pressure_dependence( rmg.reaction_model.add_completed_pdep_network(formula) +def _parse_writer_config(value, default_save_interval=1): + """ + Parse an output-writer configuration value from an input file. + + Parameters + ---------- + value : bool or dict + ``False`` disables the writer. ``True`` enables it with + *default_save_interval*. A dict may contain the keys + ``'saveInterval'`` (int), ``'verboseComments'`` (bool), and + ``'saveEdge'`` (bool). + default_save_interval : int + Save interval to use when ``value`` is ``True``. + + Returns + ------- + WriterConfig + """ + if value is False: + return WriterConfig(save_interval=0) + if value is True: + return WriterConfig(save_interval=default_save_interval) + if isinstance(value, dict): + si = value.get('saveInterval', default_save_interval) + return WriterConfig( + save_interval=si, + verbose_comments=value.get('verboseComments', None), + save_edge=value.get('saveEdge', None), + ) + raise InputError( + f"Writer config must be True, False, or a dict with keys " + f"'saveInterval', 'verboseComments', 'saveEdge'; got {type(value).__name__!r}" + ) + + +def _writer_config_to_input(cfg): + """ + Serialize a WriterConfig back to a value suitable for writing into an + RMG input file (i.e. ``True``, ``False``, or a dict literal string). + """ + if cfg is None or not cfg.enabled: + return False + has_overrides = (cfg.verbose_comments is not None or cfg.save_edge is not None) + if cfg.save_interval == 1 and not has_overrides: + return True + parts = [f"'saveInterval': {cfg.save_interval}"] + if cfg.verbose_comments is not None: + parts.append(f"'verboseComments': {cfg.verbose_comments}") + if cfg.save_edge is not None: + parts.append(f"'saveEdge': {cfg.save_edge}") + return '{' + ', '.join(parts) + '}' + + def options(name='Seed', generateSeedEachIteration=True, saveSeedToDatabase=False, units='si', saveRestartPeriod=None, - generateOutputHTML=False, generatePlots=False, generatePESDiagrams=False, saveSimulationProfiles=False, verboseComments=False, - saveEdgeSpecies=False, keepIrreversible=False, trimolecularProductReversible=True, wallTime='00:00:00:00', - saveSeedModulus=-1): + generateOutputHTML=False, generatePlots=False, generatePESDiagrams=False, saveSimulationProfiles=False, + verboseComments=False, saveEdgeSpecies=False, keepIrreversible=False, + trimolecularProductReversible=True, wallTime='00:00:00:00', saveSeedModulus=-1, + generateChemkin=True, generateRMSYAML=True, + generateCanteraYAML1=False, generateCanteraYAML2=False): if saveRestartPeriod: logging.warning("`saveRestartPeriod` flag was set in the input file, but this feature has been removed. Please " "remove this line from the input file. This will throw an error after RMG-Py 3.1. For " @@ -1434,7 +1489,7 @@ def options(name='Seed', generateSeedEachIteration=True, saveSeedToDatabase=Fals rmg.units = units if generateOutputHTML: logging.warning('Generate Output HTML option was turned on. Note that this will slow down model generation.') - rmg.generate_output_html = generateOutputHTML + rmg.generate_output_html = bool(generateOutputHTML) rmg.generate_plots = generatePlots rmg.generate_PES_diagrams = generatePESDiagrams if generatePESDiagrams: @@ -1450,6 +1505,12 @@ def options(name='Seed', generateSeedEachIteration=True, saveSeedToDatabase=Fals rmg.walltime = wallTime rmg.save_seed_modulus = saveSeedModulus + rmg.chemkin_writer_config = _parse_writer_config(generateChemkin) + rmg.rms_writer_config = _parse_writer_config(generateRMSYAML) + rmg.cantera1_writer_config = _parse_writer_config(generateCanteraYAML1) + rmg.cantera2_writer_config = _parse_writer_config(generateCanteraYAML2) + rmg.html_writer_config = _parse_writer_config(generateOutputHTML) + def generated_species_constraints(**kwargs): valid_constraints = [ @@ -1937,7 +1998,7 @@ def formula(elements): # Options f.write('options(\n') f.write(' units = "{0}",\n'.format(rmg.units)) - f.write(' generateOutputHTML = {0},\n'.format(rmg.generate_output_html)) + f.write(' generateOutputHTML = {0},\n'.format(_writer_config_to_input(rmg.html_writer_config))) f.write(' generatePlots = {0},\n'.format(rmg.generate_plots)) f.write(' generatePESDiagrams = {0},\n'.format(rmg.generate_PES_diagrams)) f.write(' saveSimulationProfiles = {0},\n'.format(rmg.save_simulation_profiles)) @@ -1946,6 +2007,12 @@ def formula(elements): f.write(' trimolecularProductReversible = {0},\n'.format(rmg.trimolecular_product_reversible)) f.write(' verboseComments = {0},\n'.format(rmg.verbose_comments)) f.write(' wallTime = {0},\n'.format(rmg.walltime)) + f.write(' generateChemkin = {0},\n'.format(_writer_config_to_input(rmg.chemkin_writer_config))) + f.write(' generateRMSYAML = {0},\n'.format(_writer_config_to_input(rmg.rms_writer_config))) + if rmg.cantera1_writer_config and rmg.cantera1_writer_config.enabled: + f.write(' generateCanteraYAML1 = {0},\n'.format(_writer_config_to_input(rmg.cantera1_writer_config))) + if rmg.cantera2_writer_config and rmg.cantera2_writer_config.enabled: + f.write(' generateCanteraYAML2 = {0},\n'.format(_writer_config_to_input(rmg.cantera2_writer_config))) f.write(')\n\n') f.close() diff --git a/rmgpy/rmg/main.py b/rmgpy/rmg/main.py index a5854c26cca..6ccb7a7a292 100644 --- a/rmgpy/rmg/main.py +++ b/rmgpy/rmg/main.py @@ -76,13 +76,16 @@ from rmgpy.rmg.output import OutputHTMLWriter from rmgpy.rmg.pdep import PDepNetwork from rmgpy.rmg.reactionmechanismsimulator_reactors import Reactor as RMSReactor -from rmgpy.rmg.settings import ModelSettings +from rmgpy.rmg.settings import ModelSettings, WriterConfig from rmgpy.solver.base import TerminationTime from rmgpy.stats import ExecutionStatsWriter from rmgpy.thermo.thermoengine import submit from rmgpy.tools.plot import plot_sensitivity +from rmgpy.tools.compare_cantera_yaml import compare_yaml_files, compare_yaml_files_and_report from rmgpy.tools.uncertainty import Uncertainty, process_local_results -from rmgpy.yml import RMSWriter +from rmgpy.yaml_rms import RMSWriter +from rmgpy.yaml_cantera1 import CanteraWriter1 +from rmgpy.yaml_cantera2 import CanteraWriter2 ################################################################################ @@ -143,8 +146,14 @@ class RMG(util.Subject): `generate_output_html` ``True`` to draw pictures of the species and reactions, saving a visualized model in an output HTML file. ``False`` otherwise `generate_plots` ``True`` to generate plots of the job execution statistics after each iteration, ``False`` otherwise `generate_PES_diagrams` ``True`` to generate potential energy surface diagrams for pressure dependent networks in the model, ``False`` otherwise - `verbose_comments` ``True`` to keep the verbose comments for database estimates, ``False`` otherwise - `save_edge_species` ``True`` to save chemkin and HTML files of the edge species, ``False`` otherwise + `verbose_comments` ``True`` to keep the verbose comments for database estimates, ``False`` otherwise (global fallback when writer config does not override) + `save_edge_species` ``True`` to save chemkin and HTML files of the edge species, ``False`` otherwise (global fallback when writer config does not override) + `chemkin_writer_config` :class:`WriterConfig` controlling when the Chemkin writer runs and its per-writer options + `rms_writer_config` :class:`WriterConfig` controlling when the RMS YAML writer runs and its per-writer options + `cantera1_writer_config` :class:`WriterConfig` controlling when CanteraWriter1 runs and its per-writer options + `cantera2_writer_config` :class:`WriterConfig` controlling when CanteraWriter2 runs and its per-writer options + `html_writer_config` :class:`WriterConfig` controlling when the HTML writer runs and its per-writer options + `is_final_save` Set to ``True`` immediately before the end-of-run ``save_everything()`` call so writers know it is the final notification `keep_irreversible` ``True`` to keep ireversibility of library reactions as is ('<=>' or '=>'). ``False`` (default) to force all library reactions to be reversible ('<=>') `trimolecular_product_reversible` ``True`` (default) to allow families with trimolecular products to react in the reverse direction, ``False`` otherwise `pressure_dependence` Whether to process unimolecular (pressure-dependent) reaction networks @@ -228,6 +237,12 @@ def clear(self): self.save_simulation_profiles = None self.verbose_comments = None self.save_edge_species = None + self.chemkin_writer_config = None + self.rms_writer_config = None + self.cantera1_writer_config = None + self.cantera2_writer_config = None + self.html_writer_config = None + self.is_final_save = False self.keep_irreversible = None self.trimolecular_product_reversible = None self.pressure_dependence = None @@ -256,6 +271,19 @@ def clear(self): self.exec_time = [] self.liquid_volumetric_mass_transfer_coefficient_power_law = None + @staticmethod + def _parse_walltime_to_seconds(walltime): + """ + Convert walltime string DD:HH:MM:SS to seconds. + """ + data = walltime.split(":") + if len(data) != 4: + raise ValueError("Invalid format for wall time {0}; should be DD:HH:MM:SS.".format(walltime)) + try: + return int(data[-1]) + 60 * int(data[-2]) + 3600 * int(data[-3]) + 86400 * int(data[-4]) + except ValueError as exc: + raise ValueError("Invalid format for wall time {0}; should be DD:HH:MM:SS.".format(walltime)) from exc + def load_input(self, path=None): """ Load an RMG job from the input file located at `input_file`, or @@ -567,6 +595,24 @@ def initialize(self, **kwargs): ) ) + if "walltime" in kwargs: + logging.info( + "Overriding walltime from input file (%s) with command-line value (%s).", + self.walltime, + kwargs["walltime"], + ) + self.walltime = kwargs["walltime"] + + if "max_iterations" in kwargs: + logging.info( + "Overriding max_iterations from input file (%s) with command-line value (%s).", + self.max_iterations, + kwargs["max_iterations"], + ) + self.max_iterations = kwargs["max_iterations"] + + self.walltime = self._parse_walltime_to_seconds(self.walltime) + # Auto-select libraries if any field uses 'auto' or '' auto_select_libraries(self) @@ -644,21 +690,6 @@ def initialize(self, **kwargs): if reaction_system.T: reaction_system.viscosity = solvent_data.get_solvent_viscosity(reaction_system.T.value_si) - try: - self.walltime = kwargs["walltime"] - except KeyError: - pass - - try: - self.max_iterations = kwargs["max_iterations"] - except KeyError: - pass - - data = self.walltime.split(":") - if not len(data) == 4: - raise ValueError("Invalid format for wall time {0}; should be DD:HH:MM:SS.".format(self.walltime)) - self.walltime = int(data[-1]) + 60 * int(data[-2]) + 3600 * int(data[-3]) + 86400 * int(data[-4]) - # Initialize reaction model for spec in self.initial_species: @@ -781,12 +812,22 @@ def register_listeners(self, requires_rms=False): found in the RMG input file. """ - self.attach(ChemkinWriter(self.output_directory)) - - self.attach(RMSWriter(self.output_directory)) - - if self.generate_output_html: - self.attach(OutputHTMLWriter(self.output_directory)) + cfg_chemkin = self.chemkin_writer_config or WriterConfig(save_interval=1) + cfg_rms = self.rms_writer_config or WriterConfig(save_interval=1) + cfg_cantera1 = self.cantera1_writer_config or WriterConfig(save_interval=0) + cfg_cantera2 = self.cantera2_writer_config or WriterConfig(save_interval=0) + cfg_html = self.html_writer_config or WriterConfig(save_interval=0) + + if cfg_chemkin.enabled: + self.attach(ChemkinWriter(self.output_directory, cfg_chemkin)) + if cfg_rms.enabled: + self.attach(RMSWriter(self.output_directory, cfg_rms)) + if cfg_cantera1.enabled: + self.attach(CanteraWriter1(self.output_directory, cfg_cantera1)) + if cfg_cantera2.enabled: + self.attach(CanteraWriter2(self.output_directory, cfg_cantera2)) + if cfg_html.enabled: + self.attach(OutputHTMLWriter(self.output_directory, cfg_html)) if self.quantum_mechanics: self.attach(QMDatabaseWriter()) @@ -906,6 +947,7 @@ def execute(self, initialize=True, **kwargs): self.make_seed_mech() max_num_spcs_hit = False # default + end_early = False for q, model_settings in enumerate(self.model_settings_list): if len(self.simulator_settings_list) > 1: @@ -915,7 +957,7 @@ def execute(self, initialize=True, **kwargs): self.filter_reactions = model_settings.filter_reactions - logging.info("Beginning model generation stage {0}...\n".format(q + 1)) + logging.info(f"Beginning model generation stage {q + 1} of {len(self.model_settings_list)}.\n") self.done = False @@ -1210,7 +1252,8 @@ def execute(self, initialize=True, **kwargs): core_spec, core_reac, edge_spec, edge_reac = self.reaction_model.get_model_size() logging.info("The current model core has %s species and %s reactions" % (core_spec, core_reac)) logging.info("The current model edge has %s species and %s reactions" % (edge_spec, edge_reac)) - return + end_early = True + break if self.max_iterations and (self.reaction_model.iteration_num >= self.max_iterations): logging.info("MODEL GENERATION TERMINATED") @@ -1221,60 +1264,94 @@ def execute(self, initialize=True, **kwargs): core_spec, core_reac, edge_spec, edge_reac = self.reaction_model.get_model_size() logging.info("The current model core has %s species and %s reactions" % (core_spec, core_reac)) logging.info("The current model edge has %s species and %s reactions" % (edge_spec, edge_reac)) - return + end_early = True + break if max_num_spcs_hit: # resets maxNumSpcsHit and continues the settings for loop logging.info("The maximum number of species ({0}) has been hit, Exiting stage {1} ...".format(model_settings.max_num_species, q + 1)) max_num_spcs_hit = False + if end_early: # breaks the settings for loop + break + + self.reaction_model.iteration_num += 1 # Save the final seed mechanism self.make_seed_mech() + # Notify all writers that this is the final save (end-of-run). + # Writers configured with saveInterval=-1 will write only here. + # Writers configured with saveInterval>0 will also write here + # unless they already wrote on this iteration. + self.is_final_save = True + self.save_everything() + self.is_final_save = False + self.run_model_analysis() - # generate Cantera files chem.yaml & chem_annotated.yaml in a designated `cantera` output folder + # generate Cantera files chem.yaml & chem_annotated.yaml in designated Cantera output folders try: - if any([s.contains_surface_site() for s in self.reaction_model.core.species]): - # Surface (catalytic) chemistry - self.generate_cantera_files( - os.path.join(self.output_directory, "chemkin", "chem-gas.inp"), - surface_file=(os.path.join(self.output_directory, "chemkin", "chem-surface.inp")), - ) - self.generate_cantera_files( - os.path.join(self.output_directory, "chemkin", "chem_annotated-gas.inp"), - surface_file=(os.path.join(self.output_directory, "chemkin", "chem_annotated-surface.inp")), - ) + translated_cantera_file = None + if self.chemkin_writer_config and self.chemkin_writer_config.enabled: + logging.info("Translating final chemkin file into Cantera yaml.") + if any([s.contains_surface_site() for s in self.reaction_model.core.species]): + # Surface (catalytic) chemistry + translated_cantera_file = self.generate_cantera_files_from_chemkin( + os.path.join(self.output_directory, "chemkin", "chem-gas.inp"), + surface_file=(os.path.join(self.output_directory, "chemkin", "chem-surface.inp")), + ) + annotated_gas = os.path.join(self.output_directory, "chemkin", "chem_annotated-gas.inp") + if os.path.exists(annotated_gas): + self.generate_cantera_files_from_chemkin( + annotated_gas, + surface_file=(os.path.join(self.output_directory, "chemkin", "chem_annotated-surface.inp")), + ) - if self.thermo_coverage_dependence: - # Build coverage_deps: {species_name: string_to_add_to_yaml} - coverage_deps = {} - for s in self.reaction_model.core.species: - if s.contains_surface_site() and s.thermo.thermo_coverage_dependence: - s_name = s.to_chemkin() - for dep_sp_adj, parameters in s.thermo.thermo_coverage_dependence.items(): - mol = Molecule().from_adjacency_list(dep_sp_adj) - for sp in self.reaction_model.core.species: - if sp.is_isomorphic(mol, strict=False): - if s_name not in coverage_deps: - coverage_deps[s_name] = ' coverage-dependencies:' - coverage_deps[s_name] += f""" + if self.thermo_coverage_dependence: + # Build coverage_deps: {species_name: string_to_add_to_yaml} + coverage_deps = {} + for s in self.reaction_model.core.species: + if s.contains_surface_site() and s.thermo.thermo_coverage_dependence: + s_name = s.to_chemkin() + for dep_sp_adj, parameters in s.thermo.thermo_coverage_dependence.items(): + mol = Molecule().from_adjacency_list(dep_sp_adj) + for sp in self.reaction_model.core.species: + if sp.is_isomorphic(mol, strict=False): + if s_name not in coverage_deps: + coverage_deps[s_name] = ' coverage-dependencies:' + coverage_deps[s_name] += f""" {sp.to_chemkin()}: model: {parameters['model']} enthalpy-coefficients: {[v.value_si for v in parameters['enthalpy-coefficients']]} entropy-coefficients: {[v.value_si for v in parameters['entropy-coefficients']]} units: {{energy: J, quantity: mol}} """ - break - - for yaml_path in [ - os.path.join(self.output_directory, "cantera", "chem.yaml"), - os.path.join(self.output_directory, "cantera", "chem_annotated.yaml"), - ]: - _add_coverage_dependence_to_cantera_yaml(yaml_path, coverage_deps) + break + + for yaml_path in [ + os.path.join(self.output_directory, "cantera_from_ck", "chem.yaml"), + os.path.join(self.output_directory, "cantera_from_ck", "chem_annotated.yaml"), + ]: + if os.path.exists(yaml_path): + _add_coverage_dependence_to_cantera_yaml(yaml_path, coverage_deps) + + else: # gas phase only + translated_cantera_file = self.generate_cantera_files_from_chemkin( + os.path.join(self.output_directory, "chemkin", "chem.inp") + ) + annotated = os.path.join(self.output_directory, "chemkin", "chem_annotated.inp") + if os.path.exists(annotated): + self.generate_cantera_files_from_chemkin(annotated) + + # Compare translated Cantera files against directly generated Cantera files + if translated_cantera_file and self.cantera1_writer_config and self.cantera1_writer_config.enabled: + compare_yaml_files_and_report(translated_cantera_file, + os.path.join(self.output_directory, "cantera1", "chem.yaml"), + output=os.path.join(self.output_directory, "cantera1", "comparison_report.txt")) + if translated_cantera_file and self.cantera2_writer_config and self.cantera2_writer_config.enabled: + compare_yaml_files_and_report(translated_cantera_file, + os.path.join(self.output_directory, "cantera2", "chem.yaml"), + output=os.path.join(self.output_directory, "cantera2", "comparison_report.txt")) - else: # gas phase only - self.generate_cantera_files(os.path.join(self.output_directory, "chemkin", "chem.inp")) - self.generate_cantera_files(os.path.join(self.output_directory, "chemkin", "chem_annotated.inp")) except EnvironmentError: logging.exception("Could not generate Cantera files due to EnvironmentError. Check read\\write privileges in output directory.") except Exception: @@ -1282,12 +1359,14 @@ def execute(self, initialize=True, **kwargs): self.check_model() # Write output file - logging.info("") - logging.info("MODEL GENERATION COMPLETED") - logging.info("") - core_spec, core_reac, edge_spec, edge_reac = self.reaction_model.get_model_size() - logging.info("The final model core has %s species and %s reactions" % (core_spec, core_reac)) - logging.info("The final model edge has %s species and %s reactions" % (edge_spec, edge_reac)) + + if not end_early: + logging.info("") + logging.info("MODEL GENERATION COMPLETED") + logging.info("") + core_spec, core_reac, edge_spec, edge_reac = self.reaction_model.get_model_size() + logging.info("The final model core has %s species and %s reactions" % (core_spec, core_reac)) + logging.info("The final model edge has %s species and %s reactions" % (edge_spec, edge_reac)) self.finish() @@ -1845,14 +1924,15 @@ def process_reactions_to_species(self, obj): raise TypeError("improper call, obj input was incorrect") return potential_spcs - def generate_cantera_files(self, chemkin_file, **kwargs): + def generate_cantera_files_from_chemkin(self, chemkin_file, **kwargs): """ Convert a chemkin mechanism chem.inp file to a cantera mechanism file chem.yaml - and save it in the cantera directory + and save it in the cantera directory. + Returns the path to the generated cantera file. """ transport_file = os.path.join(os.path.dirname(chemkin_file), "tran.dat") file_name = os.path.splitext(os.path.basename(chemkin_file))[0] + ".yaml" - out_name = os.path.join(self.output_directory, "cantera", file_name) + out_name = os.path.join(self.output_directory, "cantera_from_ck", file_name) if "surface_file" in kwargs: out_name = out_name.replace("-gas.", ".") cantera_dir = os.path.dirname(out_name) @@ -1870,6 +1950,7 @@ def generate_cantera_files(self, chemkin_file, **kwargs): logging.exception("Error converting to Cantera format.") logging.info("Trying again without transport data file.") parser.convert_mech(chemkin_file, out_name=out_name, quiet=True, permissive=True, **kwargs) + return out_name def initialize_reaction_threshold_and_react_flags(self): num_core_species = len(self.reaction_model.core.species) @@ -2157,8 +2238,9 @@ def get_git_commit(self, module_path): if os.path.exists(os.path.join(module_path, "..", ".git")): try: - return subprocess.check_output(["git", "log", "--format=%H%n%cd", "-1"], cwd=module_path).splitlines() - except: + head, date = subprocess.check_output(["git", "log", "--format=%H%n%cd", "-1"], cwd=module_path).splitlines() + return head.decode(), date.decode() + except (subprocess.CalledProcessError, OSError): return "", "" else: return "", "" diff --git a/rmgpy/rmg/output.py b/rmgpy/rmg/output.py index 93cc8782bb3..bcd40c0826f 100644 --- a/rmgpy/rmg/output.py +++ b/rmgpy/rmg/output.py @@ -1317,14 +1317,16 @@ def csssafe(input): f.close() -def save_output(rmg): +def save_output(rmg, save_edge=None): """ Save the current reaction model to a pretty HTML file. """ + if save_edge is None: + save_edge = rmg.save_edge_species logging.info('Saving current model core to HTML file...') save_output_html(os.path.join(rmg.output_directory, 'output.html'), rmg.reaction_model, 'core') - if rmg.save_edge_species: + if save_edge: logging.info('Saving current model edge to HTML file...') save_output_html(os.path.join(rmg.output_directory, 'output_edge.html'), rmg.reaction_model, 'edge') @@ -1351,9 +1353,14 @@ class OutputHTMLWriter(object): """ - def __init__(self, output_directory=''): + def __init__(self, output_directory='', config=None): super(OutputHTMLWriter, self).__init__() + self.config = config make_output_subdirectory(output_directory, 'species') def update(self, rmg): - save_output(rmg) + if self.config is not None and not self.config.should_write( + rmg.reaction_model.iteration_num, rmg.is_final_save): + return + save_edge = self.config.save_edge if (self.config and self.config.save_edge is not None) else rmg.save_edge_species + save_output(rmg, save_edge=save_edge) diff --git a/rmgpy/rmg/settings.py b/rmgpy/rmg/settings.py index b4a7bd52e0b..efe4ca8625a 100644 --- a/rmgpy/rmg/settings.py +++ b/rmgpy/rmg/settings.py @@ -139,3 +139,45 @@ def __init__(self, atol=1e-16, rtol=1e-8, sens_atol=1e-6, sens_rtol=1e-4): self.rtol = rtol self.sens_atol = sens_atol self.sens_rtol = sens_rtol + + +class WriterConfig: + """ + Configuration for a single output-format writer. + + Attributes + ---------- + save_interval : int + How often to write output. Positive N = every N iterations (0-indexed + iteration numbers, so iteration 0 is always included). -1 = end of run + only. 0 = disabled entirely. + verbose_comments : bool or None + Per-writer override for verbose comments. None means fall back to the + global ``rmg.verbose_comments``. + save_edge : bool or None + Per-writer override for saving edge species. None means fall back to + the global ``rmg.save_edge_species``. + """ + + def __init__(self, save_interval=1, verbose_comments=None, save_edge=None): + self.save_interval = save_interval + self.verbose_comments = verbose_comments + self.save_edge = save_edge + self._last_write = -1 + + @property + def enabled(self): + return self.save_interval != 0 + + def should_write(self, iteration_num, is_final): + """Return True if the writer should produce output right now.""" + if not self.enabled: + return False + if self.save_interval == -1: + return is_final + if is_final: + return self._last_write != iteration_num + result = (iteration_num % self.save_interval == 0) + if result: + self._last_write = iteration_num + return result diff --git a/rmgpy/solver/surface.pyx b/rmgpy/solver/surface.pyx index e19cd3bbb4a..a9e0cd22b49 100644 --- a/rmgpy/solver/surface.pyx +++ b/rmgpy/solver/surface.pyx @@ -36,7 +36,7 @@ import logging cimport cython import numpy as np cimport numpy as np -from libc.math cimport exp +from libc.math cimport exp, pow import rmgpy.constants as constants cimport rmgpy.constants as constants @@ -478,9 +478,11 @@ cdef class SurfaceReactor(ReactionSystem): #: surface species are in mol/m2, gas phase are in mol/m3 core_species_concentrations[j] = C[j] + if self.thermo_coverage_dependence or self.coverage_dependence: + coverages = np.where(species_on_surface, np.maximum(N / total_sites, 0.0), 0.0) + # Thermodynamic coverage dependence if self.thermo_coverage_dependence: - coverages = np.where(species_on_surface, N / total_sites, 0.0) coverages_squared = coverages * coverages temperature_scaled_coverages = -self.T.value_si * coverages thermo_dep_coverage = np.empty((6, coverages.shape[0]), dtype=np.float64) @@ -508,12 +510,12 @@ cdef class SurfaceReactor(ReactionSystem): """ for i, list_of_coverage_deps in self.coverage_dependencies.items(): # Species i, Reaction j - surface_site_fraction = N[i] / total_sites - if surface_site_fraction < 1e-15: + surface_site_fraction = coverages[i] + if surface_site_fraction <= 1e-6: continue for j, a, m, E in list_of_coverage_deps: coverage_corrections[j] *= 10. ** (a * surface_site_fraction) *\ - surface_site_fraction ** m *\ + pow(surface_site_fraction, m) *\ exp(-1 * E * surface_site_fraction / (constants.R * self.T.value_si)) kf = kf * coverage_corrections # make a corrected copy kf, but leave the original array at self.kf unchanged kr = kr * coverage_corrections diff --git a/rmgpy/species.py b/rmgpy/species.py index d89cf8c8645..92bb4e805e3 100644 --- a/rmgpy/species.py +++ b/rmgpy/species.py @@ -428,13 +428,18 @@ def to_chemkin(self): from rmgpy.chemkin import get_species_identifier return get_species_identifier(self) - def to_cantera(self, use_chemkin_identifier=False): + def to_cantera(self, use_chemkin_identifier=False, all_species=None): """ Converts the RMG Species object to a Cantera Species object with the appropriate thermo data. If use_chemkin_identifier is set to False, the species label is used instead. Be sure that species' labels are unique when setting it False. + + If all_species is provided and this is a surface species with + coverage-dependent thermo, the coverage-dependencies are attached to + the Cantera Species object via update_user_data() so that they appear + in input_data and in Solution.write_yaml() output. """ import cantera as ct @@ -475,6 +480,32 @@ def to_cantera(self, use_chemkin_identifier=False): if self.transport_data: ct_species.transport = self.transport_data.to_cantera() + # Attach coverage-dependent thermo if present. + # thermo_coverage_dependence keys are adjacency-list strings; we resolve + # them to species names here using all_species. The data is stored via + # update_user_data() so it appears in ct_species.input_data and in any + # YAML serialised by Cantera (e.g. Solution.write_yaml()). + if (all_species is not None + and self.contains_surface_site() + and self.thermo + and hasattr(self.thermo, 'thermo_coverage_dependence') + and self.thermo.thermo_coverage_dependence): + from rmgpy.molecule.molecule import Molecule + cov_deps = {} + for adj_list, parameters in self.thermo.thermo_coverage_dependence.items(): + mol = Molecule().from_adjacency_list(adj_list) + for sp in all_species: + if sp.is_isomorphic(mol, strict=False): + dep_name = sp.to_chemkin() if use_chemkin_identifier else sp.label + cov_deps[dep_name] = { + 'units': {'energy': 'J', 'quantity': 'mol'}, + 'enthalpy-coefficients': [v.value_si for v in parameters['enthalpy-coefficients']], + 'entropy-coefficients': [v.value_si for v in parameters['entropy-coefficients']], + } + break + if cov_deps: + ct_species.update_user_data({'coverage-dependencies': cov_deps}) + return ct_species def has_statmech(self): diff --git a/rmgpy/thermo/nasa.pyx b/rmgpy/thermo/nasa.pyx index 0ee505e4167..a12b086332e 100644 --- a/rmgpy/thermo/nasa.pyx +++ b/rmgpy/thermo/nasa.pyx @@ -421,7 +421,6 @@ cdef class NASA(HeatCapacityModel): poly.change_base_entropy(deltaS) return self - # need to modify this to include the thermo coverage dependence def to_cantera(self): """ Return the cantera equivalent NasaPoly2 object from this NASA object. diff --git a/rmgpy/tools/compare_cantera_yaml.py b/rmgpy/tools/compare_cantera_yaml.py new file mode 100755 index 00000000000..0032ccd25c3 --- /dev/null +++ b/rmgpy/tools/compare_cantera_yaml.py @@ -0,0 +1,548 @@ +#!/usr/bin/env python3 +""" +Script to compare two Cantera YAML files. + +This script loads two Cantera mechanism YAML files and compares them for +structural and numerical differences. It compares: +- YAML metadata (generator, date, units, elements, phases structure) +- Species in each phase (names, ordering, and thermodynamic data) +- Reactions in each phase (equations, ordering, and kinetic data) + +Usage: + python compare_cantera_yaml.py + python compare_cantera_yaml.py # Should show no differences +""" + +import sys +import argparse +import logging +from pathlib import Path +from typing import Any, List, Tuple, Dict +from itertools import chain + +import yaml +import numpy as np +import cantera as ct + + +class CanteraModel: + """ + Represents a Cantera mechanism model loaded from a YAML file. + + This class loads both the raw YAML data structure and creates Cantera + Solution objects for each phase defined in the file. + + Attributes + ---------- + file_path : str + Path to the Cantera YAML file. + yaml_data : dict + Raw YAML data loaded from the file. + phases : dict + Dictionary of phase_name -> ct.Solution objects. + """ + + def __init__(self, file_path: str): + """ + Initialize a CanteraModel by loading the YAML file and all its phases. + + Parameters + ---------- + file_path : str + Path to the Cantera YAML file. + + Raises + ------ + FileNotFoundError + If the file does not exist. + Exception + If loading the YAML or phases fails. + """ + self.file_path = file_path + self.yaml_data = None + self.phases = {} + + # Load the YAML structure + self.load_yaml() + + # Extract phase names and load each phase + phase_names = self._extract_phase_names() + self.load_phases(phase_names) + + def load_yaml(self) -> dict: + """ + Load the YAML file into a dictionary structure using yaml.safe_load(). + + Returns + ------- + dict + The YAML data structure. + + Raises + ------ + FileNotFoundError + If the file does not exist. + yaml.YAMLError + If YAML parsing fails. + """ + with open(self.file_path, 'r') as f: + self.yaml_data = yaml.safe_load(f) + return self.yaml_data + + def _extract_phase_names(self) -> List[str]: + """ + Extract phase names from the loaded YAML data. + + Returns + ------- + list of str + List of phase names found in the 'phases' section. + + Raises + ------ + ValueError + If 'phases' key is not found or is empty. + """ + if self.yaml_data is None: + raise ValueError("YAML data not loaded. Call load_yaml() first.") + + if 'phases' not in self.yaml_data: + raise ValueError(f"No 'phases' key found in {self.file_path}") + + phases_list = self.yaml_data['phases'] + if not phases_list: + raise ValueError(f"'phases' list is empty in {self.file_path}") + + phase_names = [] + for phase in phases_list: + if 'name' not in phase: + raise ValueError(f"Phase definition missing 'name' key: {phase}") + phase_names.append(phase['name']) + + return phase_names + + def load_phases(self, phase_names: List[str]): + """ + Load Cantera Solution objects for the specified phases. + + Parameters + ---------- + phase_names : list of str + List of phase names to load from the YAML file. + + Raises + ------ + RuntimeError + If loading any phase fails (with original exception chained). + """ + for phase_name in phase_names: + try: + solution = ct.Solution(self.file_path, name=phase_name) + self.phases[phase_name] = solution + except Exception as e: + raise RuntimeError(f"Failed to load phase '{phase_name}' from {self.file_path}") from e + + + +def is_numeric(value: Any) -> bool: + """Check if a value is numeric (int or float).""" + return isinstance(value, (int, float, np.number)) and not isinstance(value, bool) + + +def compare_values(val1: Any, val2: Any, path: str, atol: float = 1e-12, + rtol: float = 1e-3) -> List[str]: + """Compare two values and return a list of differences. + + Parameters + ---------- + val1 : Any + First value to compare. + val2 : Any + Second value to compare. + path : str + Path in the dictionary (for error reporting). + atol : float + Absolute tolerance for numerical comparisons. + rtol : float + Relative tolerance for numerical comparisons. + + Returns + ------- + list of str + List of difference descriptions, empty if no differences found. + """ + differences = [] + + ### SPECIAL CASES + # Special handling for 'elements' path - normalize to title case and sort + if path.split('.')[-1] == 'elements': + if isinstance(val1[0], str) and isinstance(val2[0], str): + val1_normalized = sorted([v.title() for v in val1]) + val2_normalized = sorted([v.title() for v in val2]) + if val1_normalized != val2_normalized: + differences.append(f"Elements list mismatch at {path}: {val1_normalized} vs {val2_normalized}") + return differences + if isinstance(val1[0], dict) and isinstance(val2[0], dict): + for d in chain(val1, val2): + d['symbol'] = d['symbol'].title() + val1 = sorted([d for d in val1], key=lambda x: x['symbol']) + val2 = sorted([d for d in val2], key=lambda x: x['symbol']) + + if path.endswith('Troe.T1') or path.endswith('Troe.T2') or path.endswith('Troe.T3'): + rtol = 5e-3 # Relax tolerance due to rounding. + + ### END OF SPECIAL CASES + + # Type checking + if type(val1) != type(val2): + differences.append(f"Type mismatch at {path}: {type(val1).__name__} vs {type(val2).__name__}") + return differences + + # Handle dictionaries recursively + if isinstance(val1, dict): + for key in set(list(val1.keys()) + list(val2.keys())): + if key not in val1: + if key == 'reference-pressure': + continue # Ignore missing 'reference-pressure' key SPECIAL CASE + differences.append(f"Missing key in first file at {path}.{key}") + elif key not in val2: + differences.append(f"Missing key in second file at {path}.{key}") + else: + new_path = f"{path}.{key}" if path else key + differences.extend(compare_values(val1[key], val2[key], new_path, atol, rtol)) + + # Handle lists recursively + elif isinstance(val1, list): + if len(val1) != len(val2): + differences.append(f"List length mismatch at {path}: {len(val1)} vs {len(val2)}") + # Compare up to the shorter length + min_len = min(len(val1), len(val2)) + else: + min_len = len(val1) + + for i in range(min_len): + new_path = f"{path}[{i}]" + differences.extend(compare_values(val1[i], val2[i], new_path, atol, rtol)) + + # Handle numeric values with tolerance + elif is_numeric(val1) and is_numeric(val2): + # Use numpy.allclose for comparison + if not np.isclose(val1, val2, atol=atol, rtol=rtol): + # Compute the difference for reporting + abs_diff = abs(val1 - val2) + rel_diff = abs(abs_diff / val2) if val2 != 0 else float('inf') + differences.append(f"Numerical difference at {path}: {val1} vs {val2} " + f"(abs_diff={abs_diff:.2e}, rel_diff={rel_diff:.2e})") + + # Handle strings and other comparable types + elif val1 != val2: + differences.append(f"Value mismatch at {path}: {val1!r} vs {val2!r}") + + return differences + + +def compare_yaml_files(file1: str, file2: str, atol: float = 1e-12, + rtol: float = 1e-3) -> List[str]: + """Compare two Cantera YAML files. + + Compares both the raw YAML structure and the species/reactions + from loaded Cantera phases. + + Parameters + ---------- + file1 : str + Path to the first YAML file. + file2 : str + Path to the second YAML file. + atol : float + Absolute tolerance for numerical comparisons. + rtol : float + Relative tolerance for numerical comparisons. + + Returns + ------- + list of str + List of difference descriptions (empty if files are equivalent). + """ + differences = [] + + logging.info("Loading %s...", file1) + model1 = CanteraModel(file1) + + logging.info("Loading %s...", file2) + model2 = CanteraModel(file2) + + # Compare YAML metadata (everything except species and reactions details) + logging.info("Comparing YAML metadata...") + yaml_meta1 = _extract_yaml_metadata(model1.yaml_data) + yaml_meta2 = _extract_yaml_metadata(model2.yaml_data) + + for ym in (yaml_meta1, yaml_meta2): + ym.pop('cantera-version', None) + ym.pop('input-files', None) + ym.pop('date', None) + + differences.extend(compare_values(yaml_meta1, yaml_meta2, "metadata", atol, rtol)) + + # Compare phases sequentially by order + logging.info("Comparing phases...") + phase_list1 = model1.yaml_data.get('phases', []) + phase_list2 = model2.yaml_data.get('phases', []) + + if len(phase_list1) != len(phase_list2): + differences.append(f"Number of phases differs: {len(phase_list1)} vs {len(phase_list2)}") + + # Compare each phase by order + for i in range(max(len(phase_list1), len(phase_list2))): + if i >= len(phase_list1): + differences.append(f"Phase {i}: missing in first file (second file has '{phase_list2[i]['name']}')") + continue + if i >= len(phase_list2): + differences.append(f"Phase {i}: missing in second file (first file has '{phase_list1[i]['name']}')") + continue + + phase1_name = phase_list1[i]['name'] + phase2_name = phase_list2[i]['name'] + + if phase1_name != phase2_name: + differences.append(f"Phase {i}: name differs: '{phase1_name}' vs '{phase2_name}'") + + # Compare species and reactions for this phase + phase1 = model1.phases[phase1_name] + phase2 = model2.phases[phase2_name] + + logging.info(" Comparing species in phase '%s'...", phase1_name) + differences.extend(_compare_species(phase1, phase2, phase1_name, atol, rtol)) + + logging.info(" Comparing reactions in phase '%s'...", phase1_name) + differences.extend(_compare_reactions(phase1, phase2, phase1_name, atol, rtol)) + + return differences + + +def compare_yaml_files_and_report(file1: str, file2: str, atol: float = 1e-12, + rtol: float = 1e-3, output: str = None) -> bool: + """Compare two Cantera YAML files and report results via logging. + + Performs a comparison between two Cantera YAML files and logs the results. + If an output file path is provided, also writes the report to that file. + + Parameters + ---------- + file1 : str + Path to the first YAML file. + file2 : str + Path to the second YAML file. + atol : float + Absolute tolerance for numerical comparisons. + rtol : float + Relative tolerance for numerical comparisons. + output : str, optional + Path to an output file where the comparison report will be written. + If None, only logs to the standard logger. + + Returns + ------- + bool + True if files are equivalent (no differences), False otherwise. + """ + file_handler = None + root_logger = logging.getLogger() + + try: + # Set up optional file logging if output path provided + if output: + file_handler = logging.FileHandler(output) + file_handler.setFormatter(logging.Formatter("%(message)s")) + root_logger.addHandler(file_handler) + + # Check if file2 exists + if not Path(file2).exists(): + logging.warning("Cantera YAML comparison skipped; file not found at %s", file2) + return False + + # Perform the comparison + differences = compare_yaml_files(file1, file2, atol, rtol) + + # Log and report results + if differences: + logging.warning( + "Cantera YAML comparison found %d difference(s) between %s and %s", + len(differences), + file1, + file2, + ) + for diff in differences: + logging.warning(" %s", diff) + return False + else: + logging.info( + "Cantera YAML comparison passed: %s matches %s", + file1, + file2, + ) + return True + + except Exception: + logging.exception("Cantera YAML comparison failed for %s vs %s", file1, file2) + return False + + finally: + # Clean up the file handler + if file_handler: + file_handler.close() + root_logger.removeHandler(file_handler) + + +def _extract_yaml_metadata(yaml_data: dict) -> dict: + """Extract metadata from YAML (excluding detailed species/reactions).""" + metadata = yaml_data.copy() + # Remove the detailed species and reactions lists since we'll compare those separately + metadata.pop('species', None) + metadata.pop('reactions', None) + reaction_blocks = [] + for phase in yaml_data.get('phases', []): + reactions = phase.get('reactions', []) + if reactions in ('declared-species', 'all', 'none'): + continue + reaction_blocks.extend(reactions) + for block in reaction_blocks: + if block not in metadata: + raise ValueError(f"Phase mentioned reactions block '{block}' not found in top-level YAML keys") + metadata.pop(block) + return metadata + + +def _compare_species(phase1, phase2, phase_name: str, atol: float, rtol: float) -> List[str]: + """Compare species in two Cantera phases.""" + differences = [] + + species1 = phase1.species() + species2 = phase2.species() + + if len(species1) != len(species2): + differences.append(f"Phase '{phase_name}': number of species differs: {len(species1)} vs {len(species2)}") + + # Build name-to-species mapping for comparison + species1_map = {sp.name: sp for sp in species1} + species2_map = {sp.name: sp for sp in species2} + + # Check for missing species + names1 = set(species1_map.keys()) + names2 = set(species2_map.keys()) + + for name in names1 - names2: + differences.append(f"Phase '{phase_name}': species '{name}' only in first file") + for name in names2 - names1: + differences.append(f"Phase '{phase_name}': species '{name}' only in second file") + + # Compare ordering + common_species = names1 & names2 + for i in range(min(len(species1), len(species2))): + if species1[i].name != species2[i].name: + if species1[i].name in common_species and species2[i].name in common_species: + differences.append(f"Phase '{phase_name}': species order differs at index {i}: " + f"'{species1[i].name}' vs '{species2[i].name}'") + break # Only report first ordering difference + + # Compare input_data for matching species + for name in sorted(common_species): + sp1 = species1_map[name] + sp2 = species2_map[name] + path = f"phase.{phase_name}.species.{name}" + differences.extend(compare_values(sp1.input_data, sp2.input_data, path, atol, rtol)) + + return differences + + +def _compare_reactions(phase1, phase2, phase_name: str, atol: float, rtol: float) -> List[str]: + """Compare reactions in two Cantera phases.""" + differences = [] + + reactions1 = phase1.reactions() + reactions2 = phase2.reactions() + + if len(reactions1) != len(reactions2): + differences.append(f"Phase '{phase_name}': number of reactions differs: {len(reactions1)} vs {len(reactions2)}") + + # Compare reactions by index (assuming they should be in the same order) + for i in range(min(len(reactions1), len(reactions2))): + rxn1 = reactions1[i] + rxn2 = reactions2[i] + + # Check if equations match + eq1 = rxn1.equation + eq2 = rxn2.equation + + if eq1 != eq2: + differences.append(f"Phase '{phase_name}': reaction {i} equation differs: '{eq1}' vs '{eq2}'") + # Still compare input_data even if equations differ + + path = f"phase.{phase_name}.reaction[{i}]" + differences.extend(compare_values(rxn1.input_data, rxn2.input_data, path, atol, rtol)) + + return differences + + +def main(): + """Main entry point for the comparison script.""" + logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") + parser = argparse.ArgumentParser( + description="Compare two Cantera YAML mechanism files.", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + python compare_cantera_yaml.py file1.yaml file2.yaml + python compare_cantera_yaml.py file1.yaml file1.yaml # Should show no differences + python compare_cantera_yaml.py --abs-tol 1e-6 file1.yaml file2.yaml + """ + ) + parser.add_argument("file1", help="First Cantera YAML file") + parser.add_argument("file2", help="Second Cantera YAML file") + parser.add_argument("--abs-tol", type=float, default=1e-11, + help="Absolute tolerance for numerical comparisons (default: 1e-9)") + parser.add_argument("--rel-tol", type=float, default=1e-3, + help="Relative tolerance for numerical comparisons (default: 1e-9)") + + args = parser.parse_args() + + # Verify files exist + for file_path in [args.file1, args.file2]: + if not Path(file_path).exists(): + logging.error("File not found: %s", file_path) + sys.exit(1) + + try: + differences = compare_yaml_files( + args.file1, args.file2, args.abs_tol, args.rel_tol + ) + + if len(differences) == 0: + logging.info("Files are equivalent (within specified tolerances)") + sys.exit(0) + else: + logging.warning("Files differ. Found %d difference(s):", len(differences)) + for i, diff in enumerate(differences, 1): + logging.info("%3d. %s", i, diff) + sys.exit(1) + + except Exception as e: + logging.exception("Error: %s", e) + sys.exit(1) + + +if __name__ == "__main__": + logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") + if len(sys.argv) == 1: + logging.info("No arguments provided. Using default test files for demonstration.") + # sys.argv.extend([ + # "test/rmgpy/test_data/yaml_writer_data/chemkin/from_main_test.yaml", + # "test/rmgpy/test_data/yaml_writer_data/cantera/from_main_test.yaml" + # ]) + + sys.argv.extend([ + "/Users/rwest/Code/RMG-Py/testing/eg0/cantera_from_ck/chem.yaml", + "/Users/rwest/Code/RMG-Py/testing/eg0/cantera2/chem.yaml" + ]) + + main() diff --git a/rmgpy/util.py b/rmgpy/util.py index 15769e02e61..8be80d5f889 100644 --- a/rmgpy/util.py +++ b/rmgpy/util.py @@ -173,7 +173,7 @@ def parse_command_line_arguments(command_line_args=None): parser.add_argument('-P', '--postprocess', action='store_true', help='postprocess profiling statistics from previous [failed] run; does not run the simulation') - parser.add_argument('-t', '--walltime', type=str, nargs=1, default='00:00:00:00', + parser.add_argument('-t', '--walltime', type=str, nargs=1, default=None, metavar='DD:HH:MM:SS', help='set the maximum execution time') parser.add_argument('-i', '--maxiter', type=int, nargs=1, default=None, @@ -197,7 +197,7 @@ def parse_command_line_arguments(command_line_args=None): args.file = args.file[0] # If walltime was specified, retrieve this string from the element 1 list - if args.walltime != '00:00:00:00': + if args.walltime: args.walltime = args.walltime[0] if args.restart: diff --git a/rmgpy/yaml_cantera1.py b/rmgpy/yaml_cantera1.py new file mode 100644 index 00000000000..db2928b0c94 --- /dev/null +++ b/rmgpy/yaml_cantera1.py @@ -0,0 +1,536 @@ +#!/usr/bin/env python3 + +############################################################################### +# # +# RMG - Reaction Mechanism Generator # +# # +# Copyright (c) 2002-2024 Prof. William H. Green (whgreen@mit.edu), # +# Prof. Richard H. West (r.west@neu.edu) and the RMG Team (rmg_dev@mit.edu) # +# # +# Permission is hereby granted, free of charge, to any person obtaining a # +# copy of this software and associated documentation files (the 'Software'), # +# to deal in the Software without restriction, including without limitation # +# the rights to use, copy, modify, merge, publish, distribute, sublicense, # +# and/or sell copies of the Software, and to permit persons to whom the # +# Software is furnished to do so, subject to the following conditions: # +# # +# The above copyright notice and this permission notice shall be included in # +# all copies or substantial portions of the Software. # +# # +# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # +# DEALINGS IN THE SOFTWARE. # +# # +############################################################################### + +""" +This file defines functions for outputting the RMG generated mechanism to +a yaml file that can be read by Cantera +""" + + +import os +import shutil +try: + from yaml import CDumper as Dumper +except ImportError: + from yaml import Dumper +import yaml +import logging + +from rmgpy.species import Species +from rmgpy.kinetics.arrhenius import ( + MultiArrhenius, + MultiPDepArrhenius, +) +from rmgpy.util import make_output_subdirectory +from datetime import datetime +from rmgpy.chemkin import get_species_identifier +from rmgpy.data.kinetics.family import TemplateReaction +from rmgpy.data.kinetics.library import LibraryReaction +from rmgpy.rmg.pdep import PDepReaction + + +def _convert_anymap_to_dict(obj): + """ + Recursively convert Cantera AnyMap objects to regular Python dicts. + + Cantera's input_data property returns dicts containing AnyMap objects, + which are Cython extension types that cannot be serialized by YAML. + This function recursively converts all AnyMaps to plain dicts. + + Args: + obj: Any object (dict, list, AnyMap, or primitive type) + + Returns: + The object with all AnyMaps converted to dicts + """ + try: + from cantera._utils import AnyMap + except ImportError: + # If Cantera is not available or doesn't have AnyMap, just return the object + return obj + + if isinstance(obj, AnyMap): + # Convert AnyMap to dict and recursively process values + return {k: _convert_anymap_to_dict(v) for k, v in dict(obj).items()} + elif isinstance(obj, dict): + # Recursively process dict values + return {k: _convert_anymap_to_dict(v) for k, v in obj.items()} + elif isinstance(obj, (list, tuple)): + # Recursively process list/tuple elements + return type(obj)(_convert_anymap_to_dict(item) for item in obj) + else: + # Return primitive types as-is + return obj + + +def write_cantera( + spcs, + rxns, + surface_site_density=None, + solvent=None, + solvent_data=None, + path="chem.yml", + verbose=False, +): + """ + Writes yaml file depending on the type of system (gas-phase, catalysis). + Writes beginning lines of yaml file, then uses yaml.dump(result_dict) to write species/reactions info. + If verbose=True, species and reaction notes (SMILES, source, kinetics comment) are included. + """ + + try: + from rmgpy.rmg.main import RMG + git_head, _ = RMG.get_git_commit(None, os.path.dirname(__file__)) + git_head = " (git commit: {0})".format(git_head[:7]) + except Exception: + git_head = '' + + # intro to file will change depending on the presence of surface species + is_surface = False + for spc in spcs: + if spc.contains_surface_site(): + is_surface = True + if is_surface: + has_coverage_dependence = any( + hasattr(spc.thermo, 'thermo_coverage_dependence') and spc.thermo.thermo_coverage_dependence + for spc in spcs if spc.contains_surface_site() + ) + result_dict = get_mech_dict_surface( + spcs, rxns, solvent=solvent, solvent_data=solvent_data, verbose=verbose + ) + phases_block = get_phases_with_surface( + spcs, surface_site_density, has_coverage_dependence=has_coverage_dependence + ) + else: + result_dict = get_mech_dict_nonsurface( + spcs, rxns, solvent=solvent, solvent_data=solvent_data, verbose=verbose + ) + phases_block = get_phases_gas_only(spcs) + + with open(path, "w") as f: + # generator line + generator = f"RMG-Py CanteraWriter1 at {__file__}{git_head}" + f.write(f'generator: "{generator}"\n') + + # datetime object containing current date and time + now = datetime.now() + dt_string = now.strftime("%a, %d %b %Y %H:%M:%S") + f.write(f"date: {dt_string}\n") + + # units line + f.write( + "\nunits: {length: m, time: s, quantity: kmol, activation-energy: J/kmol}\n\n" + ) + + f.write(phases_block) + + f.write(ELEMENTS_BLOCK) + + yaml.dump(result_dict, stream=f, Dumper=Dumper, sort_keys=False, default_flow_style=None, width=80) + +def get_elements_block(): + """ + Returns the 'elements' section, and elements list for a phase + """ + from rmgpy.molecule.element import get_element + elements_list = ['H', 'C', 'O', 'N', 'Ne', 'Ar', 'He', 'Si', 'S', + 'F', 'Cl', 'Br', 'I'] + isotopes = (('H', 2), ('H', 3), ('C', 13),('O', 18)) + elements_block_list = ['', 'elements:'] + for symbol, isotope in isotopes: + element = get_element(symbol, isotope=isotope) + chemkin_name = element.chemkin_name + mass = 1000 * element.mass + elements_block_list.append(f"- symbol: {chemkin_name}\n atomic-weight: {mass:f}") + elements_list.append(chemkin_name) + # Surface sites + elements_list.append('X') + elements_block_list.append("- symbol: X\n atomic-weight: 195.083\n\n") + elements_block = '\n'.join(elements_block_list) + elements_line = f"elements: [{', '.join(elements_list)}]" + return elements_block, elements_line +# For now this is not dynamic, and includes everything, so we just evaluate it +# once and use it for all files. +ELEMENTS_BLOCK, ELEMENTS_LINE = get_elements_block() + + +def get_phases_gas_only(spcs): + """ + Returns 'phases' sections for a file + with only gas-phase species/reactions. + """ + sorted_species = sorted(spcs, key=lambda spcs: spcs.index) + species_to_write = [get_species_identifier(spec) for spec in sorted_species] + # make sure species with "[" or "]" is in quotes + species_to_write = [ + f"'{s}'" if "[" in s or "{" in s or "]" in s or "}" in s else s + for s in species_to_write + ] + phases_block = f""" +phases: +- name: gas + thermo: ideal-gas + {ELEMENTS_LINE} + species: [{', '.join(species_to_write)}] + kinetics: gas + transport: mixture-averaged + state: {{T: 300.0, P: 1 atm}} +""" + return phases_block + + +def get_phases_with_surface(spcs, surface_site_density, has_coverage_dependence=False): + """ + Yaml files with surface species begin with the following blocks of text, + which includes TWO phases instead of just one. + Returns 'phases' sections. + """ + surface_species = [] + gas_species = [] + for spc in spcs: + + if spc.contains_surface_site(): + surface_species.append(spc) + else: + gas_species.append(spc) + + sorted_surface_species = sorted( + surface_species, key=lambda surface_species: surface_species.index + ) + + surface_species_to_write = [ + get_species_identifier(s) for s in sorted_surface_species + ] + + # make sure species with "[" or "]" is in quotes + surface_species_to_write = [ + f"'{s}'" if "[" in s or "{" in s or "]" in s or "}" in s else s + for s in surface_species_to_write + ] + + sorted_gas_species = sorted(gas_species, key=lambda gas_species: gas_species.index) + gas_species_to_write = [get_species_identifier(s) for s in sorted_gas_species] + + # make sure species with "[" or "]" is in quotes + gas_species_to_write = [ + f"'{s}'" if "[" in s or "{" in s or "]" in s or "}" in s else s + for s in gas_species_to_write + ] + + surface_thermo = 'coverage-dependent-surface' if has_coverage_dependence else 'ideal-surface' + reference_state_line = '\n reference-state-coverage: 0.11' if has_coverage_dependence else '' + + phases_block = f""" +phases: +- name: gas + thermo: ideal-gas + {ELEMENTS_LINE} + species: [{', '.join(gas_species_to_write)}] + kinetics: gas + reactions: [gas-reactions] + transport: mixture-averaged + state: {{T: 300.0, P: 1 atm}} + +- name: surface + thermo: {surface_thermo}{reference_state_line} + adjacent-phases: [gas] + {ELEMENTS_LINE} + species: [{', '.join(surface_species_to_write)}] + kinetics: surface + reactions: [site0-reactions] + site-density: {surface_site_density * 1e-4 } +""" + # surface_site_density * 1e-4 #in units of mol/cm^2 + + return phases_block + + +def get_mech_dict_surface(spcs, rxns, solvent="solvent", solvent_data=None, verbose=False): + """ + For systems with surface species/reactions. + Adds 'species', 'gas-reactions', and 'site0-reactions' to result_dict. + """ + gas_rxns = [] + surface_rxns = [] + for rxn in rxns: + if rxn.is_surface_reaction(): + surface_rxns.append(rxn) + else: + gas_rxns.append(rxn) + + names = [x.label for x in spcs] + for i, name in enumerate(names): # fix duplicate names + if names.count(name) > 1: + names[i] += "-" + str(names.count(name)) + + result_dict = dict() + result_dict["species"] = [species_to_dict(x, all_species=spcs, verbose=verbose) for x in spcs] + + # separate gas and surface reactions + + gas_reactions = [] + for rmg_rxn in gas_rxns: + gas_reactions.extend(reaction_to_dicts(rmg_rxn, spcs, verbose=verbose)) + result_dict["gas-reactions"] = gas_reactions + + surface_reactions = [] + for rmg_rxn in surface_rxns: + surface_reactions.extend(reaction_to_dicts(rmg_rxn, spcs, verbose=verbose)) + result_dict["site0-reactions"] = surface_reactions + + return result_dict + + +def get_mech_dict_nonsurface(spcs, rxns, solvent="solvent", solvent_data=None, verbose=False): + """ + For gas-phase systems. + Adds 'species' and 'reactions' to result_dict. + """ + names = [x.label for x in spcs] + for i, name in enumerate(names): # fix duplicate names + if names.count(name) > 1: + names[i] += "-" + str(names.count(name)) + + result_dict = dict() + result_dict["species"] = [species_to_dict(x, verbose=verbose) for x in spcs] + + reactions = [] + for rmg_rxn in rxns: + reactions.extend(reaction_to_dicts(rmg_rxn, spcs, verbose=verbose)) + result_dict["reactions"] = reactions + + return result_dict + + +def reaction_to_dicts(obj, spcs, verbose=False): + """ + Takes an RMG reaction object (obj), returns a list of dictionaries + for YAML properties. For most reaction objects the list will be of + length 1, but a MultiArrhenius or MultiPDepArrhenius will be longer. + If verbose=True, a 'note' field is added with source and kinetics comment. + """ + + reaction_list = [] + if isinstance(obj.kinetics, MultiArrhenius) or isinstance( + obj.kinetics, MultiPDepArrhenius + ): + list_of_cantera_reactions = obj.to_cantera(use_chemkin_identifier=True) + else: + list_of_cantera_reactions = [obj.to_cantera(use_chemkin_identifier=True)] + + for reaction in list_of_cantera_reactions: + reaction_data = reaction.input_data + efficiencies = getattr(obj.kinetics, "efficiencies", {}) + if efficiencies: + reaction_data["efficiencies"] = { + spcs[i].to_chemkin(): float(val) + for i, val in enumerate( + obj.kinetics.get_effective_collider_efficiencies(spcs) + ) + if val != 1 + } + # Convert any AnyMap objects to regular dicts before appending + reaction_data = _convert_anymap_to_dict(reaction_data) + + if verbose: + note_parts = [] + if isinstance(obj, TemplateReaction): + note_parts.append(f"Template reaction: {obj.family}") + elif isinstance(obj, LibraryReaction): + note_parts.append(f"Library reaction: {obj.library}") + elif isinstance(obj, PDepReaction): + note_parts.append(f"PDep reaction: {obj.network}") + if obj.specific_collider is not None: + note_parts.append(f"Specific collider: {obj.specific_collider.label}") + if obj.kinetics.comment: + note_parts.append(obj.kinetics.comment.replace('\n', '; ').strip()) + if note_parts: + reaction_data["note"] = " | ".join(note_parts) + + reaction_list.append(reaction_data) + + return reaction_list + + +def species_to_dict(species, all_species=None, verbose=False): + """ + Takes an RMG species object, returns a dictionary of YAML properties. + Also adds in the number of surface sites ('sites') to the dictionary. + + all_species: if provided, coverage-dependent thermo is resolved and + attached to the Cantera species object before serialisation, so it + appears in the returned dict automatically. + If verbose=True, species SMILES and thermo/transport comments are included. + """ + if not isinstance(species, Species): + raise TypeError("species object must be an RMG Species") + + cantera_species = species.to_cantera(use_chemkin_identifier=True, all_species=all_species) + species_data = cantera_species.input_data + + if verbose: + try: + transport_comment = species.transport_data.comment + if transport_comment: + species_data["transport"]["note"] = transport_comment + except AttributeError: + pass + + if "size" in species_data: + sites = species_data["size"] + species_data.pop("size", None) + species_data["sites"] = sites + + # Convert any AnyMap objects to regular dicts before returning + species_data = _convert_anymap_to_dict(species_data) + + if verbose: + try: + smiles = species.to_smiles() + if smiles: + species_data["note"] = smiles + except Exception: + pass + if species.thermo and species.thermo.comment: + clean_comment = species.thermo.comment.replace('\n', '; ').strip() + if clean_comment: + if "thermo" in species_data and isinstance(species_data["thermo"], dict): + species_data["thermo"]["note"] = clean_comment + + # returns composition, name, thermo, and transport, and note + return species_data + + +class CanteraWriter1(object): + """ + This class listens to a RMG subject + and writes an YAML file with the current state of the RMG model, + to a yaml subfolder. + + + A new instance of the class can be appended to a subject as follows: + + rmg = ... + listener = CanteraWriter1(outputDirectory) + rmg.attach(listener) + + Whenever the subject calls the .notify() method, the + .update() method of the listener will be called. + + To stop listening to the subject, the class can be detached + from its subject: + + rmg.detach(listener) + + """ + + def __init__(self, output_directory="", config=None): + super(CanteraWriter1, self).__init__() + self.output_directory = output_directory + self.config = config + self.output_subdirectory = os.path.join(self.output_directory, "cantera1") + make_output_subdirectory(output_directory, "cantera1") + + def update(self, rmg): + if self.config is not None and not self.config.should_write( + rmg.reaction_model.iteration_num, rmg.is_final_save): + return + verbose = self.config.verbose_comments if (self.config and self.config.verbose_comments is not None) else rmg.verbose_comments + save_edge = self.config.save_edge if (self.config and self.config.save_edge is not None) else rmg.save_edge_species + + num_species = len(rmg.reaction_model.core.species) + this_output_path = os.path.join(self.output_subdirectory, + f"chem{num_species:04d}.yaml") + latest_output_path = os.path.join(self.output_subdirectory, 'chem.yaml') + + logging.info(f"Saving current model core to Cantera file: {this_output_path}") + + solvent_data = None + if rmg.solvent: + solvent_data = rmg.database.solvation.get_solvent_data(rmg.solvent) + + surface_site_density = None + if rmg.reaction_model.surface_site_density: + surface_site_density = rmg.reaction_model.surface_site_density.value_si + + write_cantera( + rmg.reaction_model.core.species, + rmg.reaction_model.core.reactions, + surface_site_density=surface_site_density, + solvent=rmg.solvent, + solvent_data=solvent_data, + path=this_output_path, + ) + shutil.copy2(this_output_path, latest_output_path) + + if verbose: + annotated_path = os.path.join(self.output_subdirectory, 'chem_annotated.yaml') + logging.info(f"Saving annotated Cantera file: {annotated_path}") + write_cantera( + rmg.reaction_model.core.species, + rmg.reaction_model.core.reactions, + surface_site_density=surface_site_density, + solvent=rmg.solvent, + solvent_data=solvent_data, + path=annotated_path, + verbose=True, + ) + + if save_edge: + logging.info('Saving current model core and edge to Cantera file...') + edge_species = rmg.reaction_model.core.species + rmg.reaction_model.edge.species + edge_reactions = rmg.reaction_model.core.reactions + rmg.reaction_model.edge.reactions + + this_edge_path = os.path.join(self.output_subdirectory, + f"chem_edge{num_species:04d}.yaml") + latest_edge_path = os.path.join(self.output_subdirectory, 'chem_edge.yaml') + + write_cantera( + edge_species, + edge_reactions, + surface_site_density=surface_site_density, + solvent=rmg.solvent, + solvent_data=solvent_data, + path=this_edge_path, + ) + shutil.copy2(this_edge_path, latest_edge_path) + + if verbose: + annotated_edge_path = os.path.join(self.output_subdirectory, + 'chem_edge_annotated.yaml') + logging.info(f"Saving annotated edge Cantera file: {annotated_edge_path}") + write_cantera( + edge_species, + edge_reactions, + surface_site_density=surface_site_density, + solvent=rmg.solvent, + solvent_data=solvent_data, + path=annotated_edge_path, + verbose=True, + ) diff --git a/rmgpy/yaml_cantera2.py b/rmgpy/yaml_cantera2.py new file mode 100644 index 00000000000..b5fd10500f7 --- /dev/null +++ b/rmgpy/yaml_cantera2.py @@ -0,0 +1,626 @@ +############################################################################### +# # +# RMG - Reaction Mechanism Generator # +# # +# Copyright (c) 2002-2023 Prof. William H. Green (whgreen@mit.edu), # +# Prof. Richard H. West (r.west@neu.edu) and the RMG Team (rmg_dev@mit.edu) # +# # +# Permission is hereby granted, free of charge, to any person obtaining a # +# copy of this software and associated documentation files (the 'Software'), # +# to deal in the Software without restriction, including without limitation # +# the rights to use, copy, modify, merge, publish, distribute, sublicense, # +# and/or sell copies of the Software, and to permit persons to whom the # +# Software is furnished to do so, subject to the following conditions: # +# # +# The above copyright notice and this permission notice shall be included in # +# all copies or substantial portions of the Software. # +# # +# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # +# DEALINGS IN THE SOFTWARE. # +# # +############################################################################### + +""" +This module contains functions for writing of Cantera input files. +""" + +from typing import Union, TYPE_CHECKING + +import os +import shutil +import logging +try: + from yaml import CDumper as Dumper +except ImportError: + from yaml import Dumper +import yaml + +from rmgpy.data.kinetics.family import TemplateReaction +from rmgpy.data.kinetics.library import LibraryReaction +from rmgpy.kinetics import ( + Arrhenius, PDepArrhenius, MultiArrhenius, MultiPDepArrhenius, + Chebyshev, Troe, Lindemann, ThirdBody, + StickingCoefficient, SurfaceArrhenius, +) +from rmgpy.reaction import Reaction +from rmgpy.rmg.pdep import PDepReaction +from rmgpy.util import make_output_subdirectory +import rmgpy.constants as constants + +from rmgpy.species import Species +if TYPE_CHECKING: + from rmgpy.molecule.molecule import Molecule + +SYMBOL_BY_NUMBER = {0: 'e', 1: 'H', 2: 'He', 3: 'Li', 4: 'Be', 5: 'B', 6: 'C', 7: 'N', 8: 'O', 9: 'F', 10: 'Ne', + 11: 'Na', 12: 'Mg', 13: 'Al', 14: 'Si', 15: 'P', 16: 'S', 17: 'Cl', 18: 'Ar', 19: 'K', 20: 'Ca', + 21: 'Sc', 22: 'Ti', 23: 'V', 24: 'Cr', 25: 'Mn', 26: 'Fe', 27: 'Co', 28: 'Ni', 29: 'Cu', 30: 'Zn', + 31: 'Ga', 32: 'Ge', 33: 'As', 34: 'Se', 35: 'Br', 36: 'Kr', 37: 'Rb', 38: 'Sr', 39: 'Y', 40: 'Zr', + 41: 'Nb', 42: 'Mo', 43: 'Tc', 44: 'Ru', 45: 'Rh', 46: 'Pd', 47: 'Ag', 48: 'Cd', 49: 'In', 50: 'Sn', + 51: 'Sb', 52: 'Te', 53: 'I', 54: 'Xe', 55: 'Cs', 56: 'Ba', 57: 'La', 58: 'Ce', 59: 'Pr', 60: 'Nd', + 61: 'Pm', 62: 'Sm', 63: 'Eu', 64: 'Gd', 65: 'Tb', 66: 'Dy', 67: 'Ho', 68: 'Er', 69: 'Tm', 70: 'Yb', + 71: 'Lu', 72: 'Hf', 73: 'Ta', 74: 'W', 75: 'Re', 76: 'Os', 77: 'Ir', 78: 'Pt', 79: 'Au', 80: 'Hg', + 81: 'Tl', 82: 'Pb', 83: 'Bi', 84: 'Po', 85: 'At', 86: 'Rn', 87: 'Fr', 88: 'Ra', 89: 'Ac', 90: 'Th', + 91: 'Pa', 92: 'U', 93: 'Np', 94: 'Pu', 95: 'Am', 96: 'Cm', 97: 'Bk', 98: 'Cf', 99: 'Es', 100: 'Fm', + 101: 'Md', 102: 'No', 103: 'Lr', 104: 'Rf', 105: 'Db', 106: 'Sg', 107: 'Bh', 108: 'Hs', 109: 'Mt', + 110: 'Ds', 111: 'Rg', 112: 'Cn', 113: 'Nh', 114: 'Fl', 115: 'Mc', 116: 'Lv', 117: 'Ts', 118: 'Og'} +NUMBER_BY_SYMBOL = {value: key for key, value in SYMBOL_BY_NUMBER.items()} + + +class CanteraWriter2(object): + """ + This class listens to a RMG subject and writes a Cantera YAML file + with the current state of the RMG model at every iteration. + """ + + def __init__(self, output_directory='', config=None): + self.output_directory = output_directory + self.config = config + make_output_subdirectory(output_directory, 'cantera2') + + def update(self, rmg): + """ + Called whenever the RMG subject notifies listeners. + """ + if self.config is not None and not self.config.should_write( + rmg.reaction_model.iteration_num, rmg.is_final_save): + return + save_cantera_files(rmg, config=self.config) + + +def save_cantera_files(rmg, config=None): + """ + Save the current reaction model to a set of Cantera YAML files. + + Creates: + 1. chem{N}.yaml (where N is num species) + 2. chem.yaml (latest copy) + 3. chem_annotated.yaml (if verbose_comments is True) + """ + verbose = config.verbose_comments if (config and config.verbose_comments is not None) else rmg.verbose_comments + save_edge = config.save_edge if (config and config.save_edge is not None) else rmg.save_edge_species + + # Ensure subdirectory exists + cantera_dir = os.path.join(rmg.output_directory, 'cantera2') + if not os.path.exists(cantera_dir): + os.mkdir(cantera_dir) + + try: + site_density = rmg.surface_site_density.value_si + except (AttributeError, KeyError, TypeError): + site_density = None + + # ------------------------------------------------------------------------- + # 1. Save Core Model + # ------------------------------------------------------------------------- + num_species = len(rmg.reaction_model.core.species) + + # Define paths + this_cantera_path = os.path.join(cantera_dir, + 'chem{0:04d}.yaml'.format(num_species)) + latest_cantera_path = os.path.join(cantera_dir, 'chem.yaml') + + logging.info(f"Saving current model core to Cantera file: {this_cantera_path}") + + # Write the YAML file (non-verbose) + save_cantera_model(rmg.reaction_model.core, this_cantera_path, site_density=site_density, + verbose=False) + + # Copy to 'chem.yaml' (The latest file) + if os.path.exists(latest_cantera_path): + os.unlink(latest_cantera_path) + shutil.copy2(this_cantera_path, latest_cantera_path) + + # Write annotated file if verbose_comments is requested + if verbose: + annotated_path = os.path.join(cantera_dir, 'chem_annotated.yaml') + logging.info(f"Saving annotated Cantera file: {annotated_path}") + save_cantera_model(rmg.reaction_model.core, annotated_path, site_density=site_density, + verbose=True) + + # ------------------------------------------------------------------------- + # 2. Save Edge Model (Optional, matching ChemkinWriter logic) + # ------------------------------------------------------------------------- + if save_edge: + logging.info('Saving current model core and edge to Cantera file...') + + this_edge_path = os.path.join(cantera_dir, + 'chem_edge{0:04d}.yaml'.format(num_species)) + latest_edge_path = os.path.join(cantera_dir, 'chem_edge.yaml') + + # Create a simple container object to pass to save_cantera_model + class MixedModel: + def __init__(self, species, reactions): + self.species = species + self.reactions = reactions + + edge_model = MixedModel( + rmg.reaction_model.core.species + rmg.reaction_model.edge.species, + rmg.reaction_model.core.reactions + rmg.reaction_model.edge.reactions + ) + + save_cantera_model(edge_model, this_edge_path, site_density=site_density, verbose=False) + + if os.path.exists(latest_edge_path): + os.unlink(latest_edge_path) + shutil.copy2(this_edge_path, latest_edge_path) + + if verbose: + annotated_edge_path = os.path.join(cantera_dir, 'chem_edge_annotated.yaml') + logging.info(f"Saving annotated edge Cantera file: {annotated_edge_path}") + save_cantera_model(edge_model, annotated_edge_path, site_density=site_density, + verbose=True) + + +def save_cantera_model(model_container, path, site_density=None, verbose=False): + """ + Internal helper to generate the dictionary and write the YAML file. + model_container must have .species and .reactions attributes (lists). + If verbose=True, species/reaction notes (SMILES, source, kinetics + comments) are included in the output. + """ + species_list = model_container.species + reaction_list = model_container.reactions + + is_plasma = False + for sp in species_list: + if sp.is_electron(): + is_plasma = True + break + + # Generate Data + yaml_data = generate_cantera_data(species_list, reaction_list, is_plasma=is_plasma, + site_density=site_density, verbose=verbose) + + # Write + with open(path, 'w') as f: + # sort_keys=False ensures 'units' comes first, then 'phases', etc. + yaml.dump(yaml_data, f, Dumper=Dumper, sort_keys=False, default_flow_style=None) + + +def generate_cantera_data(species_list, + reaction_list, + is_plasma=False, + site_density=None, + search_for_additional_elements=False, + verbose=False, + ): + """ + Converts RMG objects into a dictionary structure compatible with Cantera YAML. + If verbose=True, species/reaction notes are included (SMILES, source, kinetics comments). + """ + # --- 1. Header & Units --- + # We output everything in SI units. + try: + from rmgpy.rmg.main import RMG + git_head, _ = RMG.get_git_commit(None, os.path.dirname(__file__)) + git_head = " (git commit: {0})".format(git_head[:7]) + except Exception: + git_head = '' + + data = { + 'description': 'RMG-Py Generated Mechanism', + 'generator': f'RMG-Py CanteraWriter2 at {__file__}{git_head}', + 'cantera-version': '3.1', + 'units': { + 'length': 'm', + 'time': 's', + 'quantity': 'mol', + 'activation-energy': 'J/mol' + } + } + + # Sort species list by index + sorted_species = sorted(species_list, key=lambda species: species.index) + + # --- 2. Phase Segregation (Gas vs Surface) --- + gas_species, surface_species, gas_reactions, surface_reactions = list(), list(), list(), list() + + for spc in sorted_species: + if spc.contains_surface_site(): + surface_species.append(spc) + else: + gas_species.append(spc) + + for rxn in reaction_list: + if rxn.is_surface_reaction(): + surface_reactions.append(rxn) + else: + gas_reactions.append(rxn) + + # --- 3. Phase Definitions --- + base_elements = ['H', 'C', 'O', 'N', 'Ne', 'Ar', 'He', 'Si', 'S', 'F', 'Cl', 'Br', 'I', 'E'] + elements_set = set(base_elements) + + if search_for_additional_elements: + for spc in sorted_species: + if spc.molecule and len(spc.molecule) > 0: + if spc.is_electron(): + elements_set.add('E') + is_plasma = True + else: + for elem in spc.molecule[0].get_element_count().keys(): + if elem != 'X': + elements_set.add(elem) + + phases = list() + + gas_phase_def = { + 'name': 'gas', + 'thermo': 'plasma' if is_plasma else 'ideal-gas', + 'elements': sorted(list(elements_set)), + 'species': [get_label(spc, species_list) for spc in gas_species], + 'kinetics': 'gas', + 'reactions': 'declared-species', + } + + if is_plasma: + gas_phase_def['transport'] = 'ionized-gas' + # Plasma specific defaults + gas_phase_def['electron-energy-distribution'] = { + 'type': 'isotropic', + 'shape-factor': 2.0, + 'mean-electron-energy': 1.0 + } + else: + gas_phase_def['transport'] = 'mixture-averaged' + + phases.append(gas_phase_def) + + if surface_species: + default_site_density = 2.5e-5 # mol/m^2 + + has_coverage_dependence = any( + hasattr(sp.thermo, 'thermo_coverage_dependence') and sp.thermo.thermo_coverage_dependence + for sp in surface_species + ) + + surface_phase_def = { + 'name': 'surface', + 'thermo': 'coverage-dependent-surface' if has_coverage_dependence else 'ideal-surface', + 'adjacent-phases': ['gas'], + 'elements': sorted(list(elements_set)), + 'species': [get_label(sp, species_list) for sp in surface_species], + 'kinetics': 'surface', + 'reactions': 'declared-species', + 'site-density': site_density or default_site_density + } + if has_coverage_dependence: + surface_phase_def['reference-state-coverage'] = 0.11 + phases.append(surface_phase_def) + + data['phases'] = phases + + species_data = list() + for sp in species_list: + species_data.append(species_to_dict(sp, species_list, verbose=verbose)) + data['species'] = species_data + + reaction_data = list() + for rxn in gas_reactions: + entries = reaction_to_dict_list(rxn, species_list, verbose=verbose) + if entries: + reaction_data.extend(entries) + for rxn in surface_reactions: + entries = reaction_to_dict_list(rxn, species_list, verbose=verbose) + if entries: + reaction_data.extend(entries) + data['reactions'] = reaction_data + + return data + + +def species_to_dict(species, species_list, verbose=False): + """Convert an RMG Species object to a Cantera YAML dictionary. + If verbose=True, species notes (SMILES, thermo/transport comments) are included. + """ + + notes = list() + if verbose: + try: + notes.append(species.to_smiles()) + except: + pass + + # Composition + mol = species.molecule[0] + atom_dict = dict(mol.get_element_count()) + + # Number of electrons 'E' + # The special pseudo-element E is used in representing charged species, where it specifies + # the net number of electrons compared to the number needed to form a neutral species. + # That is, negatively charged ions will have E > 0, while positively charged ions will have E < 0. + # https://cantera.org/3.1/userguide/creating-mechanisms.html#elemental-composition + charge = mol.get_net_charge() + if 'E' not in atom_dict and charge != 0: + atom_dict['E'] = -charge + + # Sort composition by atomic number + atom_dict = {k: atom_dict[k] for k in sorted(atom_dict.keys(), key=lambda x: NUMBER_BY_SYMBOL.get(x, 999))} + + # Thermo (NASA7) + thermo_data = species.get_thermo_data() + + # Sort polynomials by Tmin + sorted_polys = sorted(thermo_data.polynomials, key=lambda p: p.Tmin.value_si) + + polys = [] + for poly in sorted_polys: + polys.append({ + 'T-range': [poly.Tmin.value_si, poly.Tmax.value_si], + 'data': poly.coeffs.tolist() # a0..a6 + }) + + # Build the base dictionary + species_entry = { + 'name': get_label(species, species_list), + 'composition': atom_dict, + 'thermo': { + 'model': 'NASA7', + 'temperature-ranges': [sorted_polys[0].Tmin.value_si, sorted_polys[0].Tmax.value_si, + sorted_polys[1].Tmax.value_si], + 'data': [polys[0]['data'], polys[1]['data']] + }, + } + + # Transport (if available) - Only relevant for gas phase usually + if species.transport_data and not species.contains_surface_site(): + td = species.transport_data + + transport_dict = { + 'model': 'gas', + 'geometry': 'atom' if td.shapeIndex == 0 else 'linear' if td.shapeIndex == 1 else 'nonlinear', + 'well-depth': td.epsilon.value_si / constants.R, # Kelvin + 'diameter': td.sigma.value_si * 1e10, # Angstroms + } + if td.dipoleMoment and td.dipoleMoment.value_si != 0.0: + transport_dict['dipole'] = td.dipoleMoment.value_si * 1e21 * constants.c # Debye + if getattr(td, 'polarizability', None) and td.polarizability.value_si != 0.0: + transport_dict['polarizability'] = td.polarizability.value_si * 1e30 # Angstrom^3 + if getattr(td, 'rotrelaxcollnum', None) and td.rotrelaxcollnum != 0.0: + transport_dict['rotational-relaxation'] = td.rotrelaxcollnum + if verbose and td.comment: + transport_dict['note'] = td.comment.strip() + species_entry['transport'] = transport_dict + + if verbose and species.thermo and species.thermo.comment: + clean_comment = species.thermo.comment.replace('\n', '; ').strip() + species_entry['thermo']['note'] = clean_comment + + if notes: + species_entry['note'] = " | ".join(notes) + + # Add coverage-dependencies if this surface species has coverage-dependent thermo + if (species.contains_surface_site() and + hasattr(thermo_data, 'thermo_coverage_dependence') and + thermo_data.thermo_coverage_dependence): + from rmgpy.molecule.molecule import Molecule + cov_deps = {} + for adj_list, parameters in thermo_data.thermo_coverage_dependence.items(): + mol = Molecule().from_adjacency_list(adj_list) + for sp in species_list: + if sp.is_isomorphic(mol, strict=False): + dep_label = get_label(sp, species_list) + if dep_label: + cov_deps[dep_label] = { + 'units': {'energy': 'J', 'quantity': 'mol'}, + 'enthalpy-coefficients': [v.value_si for v in parameters['enthalpy-coefficients']], + 'entropy-coefficients': [v.value_si for v in parameters['entropy-coefficients']], + } + break + if cov_deps: + species_entry['coverage-dependencies'] = cov_deps + + return species_entry + + +def reaction_to_dict_list(reaction, species_list=None, verbose=False): + """ + Convert an RMG Reaction object to a LIST of Cantera YAML dictionaries. + If verbose=True, a 'note' field is added with source and kinetics comment. + """ + # Check for MultiKinetics (duplicates grouped in one RMG object) + if isinstance(reaction.kinetics, (MultiArrhenius, MultiPDepArrhenius)): + entries = [] + sub_kinetics_list = reaction.kinetics.arrhenius + + for sub_kin in sub_kinetics_list: + sub_rxn = Reaction( + reactants=reaction.reactants, + products=reaction.products, + reversible=reaction.reversible, + kinetics=sub_kin, + duplicate=True + ) + sub_result = reaction_to_dict_list(sub_rxn, species_list, verbose=verbose) + if sub_result: + entries.extend(sub_result) + return entries + + kin = reaction.kinetics + + # Generate equation string + equation = get_reaction_equation(reaction, species_list) + entry = {'equation': equation} + + if reaction.duplicate: + entry['duplicate'] = True + + # --- Kinetics Serialization --- + + # 1. Surface Kinetics + if isinstance(kin, StickingCoefficient): + entry['type'] = 'sticking-Arrhenius' + entry['sticking-coefficient'] = {'A': kin.A.value_si, 'b': kin.n.value_si, 'Ea': kin.Ea.value_si} + + elif isinstance(kin, SurfaceArrhenius): + entry['type'] = 'interface-Arrhenius' + entry['rate-constant'] = {'A': kin.A.value_si, 'b': kin.n.value_si, 'Ea': kin.Ea.value_si} + + # 2. Gas Kinetics + elif isinstance(kin, Arrhenius): + entry['rate-constant'] = {'A': kin.A.value_si, 'b': kin.n.value_si, 'Ea': kin.Ea.value_si} + + elif isinstance(kin, Chebyshev): + entry['type'] = 'Chebyshev' + entry['temperature-range'] = [kin.Tmin.value_si, kin.Tmax.value_si] + entry['pressure-range'] = [kin.Pmin.value_si, kin.Pmax.value_si] + entry['data'] = kin.coeffs.value_si.tolist() + + elif isinstance(kin, ThirdBody): + entry['type'] = 'three-body' + entry['rate-constant'] = { + 'A': kin.arrheniusLow.A.value_si, + 'b': kin.arrheniusLow.n.value_si, + 'Ea': kin.arrheniusLow.Ea.value_si + } + entry['efficiencies'] = {lbl: v for m, v in kin.efficiencies.items() if + (lbl := get_label(m, species_list)) is not None} + + elif isinstance(kin, Troe): + entry['type'] = 'falloff' + entry['high-P-rate-constant'] = { + 'A': kin.arrheniusHigh.A.value_si, + 'b': kin.arrheniusHigh.n.value_si, + 'Ea': kin.arrheniusHigh.Ea.value_si + } + entry['low-P-rate-constant'] = { + 'A': kin.arrheniusLow.A.value_si, + 'b': kin.arrheniusLow.n.value_si, + 'Ea': kin.arrheniusLow.Ea.value_si + } + troe_p = {'A': kin.alpha, 'T3': kin.T3.value_si, 'T1': kin.T1.value_si} + if kin.T2: + troe_p['T2'] = kin.T2.value_si + entry['Troe'] = troe_p + entry['efficiencies'] = {lbl: v for m, v in kin.efficiencies.items() if + (lbl := get_label(m, species_list)) is not None} + + elif isinstance(kin, Lindemann): + entry['type'] = 'falloff' + entry['high-P-rate-constant'] = { + 'A': kin.arrheniusHigh.A.value_si, + 'b': kin.arrheniusHigh.n.value_si, + 'Ea': kin.arrheniusHigh.Ea.value_si + } + entry['low-P-rate-constant'] = { + 'A': kin.arrheniusLow.A.value_si, + 'b': kin.arrheniusLow.n.value_si, + 'Ea': kin.arrheniusLow.Ea.value_si + } + entry['efficiencies'] = {lbl: v for m, v in kin.efficiencies.items() if + (lbl := get_label(m, species_list)) is not None} + + elif isinstance(kin, PDepArrhenius): + # A MultiArrhenius entry comes from a chemkin PLOG block with duplicate + # pressures; expand it into one rate-constants entry per inner Arrhenius + # at the shared pressure. Cantera's pressure-dependent-Arrhenius sums + # duplicate-pressure entries at evaluation, matching chemkin semantics. + # Splitting into separate `duplicate: true` reactions would be wrong: + # that interpolates each component independently, then sums, which + # gives different rates at intermediate pressures. + entry['type'] = 'pressure-dependent-Arrhenius' + rates = [] + for P, arr in zip(kin.pressures.value_si, kin.arrhenius): + sub_arrhenius = arr.arrhenius if isinstance(arr, MultiArrhenius) else [arr] + for sub in sub_arrhenius: + rates.append({ + 'P': float(P), + 'A': sub.A.value_si, + 'b': sub.n.value_si, + 'Ea': sub.Ea.value_si + }) + entry['rate-constants'] = rates + + else: + logging.warning(f"Skipping reaction {equation}: Unknown kinetics type {type(kin)}") + return [] + + # --- Coverage Dependencies --- + if hasattr(kin, 'coverage_dependence') and kin.coverage_dependence: + cov_deps = {} + for sp, cov_params in kin.coverage_dependence.items(): + sp_label = get_label(sp, species_list) + if sp_label: + # Cantera YAML expects { a: ..., m: ..., E: ... } + cov_deps[sp_label] = { + 'a': cov_params['a'].value_si, + 'm': cov_params['m'].value_si, + 'E': cov_params['E'].value_si + } + if cov_deps: + entry['coverage-dependencies'] = cov_deps + + # --- Metadata / Notes (only when verbose) --- + if verbose: + note_parts = list() + if isinstance(reaction, TemplateReaction): + note_parts.append(f"Source: Template family {reaction.family}") + elif isinstance(reaction, LibraryReaction): + note_parts.append(f"Source: Library {reaction.library}") + elif isinstance(reaction, PDepReaction): + note_parts.append(f"Source: PDep Network #{reaction.network.index}") + + if hasattr(kin, 'comment') and kin.comment: + clean_comment = kin.comment.replace('\n', '; ').strip() + if clean_comment: + note_parts.append(clean_comment) + + if reaction.specific_collider: + note_parts.append(f"Specific collider: {reaction.specific_collider.label}") + + if note_parts: + entry['note'] = " | ".join(note_parts) + + return [entry] + + +def get_reaction_equation(reaction, species_list): + """Helper to build reaction string""" + reactants_str = " + ".join([get_label(r, species_list) for r in reaction.reactants]) + products_str = " + ".join([get_label(p, species_list) for p in reaction.products]) + + suffix = "" + kin = reaction.kinetics + if isinstance(kin, (ThirdBody, Lindemann, Troe)): + if hasattr(reaction, 'specific_collider') and reaction.specific_collider: + suffix = " + " + get_label(reaction.specific_collider, species_list) + else: + suffix = " (+ M)" + + return reactants_str + suffix + " <=> " + products_str + suffix + + +def get_label(obj: Union['Species', 'Molecule'], species_list: list['Species']): + if isinstance(obj, Species): + return f'{obj.label}({obj.index})' if obj.index > 0 else obj.label + + if species_list: + for sp in species_list: + if sp.is_isomorphic(obj): + return f'{sp.label}({sp.index})' if sp.index > 0 else sp.label + return None diff --git a/rmgpy/yml.py b/rmgpy/yaml_rms.py similarity index 95% rename from rmgpy/yml.py rename to rmgpy/yaml_rms.py index 8b6e9f771f4..4132b0ae053 100644 --- a/rmgpy/yml.py +++ b/rmgpy/yaml_rms.py @@ -33,6 +33,10 @@ """ import os +try: + from yaml import CDumper as Dumper +except ImportError: + from yaml import Dumper import yaml import logging @@ -49,7 +53,7 @@ from rmgpy.util import make_output_subdirectory -def convert_chemkin_to_yml(chemkin_path, dictionary_path=None, output="chem.rms"): +def convert_chemkin_to_rms(chemkin_path, dictionary_path=None, output="chem.rms"): if dictionary_path: spcs, rxns = load_chemkin_file(chemkin_path, dictionary_path=dictionary_path) else: @@ -57,10 +61,10 @@ def convert_chemkin_to_yml(chemkin_path, dictionary_path=None, output="chem.rms" write_yml(spcs, rxns, path=output) -def write_yml(spcs, rxns, solvent=None, solvent_data=None, path="chem.yml"): +def write_rms(spcs, rxns, solvent=None, solvent_data=None, path="chem.rms"): result_dict = get_mech_dict(spcs, rxns, solvent=solvent, solvent_data=solvent_data) with open(path, 'w') as f: - yaml.dump(result_dict, stream=f) + yaml.dump(result_dict, stream=f, Dumper=Dumper, sort_keys=False) def get_mech_dict(spcs, rxns, solvent='solvent', solvent_data=None): @@ -270,14 +274,18 @@ class RMSWriter(object): rmg.detach(listener) """ - def __init__(self, output_directory=''): + def __init__(self, output_directory='', config=None): super(RMSWriter, self).__init__() self.output_directory = output_directory + self.config = config make_output_subdirectory(output_directory, 'rms') def update(self, rmg): + if self.config is not None and not self.config.should_write( + rmg.reaction_model.iteration_num, rmg.is_final_save): + return solvent_data = None if rmg.solvent: solvent_data = rmg.database.solvation.get_solvent_data(rmg.solvent) - write_yml(rmg.reaction_model.core.species, rmg.reaction_model.core.reactions, solvent=rmg.solvent, solvent_data=solvent_data, + write_rms(rmg.reaction_model.core.species, rmg.reaction_model.core.reactions, solvent=rmg.solvent, solvent_data=solvent_data, path=os.path.join(self.output_directory, 'rms', 'chem{}.rms').format(len(rmg.reaction_model.core.species))) diff --git a/scripts/rmg2to3.py b/scripts/rmg2to3.py index 211dbfdfac7..99517351a09 100644 --- a/scripts/rmg2to3.py +++ b/scripts/rmg2to3.py @@ -1062,7 +1062,7 @@ 'processToSpeciesNetworks': 'process_to_species_networks', 'processPdepNetworks': 'process_pdep_networks', 'processReactionsToSpecies': 'process_reactions_to_species', - 'generateCanteraFiles': 'generate_cantera_files', + 'generateCanteraFiles': 'generate_cantera_files_from_chemkin', 'initializeReactionThresholdAndReactFlags': 'initialize_reaction_threshold_and_react_flags', 'updateReactionThresholdAndReactFlags': 'update_reaction_threshold_and_react_flags', 'saveEverything': 'save_everything', diff --git a/test/rmgpy/rmg/inputTest.py b/test/rmgpy/rmg/inputTest.py index f9b083822aa..b0fe108b675 100644 --- a/test/rmgpy/rmg/inputTest.py +++ b/test/rmgpy/rmg/inputTest.py @@ -31,8 +31,10 @@ import rmgpy.rmg.input as inp from rmgpy.exceptions import InputError +from rmgpy.rmg.input import _parse_writer_config, _writer_config_to_input from rmgpy.rmg.main import RMG from rmgpy.rmg.model import CoreEdgeReactionModel +from rmgpy.rmg.settings import WriterConfig from rmgpy.ml.estimator import ADMONITION import pytest @@ -538,3 +540,95 @@ def test_completed_networks_none(self): # Check that no networks were added assert len(rmg.reaction_model.completed_pdep_networks) == 0 + + +class TestWriterConfig: + """Unit tests for WriterConfig and the _parse_writer_config / _writer_config_to_input helpers.""" + + def test_parse_false_disables(self): + cfg = _parse_writer_config(False) + assert not cfg.enabled + assert cfg.save_interval == 0 + + def test_parse_true_enables_default_interval(self): + cfg = _parse_writer_config(True) + assert cfg.enabled + assert cfg.save_interval == 1 + assert cfg.verbose_comments is None + assert cfg.save_edge is None + + def test_parse_true_custom_default_interval(self): + cfg = _parse_writer_config(True, default_save_interval=5) + assert cfg.save_interval == 5 + + def test_parse_dict_full(self): + cfg = _parse_writer_config({'saveInterval': -1, 'verboseComments': True, 'saveEdge': False}) + assert cfg.enabled + assert cfg.save_interval == -1 + assert cfg.verbose_comments is True + assert cfg.save_edge is False + + def test_parse_dict_partial(self): + cfg = _parse_writer_config({'saveInterval': 3}) + assert cfg.save_interval == 3 + assert cfg.verbose_comments is None + assert cfg.save_edge is None + + def test_parse_invalid_raises(self): + with pytest.raises(InputError): + _parse_writer_config(42) + + def test_should_write_every_iteration(self): + cfg = WriterConfig(save_interval=1) + assert cfg.should_write(0, False) + assert cfg.should_write(1, False) + assert cfg.should_write(5, False) + + def test_should_write_every_n_iterations(self): + cfg = WriterConfig(save_interval=3) + assert cfg.should_write(0, False) + assert not cfg.should_write(1, False) + assert not cfg.should_write(2, False) + assert cfg.should_write(3, False) + assert cfg.should_write(6, False) + + def test_should_write_end_only(self): + cfg = WriterConfig(save_interval=-1) + assert not cfg.should_write(0, False) + assert not cfg.should_write(5, False) + assert cfg.should_write(5, True) + + def test_should_write_disabled(self): + cfg = WriterConfig(save_interval=0) + assert not cfg.should_write(0, False) + assert not cfg.should_write(0, True) + + def test_should_write_final_always_writes(self): + cfg = WriterConfig(save_interval=5) + # Iteration 7 was not written (not multiple of 5) + assert cfg.should_write(7, True) + + def test_should_write_final_no_double_write(self): + cfg = WriterConfig(save_interval=5) + # Iteration 5 is a multiple of 5 — written during loop + cfg.should_write(5, False) + # Final call at same iteration should be skipped + assert not cfg.should_write(5, True) + + def test_writer_config_to_input_false(self): + cfg = WriterConfig(save_interval=0) + assert _writer_config_to_input(cfg) is False + + def test_writer_config_to_input_true(self): + cfg = WriterConfig(save_interval=1) + assert _writer_config_to_input(cfg) is True + + def test_writer_config_to_input_dict(self): + cfg = WriterConfig(save_interval=-1, verbose_comments=True, save_edge=False) + result = _writer_config_to_input(cfg) + assert "'saveInterval': -1" in result + assert "'verboseComments': True" in result + assert "'saveEdge': False" in result + + def test_writer_config_to_input_none(self): + assert _writer_config_to_input(None) is False diff --git a/test/rmgpy/rmg/mainTest.py b/test/rmgpy/rmg/mainTest.py index fdca40c6808..bb5df4bdd80 100644 --- a/test/rmgpy/rmg/mainTest.py +++ b/test/rmgpy/rmg/mainTest.py @@ -55,7 +55,10 @@ def setup_class(cls): cls.seedKinetics = os.path.join(cls.databaseDirectory, "kinetics", "libraries", "testSeed") cls.seedKineticsEdge = os.path.join(cls.databaseDirectory, "kinetics", "libraries", "testSeed_edge") - os.makedirs(os.path.join(cls.testDir, cls.outputDir), exist_ok=True) + output_path = os.path.join(cls.testDir, cls.outputDir) + if os.path.exists(output_path): + shutil.rmtree(output_path) + os.mkdir(output_path) cls.rmg = RMG( input_file=os.path.join(cls.testDir, "input.py"), @@ -172,21 +175,79 @@ def test_rmg_memory(self): Rmem.generate_cond() Rmem.get_cond() - def test_make_cantera_input_file(self): + def test_make_cantera_input_file_from_ck(self): + """ + This test ensures that a usable Cantera input file is created via the Chemkin to Cantera conversion. + """ + import cantera as ct + + cantera_files = os.path.join(self.rmg.output_directory, "cantera_from_ck") + files = os.listdir(cantera_files) + for f in files: + if ".yaml" in f: + try: + ct.Solution(os.path.join(cantera_files, f)) + except: + assert False, "The output Cantera file is not loadable in Cantera." + + def test_make_cantera_input_file_directly_1(self): """ - This test ensures that a usable Cantera input file is created. + This tests to ensure that a usable Cantera input file is created via direct yaml writer 1. """ import cantera as ct - outName = os.path.join(self.rmg.output_directory, "cantera") - files = os.listdir(outName) + cantera_files = os.path.join(self.rmg.output_directory, "cantera1") + files = os.listdir(cantera_files) for f in files: if ".yaml" in f: try: - ct.Solution(os.path.join(outName, f)) + ct.Solution(os.path.join(cantera_files, f)) except: assert False, "The output Cantera file is not loadable in Cantera." + def test_make_cantera_input_file_directly_2(self): + """ + This tests to ensure that a usable Cantera input file is created via direct yaml writer 2. + """ + import cantera as ct + + cantera_files = os.path.join(self.rmg.output_directory, "cantera2") + files = os.listdir(cantera_files) + for f in files: + if ".yaml" in f: + try: + ct.Solution(os.path.join(cantera_files, f)) + except: + assert False, "The output Cantera file is not loadable in Cantera." + + def test_cantera_input_files_match_chemkin_later(self): + """ + Copy the Cantera YAML files (generated directly by RMG and converted from Chemkin) + to the test data directory so that yaml_cantera1Test can compare them. + """ + # Copy RMG-generated YAML 1 to test data directory + cantera_dir = os.path.join(self.rmg.output_directory, "cantera1") + rmg_yaml_path = os.path.join(cantera_dir, 'chem_annotated.yaml') + assert os.path.exists(rmg_yaml_path), f"RMG-generated Cantera YAML file {rmg_yaml_path} not found" + test_data_cantera_target = os.path.join(self.testDir, '..', 'yaml_writer_data', 'cantera1', 'from_main_test.yaml') + shutil.copy(rmg_yaml_path, test_data_cantera_target) + + # Copy RMG-generated YAML 2 to test data directory + cantera_dir = os.path.join(self.rmg.output_directory, "cantera2") + rmg_yaml_path = os.path.join(cantera_dir, 'chem_annotated.yaml') + assert os.path.exists(rmg_yaml_path), f"RMG-generated Cantera YAML file {rmg_yaml_path} not found" + test_data_cantera_target = os.path.join(self.testDir, '..', 'yaml_writer_data', 'cantera2', 'from_main_test.yaml') + shutil.copy(rmg_yaml_path, test_data_cantera_target) + + # Copy chemkin-converted YAML to test data directory + cantera_from_ck_dir = os.path.join( + self.rmg.output_directory, "cantera_from_ck" + ) + ck_yaml_path = os.path.join(cantera_from_ck_dir, "chem_annotated.yaml") + assert os.path.exists(ck_yaml_path), f"Chemkin-converted YAML file {ck_yaml_path} not found" + test_data_chemkin_target = os.path.join(self.testDir, '..', 'yaml_writer_data', 'ck2yaml', 'from_main_test.yaml') + shutil.copy(ck_yaml_path, test_data_chemkin_target) + @pytest.mark.functional class TestRestartWithFilters: @@ -302,7 +363,7 @@ def test_max_iter(self): num_rows = df.shape[0] num_iter_actual = num_rows - num_iter_expected = self.max_iter + 1 # +1 is for saving iteration 0 + num_iter_expected = self.max_iter + 2 # +2 is for saving iteration 0, and the final after the loop ends. assert num_iter_actual == num_iter_expected @classmethod @@ -360,3 +421,172 @@ def teardown_class(cls): os.remove(os.path.join(cls.test_dir, "RMG.profile.dot")) os.remove(os.path.join(cls.test_dir, "RMG.profile.dot.ps2")) + +class TestCanteraOutputConversion: + """ + Tests if we can convert Chemkin files to Cantera files without crashing. + (Or raising an exception for bad files.) + """ + def setup_class(self): + self.chemkin_files = { + """ELEMENTS + H + D /2.014/ + T /3.016/ + C + CI /13.003/ + O + OI /18.000/ + N + +END + +SPECIES + ethane(1) + CH3(4) +END + +THERM ALL + 300.000 1000.000 5000.000 + +ethane(1) H 6 C 2 G100.000 5000.000 954.52 1 + 4.58987205E+00 1.41507042E-02-4.75958084E-06 8.60284590E-10-6.21708569E-14 2 +-1.27217823E+04-3.61762003E+00 3.78032308E+00-3.24248354E-03 5.52375224E-05 3 +-6.38573917E-08 2.28633835E-11-1.16203404E+04 5.21037799E+00 4 + +CH3(4) H 3 C 1 G100.000 5000.000 1337.62 1 + 3.54144859E+00 4.76788187E-03-1.82149144E-06 3.28878182E-10-2.22546856E-14 2 + 1.62239622E+04 1.66040083E+00 3.91546822E+00 1.84153688E-03 3.48743616E-06 3 +-3.32749553E-09 8.49963443E-13 1.62856393E+04 3.51739246E-01 4 + +END + + + +REACTIONS KCAL/MOLE MOLES + +CH3(4)+CH3(4)=ethane(1) 8.260e+17 -1.400 1.000 + +END +""": True, + """ELEMENTS + CI /13.003/ + O + OI /18.000/ + N + +END + +SPECIES + ethane(1) + CH3(4) +END + +THERM ALL + 300.000 1000.000 5000.000 + +ethane(1) H 6 C 2 G100.000 5000.000 954.52 1 + 4.58987205E+00 1.41507042E-02-4.75958084E-06 8.60284590E-10-6.21708569E-14 2 +-1.27217823E+04-3.61762003E+00 3.78032308E+00-3.24248354E-03 5.52375224E-05 3 +-6.38573917E-08 2.28633835E-11-1.16203404E+04 5.21037799E+00 4 + +CH3(4) H 3 C 1 G100.000 5000.000 1337.62 1 + 3.54144859E+00 4.76788187E-03-1.82149144E-06 3.28878182E-10-2.22546856E-14 2 + 1.62239622E+04 1.66040083E+00 3.91546822E+00 1.84153688E-03 3.48743616E-06 3 +-3.32749553E-09 8.49963443E-13 1.62856393E+04 3.51739246E-01 4 + +END + + + +REACTIONS KCAL/MOLE MOLES + +CH3(4)+CH3(4)=ethane(1) 8.260e+17 -1.400 1.000 + +END +""": False, + """ELEMENTS + H + D /2.014/ + T /3.016/ + C + CI /13.003/ + O + OI /18.000/ + N + +END + +SPECIES + ethane(1) + CH3(4) +END + +THERM ALL + 300.000 1000.000 5000.000 + +ethane(1) H 6 C 2 G100.000 5000.000 954.52 1 + 4.58987205E+00 1.41507042E-02-4.75958084E-06 8.60284590E-10-6.21708569E-14 2 +-1.27217823E+04-3.61762003E+00 3.78032308E+00-3.24248354E-03 5.52375224E-05 3 +-6.38573917E-08 2.28633835E-11-1.16203404E+04 5.21037799E+00 4 + +END + +REACTIONS KCAL/MOLE MOLES + +CH3(4)+CH3(4)=ethane(1) 8.260e+17 -1.400 1.000 + +END +""": False, + } + self.rmg = RMG() + self.dir_name = "temp_dir_for_testing" + self.rmg.output_directory = os.path.join(originalPath, "..", "test", "rmgpy", "test_data", self.dir_name) + + self.tran_dat = """ +! Species Shape LJ-depth LJ-diam DiplMom Polzblty RotRelaxNum Data +! Name Index epsilon/k_B sigma mu alpha Zrot Source +ethane(1) 2 252.301 4.302 0.000 0.000 1.500 ! GRI-Mech +CH3(4) 2 144.001 3.800 0.000 0.000 0.000 ! GRI-Mech + """ + + def teardown_class(self): + os.chdir(originalPath) + # try to remove the tree. If testChemkinToCanteraConversion properly + # ran, the files should already be removed. + try: + shutil.rmtree(self.dir_name) + except OSError: + pass + # go back to the main RMG-Py directory + os.chdir("..") + + def test_chemkin_to_cantera_conversion(self): + """ + Tests that good and bad chemkin files raise proper exceptions + """ + + from cantera.ck2yaml import InputError + + for ck_input, works in self.chemkin_files.items(): + os.chdir(originalPath) + os.mkdir(self.dir_name) + os.chdir(self.dir_name) + + f = open("chem001.inp", "w") + f.write(ck_input) + f.close() + + f = open("tran.dat", "w") + f.write(self.tran_dat) + f.close() + + if works: + self.rmg.generate_cantera_files_from_chemkin(os.path.join(os.getcwd(), "chem001.inp")) + else: + with pytest.raises(InputError): + self.rmg.generate_cantera_files_from_chemkin(os.path.join(os.getcwd(), "chem001.inp")) + + # clean up + os.chdir(originalPath) + shutil.rmtree(self.dir_name) diff --git a/test/rmgpy/rmg/rmgTest.py b/test/rmgpy/rmg/rmgTest.py index 26686ae2c18..1fab407c8ee 100644 --- a/test/rmgpy/rmg/rmgTest.py +++ b/test/rmgpy/rmg/rmgTest.py @@ -206,7 +206,7 @@ def test_parse_command_line_arguments_defaults(self): args = parse_command_line_arguments(["input.py"]) # Test default values - assert args.walltime == "00:00:00:00" + assert args.walltime is None assert args.output_directory == os.path.abspath(os.path.dirname("./")) assert args.debug == False assert args.file == "input.py" diff --git a/test/rmgpy/test_data/mainTest/input.py b/test/rmgpy/test_data/mainTest/input.py index 42b34c0f739..dc87419de19 100644 --- a/test/rmgpy/test_data/mainTest/input.py +++ b/test/rmgpy/test_data/mainTest/input.py @@ -77,8 +77,17 @@ generateOutputHTML=False, generatePlots=False, saveEdgeSpecies=False, + verboseComments=True, saveSimulationProfiles=False, + generateCanteraYAML1=True, + generateCanteraYAML2=True, + generateRMSYAML=True, + generateChemkin=True, ) -generatedSpeciesConstraints(allowed=['seed mechanisms','reaction libraries'], -maximumRadicalElectrons=3,maximumCarbeneRadicals=3,maximumSingletCarbenes=3) +generatedSpeciesConstraints( + allowed=['seed mechanisms','reaction libraries'], + maximumRadicalElectrons=3, + maximumCarbeneRadicals=3, + maximumSingletCarbenes=3 +) diff --git a/test/rmgpy/test_data/yaml_writer_data/cantera1/from_main_test.yaml b/test/rmgpy/test_data/yaml_writer_data/cantera1/from_main_test.yaml new file mode 100644 index 00000000000..58ec229ab9d --- /dev/null +++ b/test/rmgpy/test_data/yaml_writer_data/cantera1/from_main_test.yaml @@ -0,0 +1,1329 @@ +generator: "RMG-Py CanteraWriter1 at /Users/rwest/Code/RMG-Py/rmgpy/yaml_cantera1.py (git commit: 1568184)" +date: Sun, 03 May 2026 22:13:40 + +units: {length: m, time: s, quantity: kmol, activation-energy: J/kmol} + + +phases: +- name: gas + thermo: ideal-gas + elements: [H, C, O, N, Ne, Ar, He, Si, S, F, Cl, Br, I, D, T, CI, OI, X] + species: [N2, Ar, He, Ne, ethane(1), O(2), H2(3), H(4), OH(5), HO2(6), O2(7), H2O2(8), CH(9), CO(10), CH2(11), HCO(12), CH2(S)(13), CH3(14), CH2O(15), CH4(16), CO2(17), CH2OH(18), CH3O(19), CH3OH(20), C2H(21), C2H2(22), HCCO(23), C2H3(24), CH2CO(25), C2H4(26), C2H5(27), H2O(28), C(29), HCCOH(30), CH2CHO(31), CH3CHO(32), C3H8(33)] + kinetics: gas + transport: mixture-averaged + state: {T: 300.0, P: 1 atm} + +elements: +- symbol: D + atomic-weight: 2.014102 +- symbol: T + atomic-weight: 3.016049 +- symbol: CI + atomic-weight: 13.003354 +- symbol: OI + atomic-weight: 17.999159 +- symbol: X + atomic-weight: 195.083 + +species: +- name: ethane(1) + composition: {C: 2.0, H: 6.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 954.5110936886715, 5000.0] + data: + - [3.780345805837327, -0.0032427616688195738, 5.5238540835961135e-05, -6.385877469439608e-08, + 2.28639998353842e-11, -11620.34135275107, 5.210297172176226] + - [4.589795312018622, 0.014150836627966965, -4.7596579825052244e-06, 8.603029496983977e-10, + -6.217238823881424e-14, -12721.75068161533, -3.6171891868496764] + note: 'Thermo group additivity estimation: group(Cs-CsHHH) + group(Cs-CsHHH)' + transport: {model: gas, geometry: nonlinear, diameter: 4.3020000000000005, well-depth: 252.30104810022812, + rotational-relaxation: 1.5, note: GRI-Mech} +- name: O(2) + composition: {O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 3381.427070109808, 5000.0] + data: + - [2.4999999999985287, 9.628563723021598e-15, -1.4423129357510334e-17, 7.111203555044388e-21, + -1.081468248287365e-24, 29230.244128550923, 5.12616427269486] + - [2.499999993394482, 7.0272581087493795e-12, -2.7749960501602356e-15, 4.81886544110849e-19, + -3.1045794407491553e-23, 29230.244133471373, 5.126164313272914] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, diameter: 2.7500000000000004, well-depth: 80.00026940977129, + note: GRI-Mech} +- name: H2(3) + composition: {H: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1959.0734570532368, 5000.0] + data: + - [3.4353640322436836, 0.000212711088867548, -2.786267109928371e-07, 3.4026847506425956e-10, + -7.76035238245164e-14, -1031.3598354840772, -3.9084169952050014] + - [2.7881746899044373, 0.0005876294327569003, 1.5901580485407815e-07, -5.527498406457646e-11, + 4.343188667565404e-15, -596.1494960879099, 0.11268014479418695] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, diameter: 2.9200000000000004, well-depth: 38.00012796964137, + polarizability: 0.7900000000000005, rotational-relaxation: 280.0, note: GRI-Mech} +- name: H(4) + composition: {H: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 3381.427070109808, 5000.0] + data: + - [2.4999999999985287, 9.628563723021598e-15, -1.4423129357510334e-17, 7.111203555044388e-21, + -1.081468248287365e-24, 25474.21776872916, -0.4449728963280224] + - [2.499999993394482, 7.0272581087493795e-12, -2.7749960501602356e-15, 4.81886544110849e-19, + -3.1045794407491553e-23, 25474.217773649605, -0.444972855749969] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, diameter: 2.0500000000000003, well-depth: 145.00018762466215, + note: GRI-Mech} +- name: OH(5) + composition: {H: 1.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1145.7520269685585, 5000.0] + data: + - [3.514568030889614, 2.927749474273922e-05, -5.321637895868379e-07, 1.0194907787997865e-09, + -3.859453686345065e-13, 3414.2541976175758, 2.104348876239043] + - [3.0719398919454433, 0.0006040155603844118, -1.3978216817494781e-08, -2.1344627096837766e-11, + 2.480657980220244e-15, 3579.386728674486, 4.577999618270958] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, diameter: 2.7500000000000004, well-depth: 80.00026940977129, + note: GRI-Mech} +- name: HO2(6) + composition: {H: 1.0, O: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 932.147807123929, 5000.0] + data: + - [4.04594657447324, -0.0017346688146588037, 1.0376730032838863e-05, -1.022036035881876e-08, + 3.3491349668804084e-12, -986.754316874425, 4.6358069149070324] + - [3.2102333691731144, 0.0036794289568842686, -1.2770210213031316e-06, 2.180465263628796e-10, + -1.463389951108199e-14, -910.3663758168628, 8.182947949802738] + note: 'Thermo group additivity estimation: group(O2s-OsH) + group(O2s-OsH) + radical(HOOJ)' + transport: {model: gas, geometry: nonlinear, diameter: 3.4580000000000015, well-depth: 107.40032560095216, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: O2(7) + composition: {O: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1074.5487910223908, 5000.0] + data: + - [3.5373230506433604, -0.001215723673673554, 5.316226913876108e-06, -4.894494564171178e-09, + 1.4584747893316288e-12, -1038.5885150253216, 4.683679586164618] + - [3.1538173541160557, 0.0016780494172578125, -7.69977463345062e-07, 1.5127621307497415e-10, + -1.0878302972154481e-14, -1040.815775508589, 6.1675778705421145] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, diameter: 3.4580000000000015, well-depth: 107.40032560095216, + polarizability: 1.6000000000000008, rotational-relaxation: 3.8, note: GRI-Mech} +- name: H2O2(8) + composition: {H: 2.0, O: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 908.8636980899306, 5000.0] + data: + - [3.731366284109007, 0.003350606013094521, 9.350720493428984e-06, -1.521051004866441e-08, + 6.416107043520503e-12, -17721.171163869974, 5.459079107803863] + - [5.415764982526016, 0.002610120173918772, -4.3991489926460024e-07, 4.911425476518949e-11, + -3.352347640995115e-15, -18302.943400742348, -4.022358081202631] + note: 'Thermo group additivity estimation: group(O2s-OsH) + group(O2s-OsH)' + transport: {model: gas, geometry: nonlinear, diameter: 3.4580000000000015, well-depth: 107.40032560095216, + rotational-relaxation: 3.8, note: GRI-Mech} +- name: CH(9) + composition: {C: 1.0, H: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 926.4996998286691, 5000.0] + data: + - [4.114883798366483, -0.00036105622302789266, -6.34738424724746e-06, 1.0588830857995857e-08, + -4.570592635290404e-12, 75083.85536332303, 1.6126948258692664] + - [2.3397315833288777, 0.0017585822652602947, -8.029170644997589e-07, 1.4045749082137327e-10, + -8.474970838349845e-15, 75650.75149764838, 11.32545135377962] + note: 'Thermo library: primaryThermoLibrary + radical(Cs_P)' + transport: {model: gas, geometry: linear, diameter: 2.7500000000000004, well-depth: 80.00026940977129, + note: GRI-Mech} +- name: CO(10) + composition: {C: 1.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1571.6325038092866, 5000.0] + data: + - [3.568380183872591, -0.0008521275749708765, 2.4891831341165422e-06, -1.5633152724367305e-09, + 3.135967411946522e-13, -14284.254949016655, 3.579121029658425] + - [2.913058334465055, 0.0016465903493515035, -6.886211322091902e-07, 1.2103870467221813e-10, + -7.840283442517857e-15, -14180.880154113569, 6.710506180052189] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, diameter: 3.6500000000000004, well-depth: 98.10027624123336, + polarizability: 1.9500000000000008, rotational-relaxation: 1.8, note: GRI-Mech} +- name: CH2(11) + composition: {C: 1.0, H: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1104.6163817756849, 5000.0] + data: + - [4.011923841489133, -0.00015497839451543438, 3.2629774085156933e-06, -2.4042174893371504e-09, + 5.694965417963233e-13, 45867.680221696675, 0.5332006293939462] + - [3.1498337193348007, 0.0029667428526204092, -9.760559992782986e-07, 1.5411531705304938e-10, + -9.503384326736568e-15, 46058.139092219215, 4.7780774856041885] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, diameter: 3.8, well-depth: 144.00072548202698, + note: GRI-Mech} +- name: HCO(12) + composition: {C: 1.0, H: 1.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1565.714132371199, 5000.0] + data: + - [4.35602339043274, -0.0034709024404038355, 1.2566500153664981e-05, -9.99496787565554e-09, + 2.278910275533282e-12, 3995.7703823171323, 2.7511152173315896] + - [4.618552189478943, 0.005044727567949883, -4.392490375225836e-06, 9.733000206186813e-10, + -7.074497320360272e-14, 2787.5657280626556, -2.2289265396150277] + note: 'Thermo group additivity estimation: group(Cds-OdHH) + radical(HCdsJO)' + transport: {model: gas, geometry: nonlinear, diameter: 3.590000000000001, well-depth: 498.001556803607, + note: GRI-Mech} +- name: CH2(S)(13) + composition: {C: 1.0, H: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1442.3511750737548, 5000.0] + data: + - [4.102644262821686, -0.0014406893453596408, 5.450704522808327e-06, -3.580035535341835e-09, + 7.561975727674366e-13, 50400.578468202875, -0.411767744752251] + - [2.626461951839261, 0.003947647061872542, -1.499250600733676e-06, 2.545411695073568e-10, + -1.6295740679010454e-14, 50691.75925170181, 6.783860566624157] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, diameter: 3.8, well-depth: 144.00072548202698, + note: GRI-Mech} +- name: CH3(14) + composition: {C: 1.0, H: 3.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1337.620819587787, 5000.0] + data: + - [3.915468545997816, 0.0018415334744105523, 3.487446141728892e-06, -3.3275059960317733e-09, + 8.499669695415019e-13, 16285.63932910768, 0.3517380395131654] + - [3.5414438177641827, 0.0047678891393774115, -1.8214953036507109e-06, 3.2887903936663636e-10, + -2.2254753367320316e-14, 16223.964546647976, 1.6604283078795798] + note: 'Thermo library: primaryThermoLibrary + radical(CH3)' + transport: {model: gas, geometry: nonlinear, diameter: 3.8, well-depth: 144.00072548202698, + note: GRI-Mech} +- name: CH2O(15) + composition: {C: 1.0, H: 2.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1402.2812011786486, 5000.0] + data: + - [4.322896688132622, -0.00506327946440804, 2.151558020865406e-05, -1.7652165578523147e-08, + 4.318158267459416e-12, -14278.956505443542, 2.3924226447408348] + - [3.179936326492375, 0.00955601269235614, -6.273028454801088e-06, 1.3355481910102911e-09, + -9.684126206021399e-14, -15075.21914563935, 4.31085170341811] + note: 'Thermo group additivity estimation: group(Cds-OdHH)' + transport: {model: gas, geometry: nonlinear, diameter: 3.590000000000001, well-depth: 498.001556803607, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH4(16) + composition: {C: 1.0, H: 4.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1084.123827322365, 5000.0] + data: + - [4.205413249592893, -0.005355550700516357, 2.5112249357340948e-05, -2.137618922935306e-08, + 5.97520127499108e-12, -10161.943218560951, -0.9212721095036059] + - [0.9082771923874331, 0.011454066909071433, -4.571727616998398e-06, 8.29189195152023e-10, + -5.6631286728402924e-14, -9719.979461834091, 13.993029451960226] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, diameter: 3.746000000000001, well-depth: 141.400440100105, + polarizability: 2.600000000000002, rotational-relaxation: 13.0, note: GRI-Mech} +- name: CO2(17) + composition: {C: 1.0, O: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 988.8860879833867, 5000.0] + data: + - [3.2786139579157667, 0.0027414907869317043, 7.160850310649065e-06, -1.080287685514878e-08, + 4.14288279908879e-12, -48470.31456638012, 5.979355663789081] + - [4.546085505272925, 0.0029191505308481846, -1.1548474402701926e-06, 2.276560890459939e-10, + -1.7091195474740168e-14, -48980.355193356234, -1.432689313852118] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + missing(O2d-Cdd) + + group(Cdd-OdOd)' + transport: {model: gas, geometry: linear, diameter: 3.763, well-depth: 244.00106224424113, + polarizability: 2.650000000000001, rotational-relaxation: 2.1, note: GRI-Mech} +- name: CH2OH(18) + composition: {C: 1.0, H: 3.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 895.0128423768832, 5000.0] + data: + - [3.711747875498063, 0.0019310495477475086, 2.1234224669361647e-05, -3.031581261488382e-08, + 1.2487821239782904e-11, -4007.4595420199803, 7.291993676284961] + - [6.0562988011935595, 0.0030217384679415552, 1.720948400698776e-08, -6.962736851576313e-11, + 5.182164230170264e-15, -4890.505525515445, -6.3476542841121555] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH) + + radical(CsJOH)' + transport: {model: gas, geometry: nonlinear, diameter: 3.6900000000000013, well-depth: 417.00182525120056, + dipole: 1.7000000000000002, rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH3O(19) + composition: {C: 1.0, H: 3.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 916.8834490980655, 5000.0] + data: + - [4.0013575561328585, -0.004156835987149363, 3.263543261448762e-05, -3.71118105654598e-08, + 1.3570917933379284e-11, -6.152570493302685, 6.813714035946757] + - [4.016223845036489, 0.006268132072155586, -1.5806804808679084e-06, 2.44606571076615e-10, + -1.7033720648694282e-14, -449.8054684774207, 4.338796349824254] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH) + + radical(H3COJ)' + transport: {model: gas, geometry: nonlinear, diameter: 3.6900000000000013, well-depth: 417.00182525120056, + dipole: 1.7000000000000002, rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH3OH(20) + composition: {C: 1.0, H: 4.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 952.1389908637451, 5000.0] + data: + - [3.8949618831293553, -0.0007713534032064971, 2.6475516242260254e-05, -2.9179363149306652e-08, + 1.0083470134889905e-11, -26335.85476940014, 6.364759206338717] + - [3.138078300120791, 0.010354206425018032, -3.569573213259954e-06, 6.2228670380635e-10, + -4.2780556797788775e-14, -26551.895613135097, 8.087777938366735] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH)' + transport: {model: gas, geometry: nonlinear, diameter: 3.626000000000001, well-depth: 481.802091582003, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: C2H(21) + composition: {C: 2.0, H: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1076.5739030931832, 5000.0] + data: + - [3.038528423280286, 0.011544944603038693, -2.1326485954432746e-05, 1.819338534674556e-08, + -5.41594365314797e-12, 66398.01413786084, 5.966763865161724] + - [4.008476679662765, 0.002068132533447794, 6.051403922076703e-08, -1.1771143178546624e-10, + 1.292843103778667e-14, 66529.51239223393, 2.796431735903967] + note: 'Thermo group additivity estimation: group(Ct-CtH) + group(Ct-CtH) + radical(Acetyl)' + transport: {model: gas, geometry: linear, diameter: 4.1000000000000005, well-depth: 209.00064369691785, + rotational-relaxation: 2.5, note: GRI-Mech} +- name: C2H2(22) + composition: {C: 2.0, H: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 888.6182543600265, 5000.0] + data: + - [3.0357585217151586, 0.007712248787838784, 2.535472846104679e-06, -1.0814091419221027e-08, + 5.50793884017531e-12, 25852.6438513772, 4.544573545031331] + - [5.7620170200918155, 0.002371637509595834, -1.4961216335698123e-07, -2.1908364280616377e-11, + 2.21719408295192e-15, 25094.4612801627, -9.825927939150352] + note: 'Thermo group additivity estimation: group(Ct-CtH) + group(Ct-CtH)' + transport: {model: gas, geometry: linear, diameter: 4.1000000000000005, well-depth: 209.00064369691785, + rotational-relaxation: 2.5, note: GRI-Mech} +- name: HCCO(23) + composition: {C: 2.0, H: 1.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 936.0672810203184, 5000.0] + data: + - [3.4564721955019664, 0.01057287065008409, -7.35997930717575e-06, 7.974865857027052e-10, + 8.644788930195111e-13, 22595.688064401904, 7.094966296818602] + - [5.9981069864241885, 0.003144794134936119, -9.578007435439627e-07, 1.5562106735769888e-10, + -1.0430827416714007e-14, 21969.463783317686, -5.802371777239033] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + group(Cds-(Cdd-O2d)HH) + + missing(Cdd-CdO2d) + radical(Cds_P)' + transport: {model: gas, geometry: nonlinear, diameter: 2.5000000000000013, well-depth: 150.00110650441783, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: C2H3(24) + composition: {C: 2.0, H: 3.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 931.9858880076591, 5000.0] + data: + - [3.9066414443391624, -0.00406161805089794, 3.867505561886614e-05, -4.629356294110721e-08, + 1.7288184850765833e-11, 34797.18098324665, 6.098116827390869] + - [5.448161345038558, 0.004983220634586766, -1.088008027091821e-06, 1.7978956968030537e-10, + -1.4505633804539655e-14, 33829.69476393835, -4.879180043982607] + note: 'Thermo group additivity estimation: group(Cds-CdsHH) + group(Cds-CdsHH) + + radical(Cds_P)' + transport: {model: gas, geometry: nonlinear, diameter: 4.1000000000000005, well-depth: 209.00064369691785, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: CH2CO(25) + composition: {C: 2.0, H: 2.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 956.6589663809253, 5000.0] + data: + - [3.5274937117983933, 0.007083323568383587, 9.178495162982448e-06, -1.6427295974845557e-08, + 6.7119937845095964e-12, -7123.942950136391, 5.743686833486504] + - [5.764843860393455, 0.005965775843435247, -1.984972026524795e-06, 3.527701091332367e-10, + -2.5164077388183256e-14, -7928.956600867915, -6.9211732597275475] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + group(Cds-(Cdd-O2d)HH) + + missing(Cdd-CdO2d)' + transport: {model: gas, geometry: nonlinear, diameter: 3.9700000000000006, well-depth: 436.0012277388149, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: C2H4(26) + composition: {C: 2.0, H: 4.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 940.4415341496032, 5000.0] + data: + - [3.979761078299263, -0.007575804379415596, 5.5298083380567165e-05, -6.362321213029474e-08, + 2.3177190400951143e-11, 5077.460147499724, 4.0461684201547214] + - [5.202940933280232, 0.007824516477330179, -2.1268877513906106e-06, 3.7970335544514704e-10, + -2.946814128701208e-14, 3936.3029880366635, -6.623812180250903] + note: 'Thermo group additivity estimation: group(Cds-CdsHH) + group(Cds-CdsHH)' + transport: {model: gas, geometry: nonlinear, diameter: 3.9710000000000005, well-depth: 280.80075319274636, + rotational-relaxation: 1.5, note: GRI-Mech} +- name: C2H5(27) + composition: {C: 2.0, H: 5.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 900.3133686413051, 5000.0] + data: + - [3.8218366887126693, -0.0034336137652750723, 5.092576559329648e-05, -6.202121616415652e-08, + 2.3707360339402987e-11, 13066.01287427912, 7.616431110400184] + - [5.156207199872521, 0.009431228225167086, -1.8194614628685796e-06, 2.2119612633683184e-10, + -1.4348159485107404e-14, 12064.083237107747, -2.9109776507588903] + note: 'Thermo group additivity estimation: group(Cs-CsHHH) + group(Cs-CsHHH) + + radical(CCJ)' + transport: {model: gas, geometry: nonlinear, diameter: 4.3020000000000005, well-depth: 252.30104810022812, + rotational-relaxation: 1.5, note: GRI-Mech} +- name: H2O(28) + composition: {H: 2.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1130.2428926130467, 5000.0] + data: + - [4.057636187975462, -0.0007879398698184641, 2.908788069492715e-06, -1.475204287660629e-09, + 2.128490170160392e-13, -30281.5866521907, -0.31136534685788253] + - [2.8432480470655004, 0.002751089366900853, -7.8103367121036e-07, 1.0724414332729549e-10, + -5.793963421285384e-15, -29958.611693452458, 5.910433578723651] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, diameter: 2.6050000000000004, well-depth: 572.4019516813576, + dipole: 1.8439999999999999, rotational-relaxation: 4.0, note: GRI-Mech} +- name: C(29) + composition: {C: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 3381.427070109808, 5000.0] + data: + - [2.4999999999985287, 9.628563723021598e-15, -1.4423129357510334e-17, 7.111203555044388e-21, + -1.081468248287365e-24, 85474.52470343288, 3.659784206708707] + - [2.499999993394482, 7.0272581087493795e-12, -2.7749960501602356e-15, 4.81886544110849e-19, + -3.1045794407491553e-23, 85474.52470835333, 3.6597842472867588] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, diameter: 3.2980000000000005, well-depth: 71.40020436655509, + note: GRI-Mech} +- name: HCCOH(30) + composition: {C: 2.0, H: 2.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 1009.8671367328868, 5000.0] + data: + - [3.3040912347897615, 0.012502446003621081, -3.795055354192445e-06, -4.4633009808641336e-09, + 2.663225471130415e-12, 8782.035416515859, 7.197168970728035] + - [6.7124551454507815, 0.005148330500649028, -2.0007834627740915e-06, 3.788190799793496e-10, + -2.7409124748516927e-14, 7780.23551660169, -10.831376654084673] + note: 'Thermo group additivity estimation: group(O2s-CtH) + group(Ct-CtOs) + group(Ct-CtH)' + transport: {model: gas, geometry: nonlinear, diameter: 3.9700000000000006, well-depth: 436.0012277388149, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH2CHO(31) + composition: {C: 2.0, H: 3.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 914.2195653125194, 5000.0] + data: + - [3.347148890024995, 0.0012878732026556307, 5.399642419215212e-05, -7.841121904676618e-08, + 3.240708687065647e-11, -2992.8440212693995, 8.9731019330448] + - [11.726154554803275, -0.001473691800042265, 2.907484426602473e-06, -5.970162857550277e-10, + 3.7029752558219025e-14, -5941.538943574109, -38.44712632255116] + note: 'Thermo group additivity estimation: group(O2s-(Cds-Cd)H) + group(Cds-CdsOsH) + + group(Cds-CdsHH) + radical(C=COJ)' + transport: {model: gas, geometry: nonlinear, diameter: 3.9700000000000006, well-depth: 436.0012277388149, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH3CHO(32) + composition: {C: 2.0, H: 4.0, O: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 984.2016120728738, 5000.0] + data: + - [3.7007802531138334, 0.0003879420044348043, 3.8692486968828104e-05, -4.5244175226526585e-08, + 1.588568911984255e-11, -21380.907966251474, 9.13565622207468] + - [4.588928731919886, 0.01288931344454544, -4.914985254816196e-06, 9.265000639719394e-10, + -6.710044287886815e-14, -22336.02926281222, 0.9008805816430335] + note: 'Thermo group additivity estimation: group(Cs-(Cds-O2d)HHH) + group(Cds-OdCsH)' + transport: {model: gas, geometry: nonlinear, diameter: 3.9700000000000006, well-depth: 436.0012277388149, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: C3H8(33) + composition: {C: 3.0, H: 8.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [100.0, 986.5741824852131, 5000.0] + data: + - [3.052565931612535, 0.01250994052655728, 3.793862567309607e-05, -5.120220837447088e-08, + 1.8706492840834734e-11, -14454.176775999556, 10.067246001067637] + - [5.91316392026703, 0.021876253744009963, -8.176607701325125e-06, 1.4985452522965277e-09, + -1.0599135379428694e-13, -16038.878659602295, -8.865558390351929] + note: 'Thermo group additivity estimation: group(Cs-CsCsHH) + group(Cs-CsHHH) + + group(Cs-CsHHH)' + transport: {model: gas, geometry: nonlinear, diameter: 4.982000000000001, well-depth: 266.8010668626943, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: N2 + composition: {N: 2.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [3.53101, -0.000123661, -5.02999e-07, 2.43531e-09, -1.40881e-12, -1046.98, 2.96747] + - [2.95258, 0.0013969, -4.92632e-07, 7.8601e-11, -4.60755e-15, -923.949, 5.87189] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, diameter: 3.6210000000000013, well-depth: 97.53030619382686, + polarizability: 1.7600000000000011, rotational-relaxation: 4.0, note: GRI-Mech} +- name: Ar + composition: {Ar: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 4.37967] + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 4.37967] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, diameter: 3.3300000000000005, well-depth: 136.50054988458677, + note: GRI-Mech} +- name: He + composition: {He: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 0.928724] + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 0.928724] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, diameter: 2.5760000000000005, well-depth: 10.2, + note: NOx2018} +- name: Ne + composition: {Ne: 1.0} + thermo: + model: NASA7 + reference-pressure: 10000.0 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 3.35532] + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 3.35532] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, diameter: 3.7580000000000005, well-depth: 148.6, + note: Epsilon & sigma estimated with fixed Lennard Jones Parameters. This is the + fallback method! Try improving transport databases!} +reactions: +- equation: H2(3) + O(2) <=> H(4) + OH(5) + rate-constant: {A: 38.7, b: 2.7, Ea: 26191840.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: HO2(6) + O(2) <=> O2(7) + OH(5) + rate-constant: {A: 20000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H2O2(8) + O(2) <=> HO2(6) + OH(5) + rate-constant: {A: 9630.0, b: 2.0, Ea: 16736000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + O(2) <=> CO(10) + H(4) + rate-constant: {A: 57000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + O(2) <=> H(4) + HCO(12) + rate-constant: {A: 80000000000.00002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + O(2) <=> CO(10) + H2(3) + rate-constant: {A: 15000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + O(2) <=> H(4) + HCO(12) + rate-constant: {A: 15000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + O(2) <=> CH2O(15) + H(4) + rate-constant: {A: 50600000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH4(16) + O(2) <=> CH3(14) + OH(5) + rate-constant: {A: 1020000.0000000001, b: 1.5, Ea: 35982400.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: HCO(12) + O(2) <=> CO(10) + OH(5) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: HCO(12) + O(2) <=> CO2(17) + H(4) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + O(2) <=> HCO(12) + OH(5) + rate-constant: {A: 39000000000.00001, b: 0.0, Ea: 14811360.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2OH(18) + O(2) <=> CH2O(15) + OH(5) + rate-constant: {A: 10000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + O(2) <=> CH2O(15) + OH(5) + rate-constant: {A: 10000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3OH(20) + O(2) <=> CH2OH(18) + OH(5) + rate-constant: {A: 388.00000000000006, b: 2.5, Ea: 12970400.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3OH(20) + O(2) <=> CH3O(19) + OH(5) + rate-constant: {A: 130.00000000000003, b: 2.5, Ea: 20920000.000000004} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H(21) + O(2) <=> CH(9) + CO(10) + rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + O(2) <=> H(4) + HCCO(23) + rate-constant: {A: 13500.000000000002, b: 2.0, Ea: 7949600.000000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + O(2) <=> C2H(21) + OH(5) + rate-constant: {A: 4.600000000000001e+16, b: -1.41, Ea: 121126800.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + O(2) <=> CH2(11) + CO(10) + rate-constant: {A: 6940.000000000001, b: 2.0, Ea: 7949600.000000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H3(24) + O(2) <=> CH2CO(25) + H(4) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H4(26) + O(2) <=> CH3(14) + HCO(12) + rate-constant: {A: 12500.000000000002, b: 1.83, Ea: 920480.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H5(27) + O(2) <=> CH2O(15) + CH3(14) + rate-constant: {A: 22400000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: O(2) + ethane(1) <=> C2H5(27) + OH(5) + rate-constant: {A: 89800.00000000001, b: 1.92, Ea: 23806960.000000004} + note: 'Library reaction: GRI-Mech3.0' +- equation: HCCO(23) + O(2) <=> 2 CO(10) + H(4) + rate-constant: {A: 100000000000.00002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CO(25) + O(2) <=> HCCO(23) + OH(5) + rate-constant: {A: 10000000000.000002, b: 0.0, Ea: 33472000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CO(25) + O(2) <=> CH2(11) + CO2(17) + rate-constant: {A: 1750000000.0000002, b: 0.0, Ea: 5648400.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CO(10) + O2(7) <=> CO2(17) + O(2) + rate-constant: {A: 2500000000.0000005, b: 0.0, Ea: 199995200.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + O2(7) <=> HCO(12) + HO2(6) + rate-constant: {A: 100000000000.00002, b: 0.0, Ea: 167360000.00000003} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + 2 O2(7) + O2(7) <=> HO2(6) + O2(7) + O2(7) + rate-constant: {A: 20800000000000.004, b: -1.24, Ea: 0.0} + efficiencies: {O2(7): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + H2O(28) + O2(7) + H2O(28) <=> H2O(28) + HO2(6) + H2O(28) + rate-constant: {A: 11260000000000.002, b: -0.76, Ea: 0.0} + efficiencies: {H2O(28): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + O2(7) <=> O(2) + OH(5) + rate-constant: {A: 26500000000000.004, b: -0.6707, Ea: 71299544.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 H(4) + H2(3) + H2(3) <=> 2 H2(3) + H2(3) + rate-constant: {A: 90000000000.00002, b: -0.6, Ea: 0.0} + efficiencies: {H2(3): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 H(4) + H2O(28) + H2O(28) <=> H2(3) + H2O(28) + H2O(28) + rate-constant: {A: 60000000000000.01, b: -1.25, Ea: 0.0} + efficiencies: {H2O(28): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CO2(17) + 2 H(4) + CO2(17) <=> CO2(17) + H2(3) + CO2(17) + rate-constant: {A: 550000000000000.1, b: -2.0, Ea: 0.0} + efficiencies: {CO2(17): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> H2O(28) + O(2) + rate-constant: {A: 3970000000.0000005, b: 0.0, Ea: 2807464.0000000005} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> H2(3) + O2(7) + rate-constant: {A: 44800000000.00001, b: 0.0, Ea: 4468512.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> 2 OH(5) + rate-constant: {A: 84000000000.00002, b: 0.0, Ea: 2656840.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + H2O2(8) <=> H2(3) + HO2(6) + rate-constant: {A: 12100.000000000002, b: 2.0, Ea: 21756800.000000004} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + H2O2(8) <=> H2O(28) + OH(5) + rate-constant: {A: 10000000000.000002, b: 0.0, Ea: 15062400.000000004} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + H(4) <=> C(29) + H2(3) + rate-constant: {A: 165000000000.00003, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + H(4) <=> CH(9) + H2(3) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH4(16) + H(4) <=> CH3(14) + H2(3) + rate-constant: {A: 660000.0000000001, b: 1.62, Ea: 45354560.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HCO(12) <=> CO(10) + H2(3) + rate-constant: {A: 73400000000.00002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + H(4) <=> H2(3) + HCO(12) + rate-constant: {A: 57400.000000000015, b: 1.9, Ea: 11472528.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2OH(18) + H(4) <=> CH2O(15) + H2(3) + rate-constant: {A: 20000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2OH(18) + H(4) <=> CH3(14) + OH(5) + rate-constant: {A: 165000000.00000003, b: 0.65, Ea: -1188256.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2OH(18) + H(4) <=> CH2(S)(13) + H2O(28) + rate-constant: {A: 32800000000.000004, b: -0.09, Ea: 2552240.0000000005} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + H(4) + H(4) <=> CH2OH(18) + H(4) + H(4) + rate-constant: {A: 41500.00000000001, b: 1.63, Ea: 8050016.000000002} + efficiencies: {H(4): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + H(4) <=> CH2O(15) + H2(3) + rate-constant: {A: 20000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + H(4) <=> CH3(14) + OH(5) + rate-constant: {A: 1500000000.0000002, b: 0.5, Ea: -460240.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + H(4) <=> CH2(S)(13) + H2O(28) + rate-constant: {A: 262000000000.00003, b: -0.23, Ea: 4476880.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3OH(20) + H(4) <=> CH2OH(18) + H2(3) + rate-constant: {A: 17000.000000000004, b: 2.1, Ea: 20376080.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3OH(20) + H(4) <=> CH3O(19) + H2(3) + rate-constant: {A: 4200.000000000001, b: 2.1, Ea: 20376080.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H3(24) + H(4) <=> C2H2(22) + H2(3) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H4(26) + H(4) <=> C2H3(24) + H2(3) + rate-constant: {A: 1325.0000000000002, b: 2.53, Ea: 51212160.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H5(27) + H(4) <=> C2H4(26) + H2(3) + rate-constant: {A: 2000000000.0000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + ethane(1) <=> C2H5(27) + H2(3) + rate-constant: {A: 115000.00000000001, b: 1.9, Ea: 31505520.000000004} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HCCO(23) <=> CH2(S)(13) + CO(10) + rate-constant: {A: 100000000000.00002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CO(25) + H(4) <=> H2(3) + HCCO(23) + rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 33472000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CO(25) + H(4) <=> CH3(14) + CO(10) + rate-constant: {A: 11300000000.000002, b: 0.0, Ea: 14342752.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HCCOH(30) + H(4) <=> CH2CO(25) + H(4) + H(4) + rate-constant: {A: 10000000000.000002, b: 0.0, Ea: 0.0} + efficiencies: {H(4): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H2(3) + OH(5) <=> H(4) + H2O(28) + rate-constant: {A: 216000.00000000003, b: 1.51, Ea: 14351120.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 OH(5) <=> H2O(28) + O(2) + rate-constant: {A: 35.7, b: 2.4, Ea: -8828240.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: HO2(6) + OH(5) <=> H2O(28) + O2(7) + rate-constant: {A: 14500000000.000002, b: 0.0, Ea: -2092000.0} + duplicate: true + note: 'Library reaction: GRI-Mech3.0' +- equation: HO2(6) + OH(5) <=> H2O(28) + O2(7) + rate-constant: {A: 5000000000000.001, b: 0.0, Ea: 72508720.00000001} + duplicate: true + note: 'Library reaction: GRI-Mech3.0' +- equation: H2O2(8) + OH(5) <=> H2O(28) + HO2(6) + rate-constant: {A: 2000000000.0000002, b: 0.0, Ea: 1786568.0} + duplicate: true + note: 'Library reaction: GRI-Mech3.0' +- equation: H2O2(8) + OH(5) <=> H2O(28) + HO2(6) + rate-constant: {A: 1700000000000000.2, b: 0.0, Ea: 123051440.00000001} + duplicate: true + note: 'Library reaction: GRI-Mech3.0' +- equation: C(29) + OH(5) <=> CO(10) + H(4) + rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + OH(5) <=> H(4) + HCO(12) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + OH(5) <=> CH2O(15) + H(4) + rate-constant: {A: 20000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + OH(5) <=> CH(9) + H2O(28) + rate-constant: {A: 11300.000000000002, b: 2.0, Ea: 12552000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + OH(5) <=> CH2O(15) + H(4) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + OH(5) <=> CH2(11) + H2O(28) + rate-constant: {A: 56000.00000000001, b: 1.6, Ea: 22677280.000000004} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + OH(5) <=> CH2(S)(13) + H2O(28) + rate-constant: {A: 644000000000000.1, b: -1.34, Ea: 5928728.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH4(16) + OH(5) <=> CH3(14) + H2O(28) + rate-constant: {A: 100000.00000000001, b: 1.6, Ea: 13054080.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CO(10) + OH(5) <=> CO2(17) + H(4) + rate-constant: {A: 47600.00000000001, b: 1.228, Ea: 292880.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: HCO(12) + OH(5) <=> CO(10) + H2O(28) + rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + OH(5) <=> H2O(28) + HCO(12) + rate-constant: {A: 3430000.0000000005, b: 1.18, Ea: -1870248.0000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2OH(18) + OH(5) <=> CH2O(15) + H2O(28) + rate-constant: {A: 5000000000.000001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + OH(5) <=> CH2O(15) + H2O(28) + rate-constant: {A: 5000000000.000001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3OH(20) + OH(5) <=> CH2OH(18) + H2O(28) + rate-constant: {A: 1440.0000000000002, b: 2.0, Ea: -3514560.0000000005} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3OH(20) + OH(5) <=> CH3O(19) + H2O(28) + rate-constant: {A: 6300.000000000001, b: 2.0, Ea: 6276000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H(21) + OH(5) <=> H(4) + HCCO(23) + rate-constant: {A: 20000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + OH(5) <=> CH2CO(25) + H(4) + rate-constant: {A: 2.1800000000000005e-07, b: 4.5, Ea: -4184000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + OH(5) <=> H(4) + HCCOH(30) + rate-constant: {A: 504.0000000000001, b: 2.3, Ea: 56484000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + OH(5) <=> C2H(21) + H2O(28) + rate-constant: {A: 33700.0, b: 2.0, Ea: 58576000.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + OH(5) <=> CH3(14) + CO(10) + rate-constant: {A: 4.830000000000001e-07, b: 4.0, Ea: -8368000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H3(24) + OH(5) <=> C2H2(22) + H2O(28) + rate-constant: {A: 5000000000.000001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H4(26) + OH(5) <=> C2H3(24) + H2O(28) + rate-constant: {A: 3600.0000000000005, b: 2.0, Ea: 10460000.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: OH(5) + ethane(1) <=> C2H5(27) + H2O(28) + rate-constant: {A: 3540.0000000000005, b: 2.12, Ea: 3640080.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CO(25) + OH(5) <=> H2O(28) + HCCO(23) + rate-constant: {A: 7500000000.000001, b: 0.0, Ea: 8368000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 HO2(6) <=> H2O2(8) + O2(7) + rate-constant: {A: 130000000.00000001, b: 0.0, Ea: -6819920.000000001} + duplicate: true + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 HO2(6) <=> H2O2(8) + O2(7) + rate-constant: {A: 420000000000.00006, b: 0.0, Ea: 50208000.0} + duplicate: true + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + HO2(6) <=> CH2O(15) + OH(5) + rate-constant: {A: 20000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + HO2(6) <=> CH4(16) + O2(7) + rate-constant: {A: 1000000000.0000001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + HO2(6) <=> CH3O(19) + OH(5) + rate-constant: {A: 37800000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CO(10) + HO2(6) <=> CO2(17) + OH(5) + rate-constant: {A: 150000000000.00003, b: 0.0, Ea: 98742400.00000003} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + HO2(6) <=> H2O2(8) + HCO(12) + rate-constant: {A: 5600.000000000001, b: 2.0, Ea: 50208000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C(29) + O2(7) <=> CO(10) + O(2) + rate-constant: {A: 58000000000.00001, b: 0.0, Ea: 2409984.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C(29) + CH2(11) <=> C2H(21) + H(4) + rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C(29) + CH3(14) <=> C2H2(22) + H(4) + rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + O2(7) <=> HCO(12) + O(2) + rate-constant: {A: 67100000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + H2(3) <=> CH2(11) + H(4) + rate-constant: {A: 108000000000.00002, b: 0.0, Ea: 13012240.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + H2O(28) <=> CH2O(15) + H(4) + rate-constant: {A: 5710000000.000001, b: 0.0, Ea: -3158920.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + CH2(11) <=> C2H2(22) + H(4) + rate-constant: {A: 40000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + CH3(14) <=> C2H3(24) + H(4) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + CH4(16) <=> C2H4(26) + H(4) + rate-constant: {A: 60000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + CO2(17) <=> CO(10) + HCO(12) + rate-constant: {A: 190000000000.00003, b: 0.0, Ea: 66073728.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + CH2O(15) <=> CH2CO(25) + H(4) + rate-constant: {A: 94600000000.00002, b: 0.0, Ea: -2154760.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + HCCO(23) <=> C2H2(22) + CO(10) + rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + O2(7) => CO(10) + H(4) + OH(5) + rate-constant: {A: 5000000000.000001, b: 0.0, Ea: 6276000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + H2(3) <=> CH3(14) + H(4) + rate-constant: {A: 500.0000000000001, b: 2.0, Ea: 30250320.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 CH2(11) <=> C2H2(22) + H2(3) + rate-constant: {A: 1600000000000.0002, b: 0.0, Ea: 49973696.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + CH3(14) <=> C2H4(26) + H(4) + rate-constant: {A: 40000000000.00001, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + CH4(16) <=> 2 CH3(14) + rate-constant: {A: 2460.0000000000005, b: 2.0, Ea: 34601680.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + HCCO(23) <=> C2H3(24) + CO(10) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + O2(7) <=> CO(10) + H(4) + OH(5) + rate-constant: {A: 28000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + O2(7) <=> CO(10) + H2O(28) + rate-constant: {A: 12000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + H2(3) <=> CH3(14) + H(4) + rate-constant: {A: 70000000000.00002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + H2O(28) + H2O(28) <=> CH2(11) + H2O(28) + H2O(28) + rate-constant: {A: 30000000000.000004, b: 0.0, Ea: 0.0} + efficiencies: {H2O(28): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + CH3(14) <=> C2H4(26) + H(4) + rate-constant: {A: 12000000000.000002, b: 0.0, Ea: -2384880.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + CH4(16) <=> 2 CH3(14) + rate-constant: {A: 16000000000.000002, b: 0.0, Ea: -2384880.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + CO(10) + CO(10) <=> CH2(11) + CO(10) + CO(10) + rate-constant: {A: 9000000000.000002, b: 0.0, Ea: 0.0} + efficiencies: {CO(10): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + CO2(17) + CO2(17) <=> CH2(11) + CO2(17) + CO2(17) + rate-constant: {A: 7000000000.000001, b: 0.0, Ea: 0.0} + efficiencies: {CO2(17): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + CO2(17) <=> CH2O(15) + CO(10) + rate-constant: {A: 14000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + ethane(1) <=> C2H5(27) + CH3(14) + rate-constant: {A: 40000000000.00001, b: 0.0, Ea: -2301200.0000000005} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + O2(7) <=> CH3O(19) + O(2) + rate-constant: {A: 35600000000.00001, b: 0.0, Ea: 127528320.00000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + O2(7) <=> CH2O(15) + OH(5) + rate-constant: {A: 2310000000.0000005, b: 0.0, Ea: 84997960.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + H2O2(8) <=> CH4(16) + HO2(6) + rate-constant: {A: 24.500000000000004, b: 2.47, Ea: 21673120.000000004} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 CH3(14) <=> C2H5(27) + H(4) + rate-constant: {A: 6840000000.000001, b: 0.1, Ea: 44350400.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + HCO(12) <=> CH4(16) + CO(10) + rate-constant: {A: 26480000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + CH3(14) <=> CH4(16) + HCO(12) + rate-constant: {A: 3.3200000000000003, b: 2.81, Ea: 24518240.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + CH3OH(20) <=> CH2OH(18) + CH4(16) + rate-constant: {A: 30000.000000000004, b: 1.5, Ea: 41588960.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + CH3OH(20) <=> CH3O(19) + CH4(16) + rate-constant: {A: 10000.000000000002, b: 1.5, Ea: 41588960.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H4(26) + CH3(14) <=> C2H3(24) + CH4(16) + rate-constant: {A: 227.00000000000003, b: 2.0, Ea: 38492800.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + ethane(1) <=> C2H5(27) + CH4(16) + rate-constant: {A: 6140.000000000002, b: 1.74, Ea: 43722800.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: H2O(28) + HCO(12) + H2O(28) <=> CO(10) + H(4) + H2O(28) + H2O(28) + rate-constant: {A: 1500000000000000.2, b: -1.0, Ea: 71128000.0} + efficiencies: {H2O(28): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: HCO(12) + O2(7) <=> CO(10) + HO2(6) + rate-constant: {A: 13450000000.000002, b: 0.0, Ea: 1673600.0000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2OH(18) + O2(7) <=> CH2O(15) + HO2(6) + rate-constant: {A: 18000000000.000004, b: 0.0, Ea: 3765600.000000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + O2(7) <=> CH2O(15) + HO2(6) + rate-constant: {A: 4.2800000000000005e-16, b: 7.6, Ea: -14769520.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H(21) + O2(7) <=> CO(10) + HCO(12) + rate-constant: {A: 10000000000.000002, b: 0.0, Ea: -3158920.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H(21) + H2(3) <=> C2H2(22) + H(4) + rate-constant: {A: 56800000.00000001, b: 0.9, Ea: 8338712.000000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H3(24) + O2(7) <=> CH2O(15) + HCO(12) + rate-constant: {A: 45800000000000.01, b: -1.39, Ea: 4246760.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H5(27) + O2(7) <=> C2H4(26) + HO2(6) + rate-constant: {A: 840000000.0000001, b: 0.0, Ea: 16213000.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: HCCO(23) + O2(7) <=> 2 CO(10) + OH(5) + rate-constant: {A: 3200000000.0000005, b: 0.0, Ea: 3573136.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 HCCO(23) <=> C2H2(22) + 2 CO(10) + rate-constant: {A: 10000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + O(2) => CO(10) + H(4) + H2(3) + rate-constant: {A: 33700000000.000008, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H4(26) + O(2) <=> CH2CHO(31) + H(4) + rate-constant: {A: 6700.000000000001, b: 1.83, Ea: 920480.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H5(27) + O(2) <=> CH3CHO(32) + H(4) + rate-constant: {A: 109600000000.00002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + OH(5) => CH2O(15) + H2(3) + rate-constant: {A: 8000000.000000001, b: 0.5, Ea: -7342920.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + O2(7) => CO2(17) + 2 H(4) + rate-constant: {A: 5800000000.000001, b: 0.0, Ea: 6276000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + O2(7) <=> CH2O(15) + O(2) + rate-constant: {A: 2400000000.0000005, b: 0.0, Ea: 6276000.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 CH2(11) => C2H2(22) + 2 H(4) + rate-constant: {A: 200000000000.00003, b: 0.0, Ea: 45977976.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + H2O(28) => CH2O(15) + H2(3) + rate-constant: {A: 68200000.00000001, b: 0.25, Ea: -3912040.0000000005} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H3(24) + O2(7) <=> CH2CHO(31) + O(2) + rate-constant: {A: 303000000.00000006, b: 0.29, Ea: 46024.00000000001} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H3(24) + O2(7) <=> C2H2(22) + HO2(6) + rate-constant: {A: 1337.0000000000002, b: 1.61, Ea: -1606656.0000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3CHO(32) + O(2) <=> CH2CHO(31) + OH(5) + rate-constant: {A: 2920000000.0000005, b: 0.0, Ea: 7564672.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3CHO(32) + O(2) => CH3(14) + CO(10) + OH(5) + rate-constant: {A: 2920000000.0000005, b: 0.0, Ea: 7564672.000000002} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3CHO(32) + O2(7) => CH3(14) + CO(10) + HO2(6) + rate-constant: {A: 30100000000.000004, b: 0.0, Ea: 163803600.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3CHO(32) + H(4) <=> CH2CHO(31) + H2(3) + rate-constant: {A: 2050000.0000000005, b: 1.16, Ea: 10062520.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3CHO(32) + H(4) => CH3(14) + CO(10) + H2(3) + rate-constant: {A: 2050000.0000000005, b: 1.16, Ea: 10062520.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3CHO(32) + OH(5) => CH3(14) + CO(10) + H2O(28) + rate-constant: {A: 23430000.000000004, b: 0.73, Ea: -4656792.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3CHO(32) + HO2(6) => CH3(14) + CO(10) + H2O2(8) + rate-constant: {A: 3010000000.0000005, b: 0.0, Ea: 49885832.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + CH3CHO(32) + CH3(14) => CH3(14) + CH4(16) + CO(10) + CH3(14) + rate-constant: {A: 2720.0000000000005, b: 1.77, Ea: 24769280.000000004} + efficiencies: {CH3(14): 1.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CHO(31) + O(2) => CH2(11) + CO2(17) + H(4) + rate-constant: {A: 150000000000.00003, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CHO(31) + O2(7) => CH2O(15) + CO(10) + OH(5) + rate-constant: {A: 18100000.000000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CHO(31) + O2(7) => 2 HCO(12) + OH(5) + rate-constant: {A: 23500000.000000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CHO(31) + H(4) <=> CH3(14) + HCO(12) + rate-constant: {A: 22000000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CHO(31) + H(4) <=> CH2CO(25) + H2(3) + rate-constant: {A: 11000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CHO(31) + OH(5) <=> CH2CO(25) + H2O(28) + rate-constant: {A: 12000000000.000002, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CHO(31) + OH(5) <=> CH2OH(18) + HCO(12) + rate-constant: {A: 30100000000.000004, b: 0.0, Ea: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 O(2) + M <=> O2(7) + M + rate-constant: {A: 120000000000.00002, b: -1.0, Ea: 0.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.4, CH4(16): 2.0, CO2(17): 3.6, H2O(28): 15.4, + Ar: 0.83} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + O(2) + M <=> OH(5) + M + rate-constant: {A: 500000000000.0001, b: -1.0, Ea: 0.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + O2(7) + M <=> HO2(6) + M + rate-constant: {A: 2800000000000.0005, b: -0.86, Ea: 0.0} + efficiencies: {ethane(1): 1.5, O2(7): 0.0, CO2(17): 1.5, H2O(28): 0.0, N2: 0.0, + Ar: 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 H(4) + M <=> H2(3) + M + rate-constant: {A: 1000000000000.0002, b: -1.0, Ea: 0.0} + efficiencies: {ethane(1): 3.0, H2(3): 0.0, CH4(16): 2.0, CO2(17): 0.0, H2O(28): 0.0, + Ar: 0.63} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + OH(5) + M <=> H2O(28) + M + rate-constant: {A: 2.2000000000000004e+16, b: -2.0, Ea: 0.0} + efficiencies: {ethane(1): 3.0, H2(3): 0.73, CH4(16): 2.0, H2O(28): 3.65, Ar: 0.38} + note: 'Library reaction: GRI-Mech3.0' +- equation: HCO(12) + M <=> CO(10) + H(4) + M + rate-constant: {A: 187000000000000.03, b: -1.0, Ea: 71128000.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 0.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CO(10) + O(2) (+M) <=> CO2(17) (+M) + type: falloff + low-P-rate-constant: {A: 602000000.0000001, b: 0.0, Ea: 12552000.0} + high-P-rate-constant: {A: 18000000.000000004, b: 0.0, Ea: 9978840.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, O2(7): 6.0, CH4(16): 2.0, CO2(17): 3.5, + H2O(28): 6.0, Ar: 0.5} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + H(4) (+M) <=> CH3(14) (+M) + type: falloff + low-P-rate-constant: {A: 1.0400000000000002e+20, b: -2.76, Ea: 6694400.000000001} + high-P-rate-constant: {A: 600000000000.0001, b: 0.0, Ea: 0.0} + Troe: {A: 0.562, T3: 91.0, T1: 5836.0, T2: 8552.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + H(4) (+M) <=> CH4(16) (+M) + type: falloff + low-P-rate-constant: {A: 2.6200000000000006e+27, b: -4.76, Ea: 10208960.000000002} + high-P-rate-constant: {A: 13900000000000.002, b: -0.534, Ea: 2242624.0000000005} + Troe: {A: 0.783, T3: 74.0, T1: 2941.0, T2: 6964.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 3.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HCO(12) (+M) <=> CH2O(15) (+M) + type: falloff + low-P-rate-constant: {A: 2.4700000000000005e+18, b: -2.57, Ea: 1778200.0} + high-P-rate-constant: {A: 1090000000.0000002, b: 0.48, Ea: -1087840.0000000005} + Troe: {A: 0.7824, T3: 271.0, T1: 2755.0, T2: 6570.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + H(4) (+M) <=> CH2OH(18) (+M) + type: falloff + low-P-rate-constant: {A: 1.2700000000000002e+26, b: -4.82, Ea: 27321520.0} + high-P-rate-constant: {A: 540000000.0000001, b: 0.454, Ea: 15062400.000000004} + Troe: {A: 0.7187, T3: 103.00000000000001, T1: 1291.0, T2: 4160.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2O(15) + H(4) (+M) <=> CH3O(19) (+M) + type: falloff + low-P-rate-constant: {A: 2.2000000000000006e+24, b: -4.8, Ea: 23263040.0} + high-P-rate-constant: {A: 540000000.0000001, b: 0.454, Ea: 10878400.000000002} + Troe: {A: 0.758, T3: 94.0, T1: 1555.0, T2: 4200.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2OH(18) + H(4) (+M) <=> CH3OH(20) (+M) + type: falloff + low-P-rate-constant: {A: 4.360000000000001e+25, b: -4.65, Ea: 21254720.0} + high-P-rate-constant: {A: 1055000000.0000002, b: 0.5, Ea: 359824.0} + Troe: {A: 0.6, T3: 100.0, T1: 90000.0, T2: 10000.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3O(19) + H(4) (+M) <=> CH3OH(20) (+M) + type: falloff + low-P-rate-constant: {A: 4.660000000000001e+35, b: -7.44, Ea: 58910720.0} + high-P-rate-constant: {A: 2430000000.0000005, b: 0.515, Ea: 209200.00000000003} + Troe: {A: 0.7, T3: 100.0, T1: 90000.0, T2: 10000.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H(21) + H(4) (+M) <=> C2H2(22) (+M) + type: falloff + low-P-rate-constant: {A: 3.750000000000001e+27, b: -4.8, Ea: 7949600.000000001} + high-P-rate-constant: {A: 100000000000000.02, b: -1.0, Ea: 0.0} + Troe: {A: 0.6464, T3: 132.0, T1: 1315.0, T2: 5566.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H2(22) + H(4) (+M) <=> C2H3(24) (+M) + type: falloff + low-P-rate-constant: {A: 3.8000000000000006e+34, b: -7.27, Ea: 30208480.0} + high-P-rate-constant: {A: 5600000000.000001, b: 0.0, Ea: 10041600.0} + Troe: {A: 0.7507, T3: 98.50000000000001, T1: 1302.0, T2: 4167.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H3(24) + H(4) (+M) <=> C2H4(26) (+M) + type: falloff + low-P-rate-constant: {A: 1.4000000000000004e+24, b: -3.86, Ea: 13890880.000000004} + high-P-rate-constant: {A: 6080000000.000001, b: 0.27, Ea: 1171520.0} + Troe: {A: 0.782, T3: 207.49999999999997, T1: 2663.0, T2: 6095.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H4(26) + H(4) (+M) <=> C2H5(27) (+M) + type: falloff + low-P-rate-constant: {A: 6.0000000000000005e+35, b: -7.62, Ea: 29162480.0} + high-P-rate-constant: {A: 540000000.0000001, b: 0.454, Ea: 7614880.000000001} + Troe: {A: 0.9753, T3: 209.99999999999997, T1: 983.9999999999999, T2: 4374.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H5(27) + H(4) (+M) <=> ethane(1) (+M) + type: falloff + low-P-rate-constant: {A: 1.9900000000000005e+35, b: -7.08, Ea: 27970040.0} + high-P-rate-constant: {A: 521000000000000.06, b: -0.99, Ea: 6610720.0} + Troe: {A: 0.8422, T3: 125.0, T1: 2219.0, T2: 6882.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CO(10) + H2(3) (+M) <=> CH2O(15) (+M) + type: falloff + low-P-rate-constant: {A: 5.07e+21, b: -3.42, Ea: 352920400.0} + high-P-rate-constant: {A: 43000.00000000001, b: 1.5, Ea: 333046400.0} + Troe: {A: 0.932, T3: 197.00000000000003, T1: 1540.0, T2: 10300.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 OH(5) (+M) <=> H2O2(8) (+M) + type: falloff + low-P-rate-constant: {A: 2300000000000.0005, b: -0.9, Ea: -7112800.0} + high-P-rate-constant: {A: 74000000000.00002, b: -0.37, Ea: 0.0} + Troe: {A: 0.7346, T3: 94.0, T1: 1756.0, T2: 5182.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH3(14) + OH(5) (+M) <=> CH3OH(20) (+M) + type: falloff + low-P-rate-constant: {A: 4.000000000000001e+30, b: -5.92, Ea: 13137760.0} + high-P-rate-constant: {A: 2790000000000000.5, b: -1.43, Ea: 5564720.0} + Troe: {A: 0.412, T3: 195.0, T1: 5900.0, T2: 6394.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + CO(10) (+M) <=> HCCO(23) (+M) + type: falloff + low-P-rate-constant: {A: 2.6900000000000003e+22, b: -3.74, Ea: 8100224.000000001} + high-P-rate-constant: {A: 50000000000.00001, b: 0.0, Ea: 0.0} + Troe: {A: 0.5757, T3: 237.00000000000003, T1: 1652.0, T2: 5069.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(11) + CO(10) (+M) <=> CH2CO(25) (+M) + type: falloff + low-P-rate-constant: {A: 2.6900000000000006e+27, b: -5.11, Ea: 29685480.0} + high-P-rate-constant: {A: 810000000.0000001, b: 0.5, Ea: 18869840.000000004} + Troe: {A: 0.5907, T3: 275.0, T1: 1226.0, T2: 5185.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2(S)(13) + H2O(28) (+M) <=> CH3OH(20) (+M) + type: falloff + low-P-rate-constant: {A: 1.88e+32, b: -6.36, Ea: 21087360.0} + high-P-rate-constant: {A: 482000000000000.06, b: -1.16, Ea: 4790680.000000001} + Troe: {A: 0.6027, T3: 208.0, T1: 3921.9999999999995, T2: 10180.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0} + note: 'Library reaction: GRI-Mech3.0' +- equation: 2 CH3(14) (+M) <=> ethane(1) (+M) + type: falloff + low-P-rate-constant: {A: 3.400000000000001e+35, b: -7.03, Ea: 11556208.000000002} + high-P-rate-constant: {A: 67700000000000.01, b: -1.18, Ea: 2736336.000000001} + Troe: {A: 0.619, T3: 73.2, T1: 1180.0, T2: 9999.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H4(26) (+M) <=> C2H2(22) + H2(3) (+M) + type: falloff + low-P-rate-constant: {A: 1.5800000000000006e+48, b: -9.3, Ea: 409195200.0} + high-P-rate-constant: {A: 8000000000000.0, b: 0.44, Ea: 363045680.00000006} + Troe: {A: 0.7345, T3: 180.0, T1: 1035.0, T2: 5417.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH(9) + H2(3) (+M) <=> CH3(14) (+M) + type: falloff + low-P-rate-constant: {A: 4.820000000000001e+19, b: -2.8, Ea: 2468560.0000000005} + high-P-rate-constant: {A: 1970000000.0000002, b: 0.43, Ea: -1548080.0000000002} + Troe: {A: 0.578, T3: 122.0, T1: 2535.0, T2: 9365.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: CH2CO(25) + H(4) (+M) <=> CH2CHO(31) (+M) + type: falloff + low-P-rate-constant: {A: 1.0120000000000002e+36, b: -7.63, Ea: 16125136.000000002} + high-P-rate-constant: {A: 486500000.00000006, b: 0.422, Ea: -7342920.0} + Troe: {A: 0.465, T3: 201.0, T1: 1772.9999999999998, T2: 5333.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: C2H5(27) + CH3(14) (+M) <=> C3H8(33) (+M) + type: falloff + low-P-rate-constant: {A: 2.7100000000000003e+68, b: -16.82, Ea: 54663960.00000001} + high-P-rate-constant: {A: 9430000000.000002, b: 0.0, Ea: 0.0} + Troe: {A: 0.1527, T3: 291.0, T1: 2742.0, T2: 7748.0} + efficiencies: {ethane(1): 3.0, H2(3): 2.0, CH4(16): 2.0, CO2(17): 2.0, H2O(28): 6.0, + Ar: 0.7} + note: 'Library reaction: GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> H2O2(8) + rate-constant: {A: 5250690.0, b: 1.27262, Ea: 0.0} + note: 'Template reaction: R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_2CNO->O_3R!H->O + in family R_Recombination.' +- equation: CH(9) + H(4) <=> CH2(S)(13) + rate-constant: {A: 53700000000.0, b: 0.15395, Ea: 0.0} + note: 'Template reaction: R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_N-2CNO->O + in family R_Recombination.' +- equation: H(4) + HCCO(23) <=> CH2CO(25) + rate-constant: {A: 11386000000.0, b: 0.308956, Ea: 0.0} + note: 'Template reaction: R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_Sp-3R!H=2CCNNOO_N-3R!H->O_Ext-3CS-R + in family R_Recombination.' +- equation: C2H(21) + OH(5) <=> HCCOH(30) + rate-constant: {A: 77000000000.0, b: 4.95181e-08, Ea: 0.0} + note: 'Template reaction: R_Recombination | Estimated from node Root_N-1R->H_N-1CNOS->N_1COS->O_2R->C_Ext-2C-R + in family R_Recombination.' +- equation: H(4) + HCCO(23) <=> HCCOH(30) + rate-constant: {A: 2805150000.0, b: 0.314888, Ea: 0.0} + note: 'Template reaction: R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_2CNO->O_N-3R!H->O + in family R_Recombination.' +- equation: CH3(14) + HCO(12) <=> CH3CHO(32) + rate-constant: {A: 18100000000.000004, b: 0.0, Ea: 0.0} + note: 'Template reaction: R_Recombination | Matched reaction 71 CH3 + CHO <=> C2H4O + in R_Recombination/training; This reaction matched rate rule [Root_N-1R->H_N-1CNOS->N_N-1COS->O_1CS->C_N-1C-inRing_Ext-2R-R_N-Sp-3R!H-2R_3R!H->O]; + family: R_Recombination' +- equation: CH2CHO(31) + H(4) <=> CH3CHO(32) + rate-constant: {A: 78286700000.0, b: 0.0631113, Ea: 0.0} + note: 'Template reaction: R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_N-2CNO->O_3R!H->C_Sp-3C-2CN + in family R_Recombination.' +- equation: 2 CH(9) <=> C2H2(22) + rate-constant: {A: 99813000.0, b: 0.610916, Ea: 0.0} + note: 'Template reaction: R_Recombination | Estimated from node Root_N-1R->H_N-1CNOS->N_N-1COS->O_1CS->C_N-1C-inRing + in family R_Recombination.' diff --git a/test/rmgpy/test_data/yaml_writer_data/cantera2/from_main_test.yaml b/test/rmgpy/test_data/yaml_writer_data/cantera2/from_main_test.yaml new file mode 100644 index 00000000000..346df39d34c --- /dev/null +++ b/test/rmgpy/test_data/yaml_writer_data/cantera2/from_main_test.yaml @@ -0,0 +1,1249 @@ +description: RMG-Py Generated Mechanism +generator: 'RMG-Py CanteraWriter2 at /Users/rwest/Code/RMG-Py/rmgpy/yaml_cantera2.py + (git commit: 36d0039)' +cantera-version: '3.1' +units: {length: m, time: s, quantity: mol, activation-energy: J/mol} +phases: +- name: gas + thermo: ideal-gas + elements: [Ar, Br, C, Cl, E, F, H, He, I, N, Ne, O, S, Si] + species: [N2, Ar, He, Ne, ethane(1), O(2), H2(3), H(4), OH(5), HO2(6), O2(7), H2O2(8), + CH(9), CO(10), CH2(11), HCO(12), CH2(S)(13), CH3(14), CH2O(15), CH4(16), CO2(17), + CH2OH(18), CH3O(19), CH3OH(20), C2H(21), C2H2(22), HCCO(23), C2H3(24), CH2CO(25), + C2H4(26), C2H5(27), H2O(28), C(29), HCCOH(30), CH2CHO(31), CH3CHO(32), C3H8(33)] + kinetics: gas + reactions: declared-species + transport: mixture-averaged +species: +- name: ethane(1) + composition: {H: 6, C: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 954.5110936886715, 5000.0] + data: + - [3.780345805837327, -0.0032427616688195738, 5.5238540835961135e-05, -6.385877469439608e-08, + 2.28639998353842e-11, -11620.34135275107, 5.210297172176226] + - [4.589795312018622, 0.014150836627966965, -4.7596579825052244e-06, 8.603029496983977e-10, + -6.217238823881424e-14, -12721.75068161533, -3.6171891868496764] + note: 'Thermo group additivity estimation: group(Cs-CsHHH) + group(Cs-CsHHH)' + transport: {model: gas, geometry: nonlinear, well-depth: 252.30104810022812, diameter: 4.3020000000000005, + rotational-relaxation: 1.5, note: GRI-Mech} +- name: O(2) + composition: {O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 3381.427070109808, 5000.0] + data: + - [2.4999999999985287, 9.628563723021598e-15, -1.4423129357510334e-17, 7.111203555044388e-21, + -1.081468248287365e-24, 29230.244128550923, 5.12616427269486] + - [2.499999993394482, 7.0272581087493795e-12, -2.7749960501602356e-15, 4.81886544110849e-19, + -3.1045794407491553e-23, 29230.244133471373, 5.126164313272914] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, well-depth: 80.00026940977129, diameter: 2.7500000000000004, + note: GRI-Mech} +- name: H2(3) + composition: {H: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1959.0734570532368, 5000.0] + data: + - [3.4353640322436836, 0.000212711088867548, -2.786267109928371e-07, 3.4026847506425956e-10, + -7.76035238245164e-14, -1031.3598354840772, -3.9084169952050014] + - [2.7881746899044373, 0.0005876294327569003, 1.5901580485407815e-07, -5.527498406457646e-11, + 4.343188667565404e-15, -596.1494960879099, 0.11268014479418695] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, well-depth: 38.00012796964137, diameter: 2.92, + polarizability: 0.7900000000000004, rotational-relaxation: 280.0, note: GRI-Mech} +- name: H(4) + composition: {H: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 3381.427070109808, 5000.0] + data: + - [2.4999999999985287, 9.628563723021598e-15, -1.4423129357510334e-17, 7.111203555044388e-21, + -1.081468248287365e-24, 25474.21776872916, -0.4449728963280224] + - [2.499999993394482, 7.0272581087493795e-12, -2.7749960501602356e-15, 4.81886544110849e-19, + -3.1045794407491553e-23, 25474.217773649605, -0.444972855749969] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, well-depth: 145.00018762466215, diameter: 2.0500000000000003, + note: GRI-Mech} +- name: OH(5) + composition: {H: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1145.7520269685585, 5000.0] + data: + - [3.514568030889614, 2.927749474273922e-05, -5.321637895868379e-07, 1.0194907787997865e-09, + -3.859453686345065e-13, 3414.2541976175758, 2.104348876239043] + - [3.0719398919454433, 0.0006040155603844118, -1.3978216817494781e-08, -2.1344627096837766e-11, + 2.480657980220244e-15, 3579.386728674486, 4.577999618270958] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, well-depth: 80.00026940977129, diameter: 2.7500000000000004, + note: GRI-Mech} +- name: HO2(6) + composition: {H: 1, O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 932.147807123929, 5000.0] + data: + - [4.04594657447324, -0.0017346688146588037, 1.0376730032838863e-05, -1.022036035881876e-08, + 3.3491349668804084e-12, -986.754316874425, 4.6358069149070324] + - [3.2102333691731144, 0.0036794289568842686, -1.2770210213031316e-06, 2.180465263628796e-10, + -1.463389951108199e-14, -910.3663758168628, 8.182947949802738] + note: 'Thermo group additivity estimation: group(O2s-OsH) + group(O2s-OsH) + radical(HOOJ)' + transport: {model: gas, geometry: nonlinear, well-depth: 107.40032560095216, diameter: 3.458000000000001, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: O2(7) + composition: {O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1074.5487910223908, 5000.0] + data: + - [3.5373230506433604, -0.001215723673673554, 5.316226913876108e-06, -4.894494564171178e-09, + 1.4584747893316288e-12, -1038.5885150253216, 4.683679586164618] + - [3.1538173541160557, 0.0016780494172578125, -7.69977463345062e-07, 1.5127621307497415e-10, + -1.0878302972154481e-14, -1040.815775508589, 6.1675778705421145] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, well-depth: 107.40032560095216, diameter: 3.458000000000001, + polarizability: 1.6000000000000008, rotational-relaxation: 3.8, note: GRI-Mech} +- name: H2O2(8) + composition: {H: 2, O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 908.8636980899306, 5000.0] + data: + - [3.731366284109007, 0.003350606013094521, 9.350720493428984e-06, -1.521051004866441e-08, + 6.416107043520503e-12, -17721.171163869974, 5.459079107803863] + - [5.415764982526016, 0.002610120173918772, -4.3991489926460024e-07, 4.911425476518949e-11, + -3.352347640995115e-15, -18302.943400742348, -4.022358081202631] + note: 'Thermo group additivity estimation: group(O2s-OsH) + group(O2s-OsH)' + transport: {model: gas, geometry: nonlinear, well-depth: 107.40032560095216, diameter: 3.458000000000001, + rotational-relaxation: 3.8, note: GRI-Mech} +- name: CH(9) + composition: {H: 1, C: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 926.4996998286691, 5000.0] + data: + - [4.114883798366483, -0.00036105622302789266, -6.34738424724746e-06, 1.0588830857995857e-08, + -4.570592635290404e-12, 75083.85536332303, 1.6126948258692664] + - [2.3397315833288777, 0.0017585822652602947, -8.029170644997589e-07, 1.4045749082137327e-10, + -8.474970838349845e-15, 75650.75149764838, 11.32545135377962] + note: 'Thermo library: primaryThermoLibrary + radical(Cs_P)' + transport: {model: gas, geometry: linear, well-depth: 80.00026940977129, diameter: 2.7500000000000004, + note: GRI-Mech} +- name: CO(10) + composition: {C: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1571.6325038092866, 5000.0] + data: + - [3.568380183872591, -0.0008521275749708765, 2.4891831341165422e-06, -1.5633152724367305e-09, + 3.135967411946522e-13, -14284.254949016655, 3.579121029658425] + - [2.913058334465055, 0.0016465903493515035, -6.886211322091902e-07, 1.2103870467221813e-10, + -7.840283442517857e-15, -14180.880154113569, 6.710506180052189] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, well-depth: 98.10027624123336, diameter: 3.6500000000000004, + polarizability: 1.9500000000000008, rotational-relaxation: 1.8, note: GRI-Mech} +- name: CH2(11) + composition: {H: 2, C: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1104.6163817756849, 5000.0] + data: + - [4.011923841489133, -0.00015497839451543438, 3.2629774085156933e-06, -2.4042174893371504e-09, + 5.694965417963233e-13, 45867.680221696675, 0.5332006293939462] + - [3.1498337193348007, 0.0029667428526204092, -9.760559992782986e-07, 1.5411531705304938e-10, + -9.503384326736568e-15, 46058.139092219215, 4.7780774856041885] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, well-depth: 144.00072548202698, diameter: 3.8, + note: GRI-Mech} +- name: HCO(12) + composition: {H: 1, C: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1565.714132371199, 5000.0] + data: + - [4.35602339043274, -0.0034709024404038355, 1.2566500153664981e-05, -9.99496787565554e-09, + 2.278910275533282e-12, 3995.7703823171323, 2.7511152173315896] + - [4.618552189478943, 0.005044727567949883, -4.392490375225836e-06, 9.733000206186813e-10, + -7.074497320360272e-14, 2787.5657280626556, -2.2289265396150277] + note: 'Thermo group additivity estimation: group(Cds-OdHH) + radical(HCdsJO)' + transport: {model: gas, geometry: nonlinear, well-depth: 498.001556803607, diameter: 3.5900000000000007, + note: GRI-Mech} +- name: CH2(S)(13) + composition: {H: 2, C: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1442.3511750737548, 5000.0] + data: + - [4.102644262821686, -0.0014406893453596408, 5.450704522808327e-06, -3.580035535341835e-09, + 7.561975727674366e-13, 50400.578468202875, -0.411767744752251] + - [2.626461951839261, 0.003947647061872542, -1.499250600733676e-06, 2.545411695073568e-10, + -1.6295740679010454e-14, 50691.75925170181, 6.783860566624157] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, well-depth: 144.00072548202698, diameter: 3.8, + note: GRI-Mech} +- name: CH3(14) + composition: {H: 3, C: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1337.620819587787, 5000.0] + data: + - [3.915468545997816, 0.0018415334744105523, 3.487446141728892e-06, -3.3275059960317733e-09, + 8.499669695415019e-13, 16285.63932910768, 0.3517380395131654] + - [3.5414438177641827, 0.0047678891393774115, -1.8214953036507109e-06, 3.2887903936663636e-10, + -2.2254753367320316e-14, 16223.964546647976, 1.6604283078795798] + note: 'Thermo library: primaryThermoLibrary + radical(CH3)' + transport: {model: gas, geometry: nonlinear, well-depth: 144.00072548202698, diameter: 3.8, + note: GRI-Mech} +- name: CH2O(15) + composition: {H: 2, C: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1402.2812011786486, 5000.0] + data: + - [4.322896688132622, -0.00506327946440804, 2.151558020865406e-05, -1.7652165578523147e-08, + 4.318158267459416e-12, -14278.956505443542, 2.3924226447408348] + - [3.179936326492375, 0.00955601269235614, -6.273028454801088e-06, 1.3355481910102911e-09, + -9.684126206021399e-14, -15075.21914563935, 4.31085170341811] + note: 'Thermo group additivity estimation: group(Cds-OdHH)' + transport: {model: gas, geometry: nonlinear, well-depth: 498.001556803607, diameter: 3.5900000000000007, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH4(16) + composition: {H: 4, C: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1084.123827322365, 5000.0] + data: + - [4.205413249592893, -0.005355550700516357, 2.5112249357340948e-05, -2.137618922935306e-08, + 5.97520127499108e-12, -10161.943218560951, -0.9212721095036059] + - [0.9082771923874331, 0.011454066909071433, -4.571727616998398e-06, 8.29189195152023e-10, + -5.6631286728402924e-14, -9719.979461834091, 13.993029451960226] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, well-depth: 141.400440100105, diameter: 3.746000000000001, + polarizability: 2.6000000000000014, rotational-relaxation: 13.0, note: GRI-Mech} +- name: CO2(17) + composition: {C: 1, O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 988.8860879833867, 5000.0] + data: + - [3.2786139579157667, 0.0027414907869317043, 7.160850310649065e-06, -1.080287685514878e-08, + 4.14288279908879e-12, -48470.31456638012, 5.979355663789081] + - [4.546085505272925, 0.0029191505308481846, -1.1548474402701926e-06, 2.276560890459939e-10, + -1.7091195474740168e-14, -48980.355193356234, -1.432689313852118] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + missing(O2d-Cdd) + + group(Cdd-OdOd)' + transport: {model: gas, geometry: linear, well-depth: 244.00106224424113, diameter: 3.763, + polarizability: 2.650000000000001, rotational-relaxation: 2.1, note: GRI-Mech} +- name: CH2OH(18) + composition: {H: 3, C: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 895.0128423768832, 5000.0] + data: + - [3.711747875498063, 0.0019310495477475086, 2.1234224669361647e-05, -3.031581261488382e-08, + 1.2487821239782904e-11, -4007.4595420199803, 7.291993676284961] + - [6.0562988011935595, 0.0030217384679415552, 1.720948400698776e-08, -6.962736851576313e-11, + 5.182164230170264e-15, -4890.505525515445, -6.3476542841121555] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH) + + radical(CsJOH)' + transport: {model: gas, geometry: nonlinear, well-depth: 417.00182525120056, diameter: 3.690000000000001, + dipole: 1.7000000000000006, rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH3O(19) + composition: {H: 3, C: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 916.8834490980655, 5000.0] + data: + - [4.0013575561328585, -0.004156835987149363, 3.263543261448762e-05, -3.71118105654598e-08, + 1.3570917933379284e-11, -6.152570493302685, 6.813714035946757] + - [4.016223845036489, 0.006268132072155586, -1.5806804808679084e-06, 2.44606571076615e-10, + -1.7033720648694282e-14, -449.8054684774207, 4.338796349824254] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH) + + radical(H3COJ)' + transport: {model: gas, geometry: nonlinear, well-depth: 417.00182525120056, diameter: 3.690000000000001, + dipole: 1.7000000000000006, rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH3OH(20) + composition: {H: 4, C: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 952.1389908637451, 5000.0] + data: + - [3.8949618831293553, -0.0007713534032064971, 2.6475516242260254e-05, -2.9179363149306652e-08, + 1.0083470134889905e-11, -26335.85476940014, 6.364759206338717] + - [3.138078300120791, 0.010354206425018032, -3.569573213259954e-06, 6.2228670380635e-10, + -4.2780556797788775e-14, -26551.895613135097, 8.087777938366735] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH)' + transport: {model: gas, geometry: nonlinear, well-depth: 481.802091582003, diameter: 3.626000000000001, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: C2H(21) + composition: {H: 1, C: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1076.5739030931832, 5000.0] + data: + - [3.038528423280286, 0.011544944603038693, -2.1326485954432746e-05, 1.819338534674556e-08, + -5.41594365314797e-12, 66398.01413786084, 5.966763865161724] + - [4.008476679662765, 0.002068132533447794, 6.051403922076703e-08, -1.1771143178546624e-10, + 1.292843103778667e-14, 66529.51239223393, 2.796431735903967] + note: 'Thermo group additivity estimation: group(Ct-CtH) + group(Ct-CtH) + radical(Acetyl)' + transport: {model: gas, geometry: linear, well-depth: 209.00064369691785, diameter: 4.1000000000000005, + rotational-relaxation: 2.5, note: GRI-Mech} +- name: C2H2(22) + composition: {H: 2, C: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 888.6182543600265, 5000.0] + data: + - [3.0357585217151586, 0.007712248787838784, 2.535472846104679e-06, -1.0814091419221027e-08, + 5.50793884017531e-12, 25852.6438513772, 4.544573545031331] + - [5.7620170200918155, 0.002371637509595834, -1.4961216335698123e-07, -2.1908364280616377e-11, + 2.21719408295192e-15, 25094.4612801627, -9.825927939150352] + note: 'Thermo group additivity estimation: group(Ct-CtH) + group(Ct-CtH)' + transport: {model: gas, geometry: linear, well-depth: 209.00064369691785, diameter: 4.1000000000000005, + rotational-relaxation: 2.5, note: GRI-Mech} +- name: HCCO(23) + composition: {H: 1, C: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 936.0672810203184, 5000.0] + data: + - [3.4564721955019664, 0.01057287065008409, -7.35997930717575e-06, 7.974865857027052e-10, + 8.644788930195111e-13, 22595.688064401904, 7.094966296818602] + - [5.9981069864241885, 0.003144794134936119, -9.578007435439627e-07, 1.5562106735769888e-10, + -1.0430827416714007e-14, 21969.463783317686, -5.802371777239033] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + group(Cds-(Cdd-O2d)HH) + + missing(Cdd-CdO2d) + radical(Cds_P)' + transport: {model: gas, geometry: nonlinear, well-depth: 150.00110650441783, diameter: 2.500000000000001, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: C2H3(24) + composition: {H: 3, C: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 931.9858880076591, 5000.0] + data: + - [3.9066414443391624, -0.00406161805089794, 3.867505561886614e-05, -4.629356294110721e-08, + 1.7288184850765833e-11, 34797.18098324665, 6.098116827390869] + - [5.448161345038558, 0.004983220634586766, -1.088008027091821e-06, 1.7978956968030537e-10, + -1.4505633804539655e-14, 33829.69476393835, -4.879180043982607] + note: 'Thermo group additivity estimation: group(Cds-CdsHH) + group(Cds-CdsHH) + + radical(Cds_P)' + transport: {model: gas, geometry: nonlinear, well-depth: 209.00064369691785, diameter: 4.1000000000000005, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: CH2CO(25) + composition: {H: 2, C: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 956.6589663809253, 5000.0] + data: + - [3.5274937117983933, 0.007083323568383587, 9.178495162982448e-06, -1.6427295974845557e-08, + 6.7119937845095964e-12, -7123.942950136391, 5.743686833486504] + - [5.764843860393455, 0.005965775843435247, -1.984972026524795e-06, 3.527701091332367e-10, + -2.5164077388183256e-14, -7928.956600867915, -6.9211732597275475] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + group(Cds-(Cdd-O2d)HH) + + missing(Cdd-CdO2d)' + transport: {model: gas, geometry: nonlinear, well-depth: 436.0012277388149, diameter: 3.9700000000000006, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: C2H4(26) + composition: {H: 4, C: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 940.4415341496032, 5000.0] + data: + - [3.979761078299263, -0.007575804379415596, 5.5298083380567165e-05, -6.362321213029474e-08, + 2.3177190400951143e-11, 5077.460147499724, 4.0461684201547214] + - [5.202940933280232, 0.007824516477330179, -2.1268877513906106e-06, 3.7970335544514704e-10, + -2.946814128701208e-14, 3936.3029880366635, -6.623812180250903] + note: 'Thermo group additivity estimation: group(Cds-CdsHH) + group(Cds-CdsHH)' + transport: {model: gas, geometry: nonlinear, well-depth: 280.80075319274636, diameter: 3.9710000000000005, + rotational-relaxation: 1.5, note: GRI-Mech} +- name: C2H5(27) + composition: {H: 5, C: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 900.3133686413051, 5000.0] + data: + - [3.8218366887126693, -0.0034336137652750723, 5.092576559329648e-05, -6.202121616415652e-08, + 2.3707360339402987e-11, 13066.01287427912, 7.616431110400184] + - [5.156207199872521, 0.009431228225167086, -1.8194614628685796e-06, 2.2119612633683184e-10, + -1.4348159485107404e-14, 12064.083237107747, -2.9109776507588903] + note: 'Thermo group additivity estimation: group(Cs-CsHHH) + group(Cs-CsHHH) + + radical(CCJ)' + transport: {model: gas, geometry: nonlinear, well-depth: 252.30104810022812, diameter: 4.3020000000000005, + rotational-relaxation: 1.5, note: GRI-Mech} +- name: H2O(28) + composition: {H: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1130.2428926130467, 5000.0] + data: + - [4.057636187975462, -0.0007879398698184641, 2.908788069492715e-06, -1.475204287660629e-09, + 2.128490170160392e-13, -30281.5866521907, -0.31136534685788253] + - [2.8432480470655004, 0.002751089366900853, -7.8103367121036e-07, 1.0724414332729549e-10, + -5.793963421285384e-15, -29958.611693452458, 5.910433578723651] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: nonlinear, well-depth: 572.4019516813576, diameter: 2.6050000000000004, + dipole: 1.8440000000000003, rotational-relaxation: 4.0, note: GRI-Mech} +- name: C(29) + composition: {C: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 3381.427070109808, 5000.0] + data: + - [2.4999999999985287, 9.628563723021598e-15, -1.4423129357510334e-17, 7.111203555044388e-21, + -1.081468248287365e-24, 85474.52470343288, 3.659784206708707] + - [2.499999993394482, 7.0272581087493795e-12, -2.7749960501602356e-15, 4.81886544110849e-19, + -3.1045794407491553e-23, 85474.52470835333, 3.6597842472867588] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, well-depth: 71.40020436655509, diameter: 3.2980000000000005, + note: GRI-Mech} +- name: HCCOH(30) + composition: {H: 2, C: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1009.8671367328868, 5000.0] + data: + - [3.3040912347897615, 0.012502446003621081, -3.795055354192445e-06, -4.4633009808641336e-09, + 2.663225471130415e-12, 8782.035416515859, 7.197168970728035] + - [6.7124551454507815, 0.005148330500649028, -2.0007834627740915e-06, 3.788190799793496e-10, + -2.7409124748516927e-14, 7780.23551660169, -10.831376654084673] + note: 'Thermo group additivity estimation: group(O2s-CtH) + group(Ct-CtOs) + group(Ct-CtH)' + transport: {model: gas, geometry: nonlinear, well-depth: 436.0012277388149, diameter: 3.9700000000000006, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH2CHO(31) + composition: {H: 3, C: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 914.2195653125194, 5000.0] + data: + - [3.347148890024995, 0.0012878732026556307, 5.399642419215212e-05, -7.841121904676618e-08, + 3.240708687065647e-11, -2992.8440212693995, 8.9731019330448] + - [11.726154554803275, -0.001473691800042265, 2.907484426602473e-06, -5.970162857550277e-10, + 3.7029752558219025e-14, -5941.538943574109, -38.44712632255116] + note: 'Thermo group additivity estimation: group(O2s-(Cds-Cd)H) + group(Cds-CdsOsH) + + group(Cds-CdsHH) + radical(C=COJ)' + transport: {model: gas, geometry: nonlinear, well-depth: 436.0012277388149, diameter: 3.9700000000000006, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: CH3CHO(32) + composition: {H: 4, C: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 984.2016120728738, 5000.0] + data: + - [3.7007802531138334, 0.0003879420044348043, 3.8692486968828104e-05, -4.5244175226526585e-08, + 1.588568911984255e-11, -21380.907966251474, 9.13565622207468] + - [4.588928731919886, 0.01288931344454544, -4.914985254816196e-06, 9.265000639719394e-10, + -6.710044287886815e-14, -22336.02926281222, 0.9008805816430335] + note: 'Thermo group additivity estimation: group(Cs-(Cds-O2d)HHH) + group(Cds-OdCsH)' + transport: {model: gas, geometry: nonlinear, well-depth: 436.0012277388149, diameter: 3.9700000000000006, + rotational-relaxation: 2.0, note: GRI-Mech} +- name: C3H8(33) + composition: {H: 8, C: 3} + thermo: + model: NASA7 + temperature-ranges: [100.0, 986.5741824852131, 5000.0] + data: + - [3.052565931612535, 0.01250994052655728, 3.793862567309607e-05, -5.120220837447088e-08, + 1.8706492840834734e-11, -14454.176775999556, 10.067246001067637] + - [5.91316392026703, 0.021876253744009963, -8.176607701325125e-06, 1.4985452522965277e-09, + -1.0599135379428694e-13, -16038.878659602295, -8.865558390351929] + note: 'Thermo group additivity estimation: group(Cs-CsCsHH) + group(Cs-CsHHH) + + group(Cs-CsHHH)' + transport: {model: gas, geometry: nonlinear, well-depth: 266.8010668626943, diameter: 4.982000000000001, + rotational-relaxation: 1.0, note: GRI-Mech} +- name: N2 + composition: {N: 2} + thermo: + model: NASA7 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [3.53101, -0.000123661, -5.02999e-07, 2.43531e-09, -1.40881e-12, -1046.98, 2.96747] + - [2.95258, 0.0013969, -4.92632e-07, 7.8601e-11, -4.60755e-15, -923.949, 5.87189] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: linear, well-depth: 97.53030619382686, diameter: 3.621000000000001, + polarizability: 1.760000000000001, rotational-relaxation: 4.0, note: GRI-Mech} +- name: Ar + composition: {Ar: 1} + thermo: + model: NASA7 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 4.37967] + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 4.37967] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, well-depth: 136.50054988458677, diameter: 3.3300000000000005, + note: GRI-Mech} +- name: He + composition: {He: 1} + thermo: + model: NASA7 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 0.928724] + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 0.928724] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, well-depth: 10.2, diameter: 2.5760000000000005, + note: NOx2018} +- name: Ne + composition: {Ne: 1} + thermo: + model: NASA7 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 3.35532] + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 3.35532] + note: 'Thermo library: primaryThermoLibrary' + transport: {model: gas, geometry: atom, well-depth: 148.6, diameter: 3.758, note: Epsilon + & sigma estimated with fixed Lennard Jones Parameters. This is the fallback + method! Try improving transport databases!} +reactions: +- equation: O(2) + H2(3) <=> H(4) + OH(5) + rate-constant: {A: 0.038700000000000005, b: 2.7, Ea: 26191.84} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + HO2(6) <=> O2(7) + OH(5) + rate-constant: {A: 20000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + H2O2(8) <=> OH(5) + HO2(6) + rate-constant: {A: 9.63, b: 2.0, Ea: 16736.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH(9) <=> H(4) + CO(10) + rate-constant: {A: 57000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2(11) <=> H(4) + HCO(12) + rate-constant: {A: 80000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2(S)(13) <=> H2(3) + CO(10) + rate-constant: {A: 15000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2(S)(13) <=> H(4) + HCO(12) + rate-constant: {A: 15000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH3(14) <=> H(4) + CH2O(15) + rate-constant: {A: 50600000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH4(16) <=> OH(5) + CH3(14) + rate-constant: {A: 1020.0000000000001, b: 1.5, Ea: 35982.4} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + HCO(12) <=> OH(5) + CO(10) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + HCO(12) <=> H(4) + CO2(17) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2O(15) <=> OH(5) + HCO(12) + rate-constant: {A: 39000000.00000001, b: 0.0, Ea: 14811.36} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2OH(18) <=> OH(5) + CH2O(15) + rate-constant: {A: 10000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH3O(19) <=> OH(5) + CH2O(15) + rate-constant: {A: 10000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH3OH(20) <=> OH(5) + CH2OH(18) + rate-constant: {A: 0.38800000000000007, b: 2.5, Ea: 12970.4} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH3OH(20) <=> OH(5) + CH3O(19) + rate-constant: {A: 0.13000000000000003, b: 2.5, Ea: 20920.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H(21) <=> CO(10) + CH(9) + rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H2(22) <=> H(4) + HCCO(23) + rate-constant: {A: 13.500000000000002, b: 2.0, Ea: 7949.6} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H2(22) <=> OH(5) + C2H(21) + rate-constant: {A: 46000000000000.01, b: -1.41, Ea: 121126.8} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H2(22) <=> CO(10) + CH2(11) + rate-constant: {A: 6.940000000000001, b: 2.0, Ea: 7949.6} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H3(24) <=> H(4) + CH2CO(25) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H4(26) <=> HCO(12) + CH3(14) + rate-constant: {A: 12.500000000000002, b: 1.83, Ea: 920.48} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H5(27) <=> CH2O(15) + CH3(14) + rate-constant: {A: 22400000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + ethane(1) <=> OH(5) + C2H5(27) + rate-constant: {A: 89.80000000000001, b: 1.92, Ea: 23806.96} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + HCCO(23) <=> H(4) + CO(10) + CO(10) + rate-constant: {A: 100000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2CO(25) <=> OH(5) + HCCO(23) + rate-constant: {A: 10000000.000000002, b: 0.0, Ea: 33472.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2CO(25) <=> CO2(17) + CH2(11) + rate-constant: {A: 1750000.0000000002, b: 0.0, Ea: 5648.400000000001} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CO(10) <=> O(2) + CO2(17) + rate-constant: {A: 2500000.0000000005, b: 0.0, Ea: 199995.2} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2O(15) <=> HO2(6) + HCO(12) + rate-constant: {A: 100000000.00000001, b: 0.0, Ea: 167360.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + O2(7) + H(4) <=> O2(7) + HO2(6) + rate-constant: {A: 20800000.000000004, b: -1.24, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + H(4) + H2O(28) <=> HO2(6) + H2O(28) + rate-constant: {A: 11260000.000000002, b: -0.76, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + H(4) <=> O(2) + OH(5) + rate-constant: {A: 26500000000.000004, b: -0.6707, Ea: 71299.54400000001} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + H(4) + H2(3) <=> H2(3) + H2(3) + rate-constant: {A: 90000.00000000001, b: -0.6, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + H(4) + H2O(28) <=> H2(3) + H2O(28) + rate-constant: {A: 60000000.00000001, b: -1.25, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + H(4) + CO2(17) <=> H2(3) + CO2(17) + rate-constant: {A: 550000000.0000001, b: -2.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> O(2) + H2O(28) + rate-constant: {A: 3970000.0000000005, b: 0.0, Ea: 2807.464} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> O2(7) + H2(3) + rate-constant: {A: 44800000.00000001, b: 0.0, Ea: 4468.512000000001} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> OH(5) + OH(5) + rate-constant: {A: 84000000.00000001, b: 0.0, Ea: 2656.84} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + H2O2(8) <=> HO2(6) + H2(3) + rate-constant: {A: 12.100000000000001, b: 2.0, Ea: 21756.8} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + H2O2(8) <=> OH(5) + H2O(28) + rate-constant: {A: 10000000.000000002, b: 0.0, Ea: 15062.400000000001} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH(9) <=> H2(3) + C(29) + rate-constant: {A: 165000000.00000003, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2(S)(13) <=> H2(3) + CH(9) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH4(16) <=> H2(3) + CH3(14) + rate-constant: {A: 660.0000000000001, b: 1.62, Ea: 45354.560000000005} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HCO(12) <=> H2(3) + CO(10) + rate-constant: {A: 73400000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2O(15) <=> H2(3) + HCO(12) + rate-constant: {A: 57.40000000000001, b: 1.9, Ea: 11472.528} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2OH(18) <=> H2(3) + CH2O(15) + rate-constant: {A: 20000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2OH(18) <=> OH(5) + CH3(14) + rate-constant: {A: 165000.00000000003, b: 0.65, Ea: -1188.256} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2OH(18) <=> H2O(28) + CH2(S)(13) + rate-constant: {A: 32800000.000000004, b: -0.09, Ea: 2552.2400000000002} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3O(19) <=> H(4) + CH2OH(18) + rate-constant: {A: 41.50000000000001, b: 1.63, Ea: 8050.0160000000005} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3O(19) <=> H2(3) + CH2O(15) + rate-constant: {A: 20000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3O(19) <=> OH(5) + CH3(14) + rate-constant: {A: 1500000.0000000002, b: 0.5, Ea: -460.24} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3O(19) <=> H2O(28) + CH2(S)(13) + rate-constant: {A: 262000000.00000003, b: -0.23, Ea: 4476.88} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3OH(20) <=> H2(3) + CH2OH(18) + rate-constant: {A: 17.000000000000004, b: 2.1, Ea: 20376.08} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3OH(20) <=> H2(3) + CH3O(19) + rate-constant: {A: 4.200000000000001, b: 2.1, Ea: 20376.08} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H3(24) <=> H2(3) + C2H2(22) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H4(26) <=> H2(3) + C2H3(24) + rate-constant: {A: 1.3250000000000002, b: 2.53, Ea: 51212.16} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H5(27) <=> H2(3) + C2H4(26) + rate-constant: {A: 2000000.0000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + ethane(1) <=> H2(3) + C2H5(27) + rate-constant: {A: 115.00000000000001, b: 1.9, Ea: 31505.52} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HCCO(23) <=> CO(10) + CH2(S)(13) + rate-constant: {A: 100000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2CO(25) <=> H2(3) + HCCO(23) + rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 33472.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2CO(25) <=> CO(10) + CH3(14) + rate-constant: {A: 11300000.000000002, b: 0.0, Ea: 14342.752} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HCCOH(30) <=> H(4) + CH2CO(25) + rate-constant: {A: 10000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + H2(3) <=> H(4) + H2O(28) + rate-constant: {A: 216.00000000000003, b: 1.51, Ea: 14351.12} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + OH(5) <=> O(2) + H2O(28) + rate-constant: {A: 0.0357, b: 2.4, Ea: -8828.24} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + HO2(6) <=> O2(7) + H2O(28) + duplicate: true + rate-constant: {A: 14500000.000000002, b: 0.0, Ea: -2092.0} +- equation: OH(5) + HO2(6) <=> O2(7) + H2O(28) + duplicate: true + rate-constant: {A: 5000000000.000001, b: 0.0, Ea: 72508.72} +- equation: OH(5) + H2O2(8) <=> HO2(6) + H2O(28) + duplicate: true + rate-constant: {A: 2000000.0000000002, b: 0.0, Ea: 1786.568} +- equation: OH(5) + H2O2(8) <=> HO2(6) + H2O(28) + duplicate: true + rate-constant: {A: 1700000000000.0002, b: 0.0, Ea: 123051.44} +- equation: OH(5) + C(29) <=> H(4) + CO(10) + rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH(9) <=> H(4) + HCO(12) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2(11) <=> H(4) + CH2O(15) + rate-constant: {A: 20000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2(11) <=> H2O(28) + CH(9) + rate-constant: {A: 11.300000000000002, b: 2.0, Ea: 12552.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2(S)(13) <=> H(4) + CH2O(15) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3(14) <=> H2O(28) + CH2(11) + rate-constant: {A: 56.00000000000001, b: 1.6, Ea: 22677.280000000002} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3(14) <=> H2O(28) + CH2(S)(13) + rate-constant: {A: 644000000000.0001, b: -1.34, Ea: 5928.728} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH4(16) <=> H2O(28) + CH3(14) + rate-constant: {A: 100.00000000000001, b: 1.6, Ea: 13054.08} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CO(10) <=> H(4) + CO2(17) + rate-constant: {A: 47.60000000000001, b: 1.228, Ea: 292.88} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + HCO(12) <=> H2O(28) + CO(10) + rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2O(15) <=> H2O(28) + HCO(12) + rate-constant: {A: 3430.0000000000005, b: 1.18, Ea: -1870.248} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2OH(18) <=> H2O(28) + CH2O(15) + rate-constant: {A: 5000000.000000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3O(19) <=> H2O(28) + CH2O(15) + rate-constant: {A: 5000000.000000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3OH(20) <=> H2O(28) + CH2OH(18) + rate-constant: {A: 1.4400000000000002, b: 2.0, Ea: -3514.56} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3OH(20) <=> H2O(28) + CH3O(19) + rate-constant: {A: 6.300000000000001, b: 2.0, Ea: 6276.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + C2H(21) <=> H(4) + HCCO(23) + rate-constant: {A: 20000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + C2H2(22) <=> H(4) + CH2CO(25) + rate-constant: {A: 2.1800000000000005e-10, b: 4.5, Ea: -4184.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + C2H2(22) <=> H(4) + HCCOH(30) + rate-constant: {A: 0.5040000000000001, b: 2.3, Ea: 56484.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + C2H2(22) <=> H2O(28) + C2H(21) + rate-constant: {A: 33.7, b: 2.0, Ea: 58576.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + C2H2(22) <=> CO(10) + CH3(14) + rate-constant: {A: 4.830000000000001e-10, b: 4.0, Ea: -8368.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + C2H3(24) <=> H2O(28) + C2H2(22) + rate-constant: {A: 5000000.000000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + C2H4(26) <=> H2O(28) + C2H3(24) + rate-constant: {A: 3.6000000000000005, b: 2.0, Ea: 10460.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + ethane(1) <=> H2O(28) + C2H5(27) + rate-constant: {A: 3.5400000000000005, b: 2.12, Ea: 3640.08} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2CO(25) <=> H2O(28) + HCCO(23) + rate-constant: {A: 7500000.000000001, b: 0.0, Ea: 8368.0} + note: 'Source: Library GRI-Mech3.0' +- equation: HO2(6) + HO2(6) <=> O2(7) + H2O2(8) + duplicate: true + rate-constant: {A: 130000.00000000001, b: 0.0, Ea: -6819.92} +- equation: HO2(6) + HO2(6) <=> O2(7) + H2O2(8) + duplicate: true + rate-constant: {A: 420000000.00000006, b: 0.0, Ea: 50208.0} +- equation: HO2(6) + CH2(11) <=> OH(5) + CH2O(15) + rate-constant: {A: 20000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: HO2(6) + CH3(14) <=> O2(7) + CH4(16) + rate-constant: {A: 1000000.0000000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: HO2(6) + CH3(14) <=> OH(5) + CH3O(19) + rate-constant: {A: 37800000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: HO2(6) + CO(10) <=> OH(5) + CO2(17) + rate-constant: {A: 150000000.00000003, b: 0.0, Ea: 98742.40000000001} + note: 'Source: Library GRI-Mech3.0' +- equation: HO2(6) + CH2O(15) <=> H2O2(8) + HCO(12) + rate-constant: {A: 5.6000000000000005, b: 2.0, Ea: 50208.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + C(29) <=> O(2) + CO(10) + rate-constant: {A: 58000000.00000001, b: 0.0, Ea: 2409.984} + note: 'Source: Library GRI-Mech3.0' +- equation: C(29) + CH2(11) <=> H(4) + C2H(21) + rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: C(29) + CH3(14) <=> H(4) + C2H2(22) + rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH(9) <=> O(2) + HCO(12) + rate-constant: {A: 67100000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H2(3) + CH(9) <=> H(4) + CH2(11) + rate-constant: {A: 108000000.00000001, b: 0.0, Ea: 13012.24} + note: 'Source: Library GRI-Mech3.0' +- equation: H2O(28) + CH(9) <=> H(4) + CH2O(15) + rate-constant: {A: 5710000.000000001, b: 0.0, Ea: -3158.92} + note: 'Source: Library GRI-Mech3.0' +- equation: CH(9) + CH2(11) <=> H(4) + C2H2(22) + rate-constant: {A: 40000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CH(9) + CH3(14) <=> H(4) + C2H3(24) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CH(9) + CH4(16) <=> H(4) + C2H4(26) + rate-constant: {A: 60000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CO2(17) + CH(9) <=> CO(10) + HCO(12) + rate-constant: {A: 190000000.00000003, b: 0.0, Ea: 66073.728} + note: 'Source: Library GRI-Mech3.0' +- equation: CH(9) + CH2O(15) <=> H(4) + CH2CO(25) + rate-constant: {A: 94600000.00000001, b: 0.0, Ea: -2154.76} + note: 'Source: Library GRI-Mech3.0' +- equation: CH(9) + HCCO(23) <=> CO(10) + C2H2(22) + rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2(11) <=> H(4) + OH(5) + CO(10) + rate-constant: {A: 5000000.000000001, b: 0.0, Ea: 6276.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H2(3) + CH2(11) <=> H(4) + CH3(14) + rate-constant: {A: 0.5000000000000001, b: 2.0, Ea: 30250.32} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(11) + CH2(11) <=> H2(3) + C2H2(22) + rate-constant: {A: 1600000000.0000002, b: 0.0, Ea: 49973.696} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(11) + CH3(14) <=> H(4) + C2H4(26) + rate-constant: {A: 40000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(11) + CH4(16) <=> CH3(14) + CH3(14) + rate-constant: {A: 2.4600000000000004, b: 2.0, Ea: 34601.68} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(11) + HCCO(23) <=> CO(10) + C2H3(24) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2(S)(13) <=> H(4) + OH(5) + CO(10) + rate-constant: {A: 28000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2(S)(13) <=> H2O(28) + CO(10) + rate-constant: {A: 12000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H2(3) + CH2(S)(13) <=> H(4) + CH3(14) + rate-constant: {A: 70000000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H2O(28) + CH2(S)(13) <=> H2O(28) + CH2(11) + rate-constant: {A: 30000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(S)(13) + CH3(14) <=> H(4) + C2H4(26) + rate-constant: {A: 12000000.000000002, b: 0.0, Ea: -2384.88} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(S)(13) + CH4(16) <=> CH3(14) + CH3(14) + rate-constant: {A: 16000000.000000002, b: 0.0, Ea: -2384.88} + note: 'Source: Library GRI-Mech3.0' +- equation: CO(10) + CH2(S)(13) <=> CO(10) + CH2(11) + rate-constant: {A: 9000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CO2(17) + CH2(S)(13) <=> CO2(17) + CH2(11) + rate-constant: {A: 7000000.000000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CO2(17) + CH2(S)(13) <=> CO(10) + CH2O(15) + rate-constant: {A: 14000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(S)(13) + ethane(1) <=> CH3(14) + C2H5(27) + rate-constant: {A: 40000000.00000001, b: 0.0, Ea: -2301.2000000000003} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH3(14) <=> O(2) + CH3O(19) + rate-constant: {A: 35600000.00000001, b: 0.0, Ea: 127528.32} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH3(14) <=> OH(5) + CH2O(15) + rate-constant: {A: 2310000.0000000005, b: 0.0, Ea: 84997.96} + note: 'Source: Library GRI-Mech3.0' +- equation: H2O2(8) + CH3(14) <=> HO2(6) + CH4(16) + rate-constant: {A: 0.024500000000000004, b: 2.47, Ea: 21673.120000000003} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + CH3(14) <=> H(4) + C2H5(27) + rate-constant: {A: 6840000.000000001, b: 0.1, Ea: 44350.4} + note: 'Source: Library GRI-Mech3.0' +- equation: HCO(12) + CH3(14) <=> CO(10) + CH4(16) + rate-constant: {A: 26480000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2O(15) + CH3(14) <=> HCO(12) + CH4(16) + rate-constant: {A: 0.0033200000000000005, b: 2.81, Ea: 24518.24} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + CH3OH(20) <=> CH2OH(18) + CH4(16) + rate-constant: {A: 30.000000000000004, b: 1.5, Ea: 41588.96} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + CH3OH(20) <=> CH3O(19) + CH4(16) + rate-constant: {A: 10.000000000000002, b: 1.5, Ea: 41588.96} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + C2H4(26) <=> CH4(16) + C2H3(24) + rate-constant: {A: 0.22700000000000004, b: 2.0, Ea: 38492.8} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + ethane(1) <=> CH4(16) + C2H5(27) + rate-constant: {A: 6.1400000000000015, b: 1.74, Ea: 43722.8} + note: 'Source: Library GRI-Mech3.0' +- equation: H2O(28) + HCO(12) <=> H(4) + H2O(28) + CO(10) + rate-constant: {A: 1500000000000.0002, b: -1.0, Ea: 71128.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + HCO(12) <=> HO2(6) + CO(10) + rate-constant: {A: 13450000.000000002, b: 0.0, Ea: 1673.6000000000001} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2OH(18) <=> HO2(6) + CH2O(15) + rate-constant: {A: 18000000.000000004, b: 0.0, Ea: 3765.6000000000004} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH3O(19) <=> HO2(6) + CH2O(15) + rate-constant: {A: 4.2800000000000005e-19, b: 7.6, Ea: -14769.52} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + C2H(21) <=> CO(10) + HCO(12) + rate-constant: {A: 10000000.000000002, b: 0.0, Ea: -3158.92} + note: 'Source: Library GRI-Mech3.0' +- equation: H2(3) + C2H(21) <=> H(4) + C2H2(22) + rate-constant: {A: 56800.00000000001, b: 0.9, Ea: 8338.712} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + C2H3(24) <=> HCO(12) + CH2O(15) + rate-constant: {A: 45800000000.00001, b: -1.39, Ea: 4246.76} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + C2H5(27) <=> HO2(6) + C2H4(26) + rate-constant: {A: 840000.0000000001, b: 0.0, Ea: 16213.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + HCCO(23) <=> OH(5) + CO(10) + CO(10) + rate-constant: {A: 3200000.0000000005, b: 0.0, Ea: 3573.136} + note: 'Source: Library GRI-Mech3.0' +- equation: HCCO(23) + HCCO(23) <=> CO(10) + CO(10) + C2H2(22) + rate-constant: {A: 10000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH3(14) <=> H(4) + H2(3) + CO(10) + rate-constant: {A: 33700000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H4(26) <=> H(4) + CH2CHO(31) + rate-constant: {A: 6.700000000000001, b: 1.83, Ea: 920.48} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + C2H5(27) <=> H(4) + CH3CHO(32) + rate-constant: {A: 109600000.00000001, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3(14) <=> H2(3) + CH2O(15) + rate-constant: {A: 8000.000000000001, b: 0.5, Ea: -7342.92} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2(11) <=> H(4) + H(4) + CO2(17) + rate-constant: {A: 5800000.000000001, b: 0.0, Ea: 6276.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2(11) <=> O(2) + CH2O(15) + rate-constant: {A: 2400000.0000000005, b: 0.0, Ea: 6276.0} + note: 'Source: Library GRI-Mech3.0' +- equation: CH2(11) + CH2(11) <=> H(4) + H(4) + C2H2(22) + rate-constant: {A: 200000000.00000003, b: 0.0, Ea: 45977.976} + note: 'Source: Library GRI-Mech3.0' +- equation: H2O(28) + CH2(S)(13) <=> H2(3) + CH2O(15) + rate-constant: {A: 68200.00000000001, b: 0.25, Ea: -3912.04} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + C2H3(24) <=> O(2) + CH2CHO(31) + rate-constant: {A: 303000.00000000006, b: 0.29, Ea: 46.024} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + C2H3(24) <=> HO2(6) + C2H2(22) + rate-constant: {A: 1.3370000000000002, b: 1.61, Ea: -1606.656} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH3CHO(32) <=> OH(5) + CH2CHO(31) + rate-constant: {A: 2920000.0000000005, b: 0.0, Ea: 7564.6720000000005} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH3CHO(32) <=> OH(5) + CO(10) + CH3(14) + rate-constant: {A: 2920000.0000000005, b: 0.0, Ea: 7564.6720000000005} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH3CHO(32) <=> HO2(6) + CO(10) + CH3(14) + rate-constant: {A: 30100000.000000004, b: 0.0, Ea: 163803.6} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3CHO(32) <=> H2(3) + CH2CHO(31) + rate-constant: {A: 2050.0000000000005, b: 1.16, Ea: 10062.52} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3CHO(32) <=> H2(3) + CO(10) + CH3(14) + rate-constant: {A: 2050.0000000000005, b: 1.16, Ea: 10062.52} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3CHO(32) <=> H2O(28) + CO(10) + CH3(14) + rate-constant: {A: 23430.000000000004, b: 0.73, Ea: -4656.792} + note: 'Source: Library GRI-Mech3.0' +- equation: HO2(6) + CH3CHO(32) <=> H2O2(8) + CO(10) + CH3(14) + rate-constant: {A: 3010000.0000000005, b: 0.0, Ea: 49885.832} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + CH3CHO(32) <=> CO(10) + CH3(14) + CH4(16) + rate-constant: {A: 2.7200000000000006, b: 1.77, Ea: 24769.280000000002} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CH2CHO(31) <=> H(4) + CO2(17) + CH2(11) + rate-constant: {A: 150000000.00000003, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2CHO(31) <=> OH(5) + CO(10) + CH2O(15) + rate-constant: {A: 18100.000000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + CH2CHO(31) <=> OH(5) + HCO(12) + HCO(12) + rate-constant: {A: 23500.000000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2CHO(31) <=> HCO(12) + CH3(14) + rate-constant: {A: 22000000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2CHO(31) <=> H2(3) + CH2CO(25) + rate-constant: {A: 11000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2CHO(31) <=> H2O(28) + CH2CO(25) + rate-constant: {A: 12000000.000000002, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH2CHO(31) <=> HCO(12) + CH2OH(18) + rate-constant: {A: 30100000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + O(2) (+ M) <=> O2(7) (+ M) + type: three-body + rate-constant: {A: 120000.00000000001, b: -1.0, Ea: 0.0} + efficiencies: {CH4(16): 2, CO2(17): 3.6, ethane(1): 3, H2O(28): 15.4, H2(3): 2.4, + Ar: 0.83} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + H(4) (+ M) <=> OH(5) (+ M) + type: three-body + rate-constant: {A: 500000.0000000001, b: -1.0, Ea: 0.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: O2(7) + H(4) (+ M) <=> HO2(6) (+ M) + type: three-body + rate-constant: {A: 2800000.0000000005, b: -0.86, Ea: 0.0} + efficiencies: {CO2(17): 1.5, ethane(1): 1.5, H2O(28): 0, O2(7): 0, N2: 0, Ar: 0} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + H(4) (+ M) <=> H2(3) (+ M) + type: three-body + rate-constant: {A: 1000000.0000000002, b: -1.0, Ea: 0.0} + efficiencies: {CH4(16): 2, CO2(17): 0, ethane(1): 3, H2O(28): 0, H2(3): 0, Ar: 0.63} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + OH(5) (+ M) <=> H2O(28) (+ M) + type: three-body + rate-constant: {A: 22000000000.000004, b: -2.0, Ea: 0.0} + efficiencies: {ethane(1): 3, CH4(16): 2, H2(3): 0.73, H2O(28): 3.65, Ar: 0.38} + note: 'Source: Library GRI-Mech3.0' +- equation: HCO(12) (+ M) <=> H(4) + CO(10) (+ M) + type: three-body + rate-constant: {A: 187000000000.00003, b: -1.0, Ea: 71128.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 0, H2(3): 2} + note: 'Source: Library GRI-Mech3.0' +- equation: O(2) + CO(10) (+ M) <=> CO2(17) (+ M) + type: falloff + high-P-rate-constant: {A: 18000.000000000004, b: 0.0, Ea: 9978.84} + low-P-rate-constant: {A: 602.0000000000001, b: 0.0, Ea: 12552.0} + efficiencies: {CH4(16): 2, CO2(17): 3.5, ethane(1): 3, H2O(28): 6, H2(3): 2, O2(7): 6, + Ar: 0.5} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2(11) (+ M) <=> CH3(14) (+ M) + type: falloff + high-P-rate-constant: {A: 600000000.0000001, b: 0.0, Ea: 0.0} + low-P-rate-constant: {A: 104000000000000.02, b: -2.76, Ea: 6694.400000000001} + Troe: {A: 0.562, T3: 91.0, T1: 5836.0, T2: 8552.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3(14) (+ M) <=> CH4(16) (+ M) + type: falloff + high-P-rate-constant: {A: 13900000000.000002, b: -0.534, Ea: 2242.6240000000003} + low-P-rate-constant: {A: 2.6200000000000005e+21, b: -4.76, Ea: 10208.960000000001} + Troe: {A: 0.783, T3: 74.0, T1: 2941.0, T2: 6964.0} + efficiencies: {CH4(16): 3, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HCO(12) (+ M) <=> CH2O(15) (+ M) + type: falloff + high-P-rate-constant: {A: 1090000.0000000002, b: 0.48, Ea: -1087.8400000000001} + low-P-rate-constant: {A: 2470000000000.0005, b: -2.57, Ea: 1778.2} + Troe: {A: 0.7824, T3: 271.0, T1: 2755.0, T2: 6570.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2O(15) (+ M) <=> CH2OH(18) (+ M) + type: falloff + high-P-rate-constant: {A: 540000.0000000001, b: 0.454, Ea: 15062.400000000001} + low-P-rate-constant: {A: 1.2700000000000002e+20, b: -4.82, Ea: 27321.52} + Troe: {A: 0.7187, T3: 103.0, T1: 1291.0, T2: 4160.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2O(15) (+ M) <=> CH3O(19) (+ M) + type: falloff + high-P-rate-constant: {A: 540000.0000000001, b: 0.454, Ea: 10878.4} + low-P-rate-constant: {A: 2.2000000000000005e+18, b: -4.8, Ea: 23263.04} + Troe: {A: 0.758, T3: 94.0, T1: 1555.0, T2: 4200.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2OH(18) (+ M) <=> CH3OH(20) (+ M) + type: falloff + high-P-rate-constant: {A: 1055000.0000000002, b: 0.5, Ea: 359.824} + low-P-rate-constant: {A: 4.360000000000001e+19, b: -4.65, Ea: 21254.72} + Troe: {A: 0.6, T3: 100.0, T1: 90000.0, T2: 10000.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH3O(19) (+ M) <=> CH3OH(20) (+ M) + type: falloff + high-P-rate-constant: {A: 2430000.0000000005, b: 0.515, Ea: 209.20000000000002} + low-P-rate-constant: {A: 4.660000000000001e+29, b: -7.44, Ea: 58910.72} + Troe: {A: 0.7, T3: 100.0, T1: 90000.0, T2: 10000.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H(21) (+ M) <=> C2H2(22) (+ M) + type: falloff + high-P-rate-constant: {A: 100000000000.00002, b: -1.0, Ea: 0.0} + low-P-rate-constant: {A: 3.750000000000001e+21, b: -4.8, Ea: 7949.6} + Troe: {A: 0.6464, T3: 132.0, T1: 1315.0, T2: 5566.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H2(22) (+ M) <=> C2H3(24) (+ M) + type: falloff + high-P-rate-constant: {A: 5600000.000000001, b: 0.0, Ea: 10041.6} + low-P-rate-constant: {A: 3.8000000000000008e+28, b: -7.27, Ea: 30208.48} + Troe: {A: 0.7507, T3: 98.5, T1: 1302.0, T2: 4167.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H3(24) (+ M) <=> C2H4(26) (+ M) + type: falloff + high-P-rate-constant: {A: 6080000.000000001, b: 0.27, Ea: 1171.52} + low-P-rate-constant: {A: 1.4000000000000003e+18, b: -3.86, Ea: 13890.880000000001} + Troe: {A: 0.782, T3: 207.5, T1: 2663.0, T2: 6095.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H4(26) (+ M) <=> C2H5(27) (+ M) + type: falloff + high-P-rate-constant: {A: 540000.0000000001, b: 0.454, Ea: 7614.88} + low-P-rate-constant: {A: 6.0000000000000005e+29, b: -7.62, Ea: 29162.48} + Troe: {A: 0.9753, T3: 210.0, T1: 984.0, T2: 4374.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + C2H5(27) (+ M) <=> ethane(1) (+ M) + type: falloff + high-P-rate-constant: {A: 521000000000.00006, b: -0.99, Ea: 6610.72} + low-P-rate-constant: {A: 1.9900000000000005e+29, b: -7.08, Ea: 27970.04} + Troe: {A: 0.8422, T3: 125.0, T1: 2219.0, T2: 6882.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H2(3) + CO(10) (+ M) <=> CH2O(15) (+ M) + type: falloff + high-P-rate-constant: {A: 43.00000000000001, b: 1.5, Ea: 333046.4} + low-P-rate-constant: {A: 5070000000000001.0, b: -3.42, Ea: 352920.4} + Troe: {A: 0.932, T3: 197.0, T1: 1540.0, T2: 10300.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + OH(5) (+ M) <=> H2O2(8) (+ M) + type: falloff + high-P-rate-constant: {A: 74000000.00000001, b: -0.37, Ea: 0.0} + low-P-rate-constant: {A: 2300000.0000000005, b: -0.9, Ea: -7112.8} + Troe: {A: 0.7346, T3: 94.0, T1: 1756.0, T2: 5182.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: OH(5) + CH3(14) (+ M) <=> CH3OH(20) (+ M) + type: falloff + high-P-rate-constant: {A: 2790000000000.0005, b: -1.43, Ea: 5564.72} + low-P-rate-constant: {A: 4.000000000000001e+24, b: -5.92, Ea: 13137.76} + Troe: {A: 0.412, T3: 195.0, T1: 5900.0, T2: 6394.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2} + note: 'Source: Library GRI-Mech3.0' +- equation: CO(10) + CH(9) (+ M) <=> HCCO(23) (+ M) + type: falloff + high-P-rate-constant: {A: 50000000.00000001, b: 0.0, Ea: 0.0} + low-P-rate-constant: {A: 2.6900000000000004e+16, b: -3.74, Ea: 8100.224} + Troe: {A: 0.5757, T3: 237.0, T1: 1652.0, T2: 5069.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: CO(10) + CH2(11) (+ M) <=> CH2CO(25) (+ M) + type: falloff + high-P-rate-constant: {A: 810000.0000000001, b: 0.5, Ea: 18869.84} + low-P-rate-constant: {A: 2.6900000000000005e+21, b: -5.11, Ea: 29685.48} + Troe: {A: 0.5907, T3: 275.0, T1: 1226.0, T2: 5185.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H2O(28) + CH2(S)(13) (+ M) <=> CH3OH(20) (+ M) + type: falloff + high-P-rate-constant: {A: 482000000000.00006, b: -1.16, Ea: 4790.68} + low-P-rate-constant: {A: 1.8800000000000002e+26, b: -6.36, Ea: 21087.36} + Troe: {A: 0.6027, T3: 208.0, T1: 3922.0, T2: 10180.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + CH3(14) (+ M) <=> ethane(1) (+ M) + type: falloff + high-P-rate-constant: {A: 67700000000.00001, b: -1.18, Ea: 2736.3360000000002} + low-P-rate-constant: {A: 3.4000000000000005e+29, b: -7.03, Ea: 11556.208} + Troe: {A: 0.619, T3: 73.2, T1: 1180.0, T2: 9999.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: C2H4(26) (+ M) <=> H2(3) + C2H2(22) (+ M) + type: falloff + high-P-rate-constant: {A: 8000000000000.0, b: 0.44, Ea: 363045.68} + low-P-rate-constant: {A: 1.5800000000000004e+45, b: -9.3, Ea: 409195.2} + Troe: {A: 0.7345, T3: 180.0, T1: 1035.0, T2: 5417.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H2(3) + CH(9) (+ M) <=> CH3(14) (+ M) + type: falloff + high-P-rate-constant: {A: 1970000.0000000002, b: 0.43, Ea: -1548.0800000000002} + low-P-rate-constant: {A: 48200000000000.01, b: -2.8, Ea: 2468.56} + Troe: {A: 0.578, T3: 122.0, T1: 2535.0, T2: 9365.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + CH2CO(25) (+ M) <=> CH2CHO(31) (+ M) + type: falloff + high-P-rate-constant: {A: 486500.00000000006, b: 0.422, Ea: -7342.92} + low-P-rate-constant: {A: 1.0120000000000002e+30, b: -7.63, Ea: 16125.136} + Troe: {A: 0.465, T3: 201.0, T1: 1773.0, T2: 5333.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: CH3(14) + C2H5(27) (+ M) <=> C3H8(33) (+ M) + type: falloff + high-P-rate-constant: {A: 9430000.000000002, b: 0.0, Ea: 0.0} + low-P-rate-constant: {A: 2.7100000000000003e+62, b: -16.82, Ea: 54663.96} + Troe: {A: 0.1527, T3: 291.0, T1: 2742.0, T2: 7748.0} + efficiencies: {CH4(16): 2, CO2(17): 2, ethane(1): 3, H2O(28): 6, H2(3): 2, Ar: 0.7} + note: 'Source: Library GRI-Mech3.0' +- equation: H(4) + HO2(6) <=> H2O2(8) + rate-constant: {A: 5250.69, b: 1.27262, Ea: 0.0} + note: 'Source: Template family R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_2CNO->O_3R!H->O + in family R_Recombination.' +- equation: H(4) + CH(9) <=> CH2(S)(13) + rate-constant: {A: 53700000.0, b: 0.15395, Ea: 0.0} + note: 'Source: Template family R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_N-2CNO->O + in family R_Recombination.' +- equation: H(4) + HCCO(23) <=> CH2CO(25) + rate-constant: {A: 11386000.0, b: 0.308956, Ea: 0.0} + note: 'Source: Template family R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_Sp-3R!H=2CCNNOO_N-3R!H->O_Ext-3CS-R + in family R_Recombination.' +- equation: OH(5) + C2H(21) <=> HCCOH(30) + rate-constant: {A: 77000000.0, b: 4.95181e-08, Ea: 0.0} + note: 'Source: Template family R_Recombination | Estimated from node Root_N-1R->H_N-1CNOS->N_1COS->O_2R->C_Ext-2C-R + in family R_Recombination.' +- equation: H(4) + HCCO(23) <=> HCCOH(30) + rate-constant: {A: 2805150.0, b: 0.314888, Ea: 0.0} + note: 'Source: Template family R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_2CNO->O_N-3R!H->O + in family R_Recombination.' +- equation: HCO(12) + CH3(14) <=> CH3CHO(32) + rate-constant: {A: 18100000.000000004, b: 0.0, Ea: 0.0} + note: 'Source: Template family R_Recombination | Matched reaction 71 CH3 + CHO <=> + C2H4O in R_Recombination/training; This reaction matched rate rule [Root_N-1R->H_N-1CNOS->N_N-1COS->O_1CS->C_N-1C-inRing_Ext-2R-R_N-Sp-3R!H-2R_3R!H->O]; + family: R_Recombination' +- equation: H(4) + CH2CHO(31) <=> CH3CHO(32) + rate-constant: {A: 78286700.0, b: 0.0631113, Ea: 0.0} + note: 'Source: Template family R_Recombination | Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_N-2CNO->O_3R!H->C_Sp-3C-2CN + in family R_Recombination.' +- equation: CH(9) + CH(9) <=> C2H2(22) + rate-constant: {A: 99813.0, b: 0.610916, Ea: 0.0} + note: 'Source: Template family R_Recombination | Estimated from node Root_N-1R->H_N-1CNOS->N_N-1COS->O_1CS->C_N-1C-inRing + in family R_Recombination.' diff --git a/test/rmgpy/test_data/yaml_writer_data/ck2yaml/from_main_test.yaml b/test/rmgpy/test_data/yaml_writer_data/ck2yaml/from_main_test.yaml new file mode 100644 index 00000000000..7edfc6dba01 --- /dev/null +++ b/test/rmgpy/test_data/yaml_writer_data/ck2yaml/from_main_test.yaml @@ -0,0 +1,2151 @@ +generator: ck2yaml +input-files: [chem_annotated.inp, tran.dat] +cantera-version: 3.1.0 +date: Sun, 03 May 2026 13:46:02 -0400 + +units: {length: cm, time: s, quantity: mol, activation-energy: + kcal/mol} + +phases: +- name: gas + thermo: ideal-gas + elements: [H, D, T, C, Ci, O, Oi, N, Ne, Ar, He, Si, S, F, Cl, Br, I, + X] + species: [N2, Ar, He, Ne, ethane(1), O(2), H2(3), H(4), OH(5), + HO2(6), O2(7), H2O2(8), CH(9), CO(10), CH2(11), HCO(12), + CH2(S)(13), CH3(14), CH2O(15), CH4(16), CO2(17), CH2OH(18), + CH3O(19), CH3OH(20), C2H(21), C2H2(22), HCCO(23), C2H3(24), + CH2CO(25), C2H4(26), C2H5(27), H2O(28), C(29), HCCOH(30), + CH2CHO(31), CH3CHO(32), C3H8(33)] + kinetics: gas + transport: mixture-averaged + state: {T: 300.0, P: 1 atm} + +elements: +- symbol: Ci + atomic-weight: 13.003 +- symbol: D + atomic-weight: 2.014 +- symbol: Oi + atomic-weight: 17.999 +- symbol: T + atomic-weight: 3.016 +- symbol: X + atomic-weight: 195.083 + +species: +- name: N2 + composition: {N: 2} + thermo: + model: NASA7 + temperature-ranges: [200.0, 1000.0, 6000.0] + data: + - [3.53101, -1.23661e-04, -5.02999e-07, 2.43531e-09, -1.40881e-12, + -1046.98, 2.96747] + - [2.95258, 1.3969e-03, -4.92632e-07, 7.8601e-11, -4.60755e-15, + -923.949, 5.87189] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: linear + well-depth: 97.53 + diameter: 3.621 + polarizability: 1.76 + rotational-relaxation: 4.0 + note: GRI-Mech + note: ' N2' +- name: Ar + composition: {Ar: 1} + thermo: + model: NASA7 + temperature-ranges: [200.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 4.37967] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: atom + well-depth: 136.501 + diameter: 3.33 + note: GRI-Mech + note: ' Ar' +- name: He + composition: {He: 1} + thermo: + model: NASA7 + temperature-ranges: [200.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 0.928724] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: atom + well-depth: 10.2 + diameter: 2.576 + note: NOx2018 + note: ' He' +- name: Ne + composition: {Ne: 1} + thermo: + model: NASA7 + temperature-ranges: [200.0, 6000.0] + data: + - [2.5, 0.0, 0.0, 0.0, 0.0, -745.375, 3.35532] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: atom + well-depth: 148.6 + diameter: 3.758 + note: Epsilon & sigma estimated with fixed Lennard Jones + Parameters. This is the fallback method! Try improving transport + databases! + note: ' Ne' +- name: ethane(1) + composition: {C: 2, H: 6} + thermo: + model: NASA7 + temperature-ranges: [100.0, 954.51, 5000.0] + data: + - [3.78034581, -3.24276167e-03, 5.52385408e-05, -6.38587747e-08, + 2.28639998e-11, -1.16203414e+04, 5.21029717] + - [4.58979531, 0.0141508366, -4.75965798e-06, 8.6030295e-10, + -6.21723882e-14, -1.27217507e+04, -3.61718919] + note: 'Thermo group additivity estimation: group(Cs-CsHHH) + group(Cs-CsHHH)' + transport: + model: gas + geometry: nonlinear + well-depth: 252.301 + diameter: 4.302 + rotational-relaxation: 1.5 + note: GRI-Mech + note: ' ethane(1)' +- name: O(2) + composition: {O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 3381.43, 5000.0] + data: + - [2.5, 9.62856372e-15, -1.44231294e-17, 7.11120356e-21, + -1.08146825e-24, 2.92302441e+04, 5.12616427] + - [2.49999999, 7.02725811e-12, -2.77499605e-15, 4.81886544e-19, + -3.10457944e-23, 2.92302441e+04, 5.12616431] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: atom + well-depth: 80.0 + diameter: 2.75 + note: GRI-Mech + note: ' O(2)' +- name: H2(3) + composition: {H: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1959.07, 5000.0] + data: + - [3.43536403, 2.12711089e-04, -2.78626711e-07, 3.40268475e-10, + -7.76035238e-14, -1031.35984, -3.908417] + - [2.78817469, 5.87629433e-04, 1.59015805e-07, -5.52749841e-11, + 4.34318867e-15, -596.149496, 0.112680145] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: linear + well-depth: 38.0 + diameter: 2.92 + polarizability: 0.79 + rotational-relaxation: 280.0 + note: GRI-Mech + note: ' H2(3)' +- name: H(4) + composition: {H: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 3381.43, 5000.0] + data: + - [2.5, 9.62856372e-15, -1.44231294e-17, 7.11120356e-21, + -1.08146825e-24, 2.54742178e+04, -0.444972896] + - [2.49999999, 7.02725811e-12, -2.77499605e-15, 4.81886544e-19, + -3.10457944e-23, 2.54742178e+04, -0.444972856] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: atom + well-depth: 145.0 + diameter: 2.05 + note: GRI-Mech + note: ' H(4)' +- name: OH(5) + composition: {H: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1145.75, 5000.0] + data: + - [3.51456803, 2.92774947e-05, -5.3216379e-07, 1.01949078e-09, + -3.85945369e-13, 3414.2542, 2.10434888] + - [3.07193989, 6.0401556e-04, -1.39782168e-08, -2.13446271e-11, + 2.48065798e-15, 3579.38673, 4.57799962] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: linear + well-depth: 80.0 + diameter: 2.75 + note: GRI-Mech + note: ' OH(5)' +- name: HO2(6) + composition: {H: 1, O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 932.15, 5000.0] + data: + - [4.04594657, -1.73466881e-03, 1.037673e-05, -1.02203604e-08, + 3.34913497e-12, -986.754317, 4.63580691] + - [3.21023337, 3.67942896e-03, -1.27702102e-06, 2.18046526e-10, + -1.46338995e-14, -910.366376, 8.18294795] + note: 'Thermo group additivity estimation: group(O2s-OsH) + group(O2s-OsH) + + radical(HOOJ)' + transport: + model: gas + geometry: nonlinear + well-depth: 107.4 + diameter: 3.458 + rotational-relaxation: 1.0 + note: GRI-Mech + note: ' HO2(6)' +- name: O2(7) + composition: {O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1074.55, 5000.0] + data: + - [3.53732305, -1.21572367e-03, 5.31622691e-06, -4.89449456e-09, + 1.45847479e-12, -1038.58852, 4.68367959] + - [3.15381735, 1.67804942e-03, -7.69977463e-07, 1.51276213e-10, + -1.0878303e-14, -1040.81578, 6.16757787] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: linear + well-depth: 107.4 + diameter: 3.458 + polarizability: 1.6 + rotational-relaxation: 3.8 + note: GRI-Mech + note: ' O2(7)' +- name: H2O2(8) + composition: {H: 2, O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 908.86, 5000.0] + data: + - [3.73136628, 3.35060601e-03, 9.35072049e-06, -1.521051e-08, + 6.41610704e-12, -1.77211712e+04, 5.45907911] + - [5.41576498, 2.61012017e-03, -4.39914899e-07, 4.91142548e-11, + -3.35234764e-15, -1.83029434e+04, -4.02235808] + note: 'Thermo group additivity estimation: group(O2s-OsH) + group(O2s-OsH)' + transport: + model: gas + geometry: nonlinear + well-depth: 107.4 + diameter: 3.458 + rotational-relaxation: 3.8 + note: GRI-Mech + note: ' H2O2(8)' +- name: CH(9) + composition: {C: 1, H: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 926.5, 5000.0] + data: + - [4.1148838, -3.61056223e-04, -6.34738425e-06, 1.05888309e-08, + -4.57059264e-12, 7.50838554e+04, 1.61269483] + - [2.33973158, 1.75858227e-03, -8.02917064e-07, 1.40457491e-10, + -8.47497084e-15, 7.56507515e+04, 11.3254514] + note: 'Thermo library: primaryThermoLibrary + radical(Cs_P)' + transport: + model: gas + geometry: linear + well-depth: 80.0 + diameter: 2.75 + note: GRI-Mech + note: ' CH(9)' +- name: CO(10) + composition: {C: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1571.63, 5000.0] + data: + - [3.56838018, -8.52127575e-04, 2.48918313e-06, -1.56331527e-09, + 3.13596741e-13, -1.42842549e+04, 3.57912103] + - [2.91305833, 1.64659035e-03, -6.88621132e-07, 1.21038705e-10, + -7.84028344e-15, -1.41808802e+04, 6.71050618] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: linear + well-depth: 98.1 + diameter: 3.65 + polarizability: 1.95 + rotational-relaxation: 1.8 + note: GRI-Mech + note: ' CO(10)' +- name: CH2(11) + composition: {C: 1, H: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1104.62, 5000.0] + data: + - [4.01192384, -1.54978395e-04, 3.26297741e-06, -2.40421749e-09, + 5.69496542e-13, 4.58676802e+04, 0.533200629] + - [3.14983372, 2.96674285e-03, -9.76055999e-07, 1.54115317e-10, + -9.50338433e-15, 4.60581391e+04, 4.77807749] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: nonlinear + well-depth: 144.001 + diameter: 3.8 + note: GRI-Mech + note: ' CH2(11)' +- name: HCO(12) + composition: {C: 1, H: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1565.71, 5000.0] + data: + - [4.35602339, -3.47090244e-03, 1.25665002e-05, -9.99496788e-09, + 2.27891028e-12, 3995.77038, 2.75111522] + - [4.61855219, 5.04472757e-03, -4.39249038e-06, 9.73300021e-10, + -7.07449732e-14, 2787.56573, -2.22892654] + note: 'Thermo group additivity estimation: group(Cds-OdHH) + radical(HCdsJO)' + transport: + model: gas + geometry: nonlinear + well-depth: 498.002 + diameter: 3.59 + note: GRI-Mech + note: ' HCO(12)' +- name: CH2(S)(13) + composition: {C: 1, H: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1442.35, 5000.0] + data: + - [4.10264426, -1.44068935e-03, 5.45070452e-06, -3.58003554e-09, + 7.56197573e-13, 5.04005785e+04, -0.411767745] + - [2.62646195, 3.94764706e-03, -1.4992506e-06, 2.5454117e-10, + -1.62957407e-14, 5.06917593e+04, 6.78386057] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: nonlinear + well-depth: 144.001 + diameter: 3.8 + note: GRI-Mech + note: ' CH2(S)(13)' +- name: CH3(14) + composition: {C: 1, H: 3} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1337.62, 5000.0] + data: + - [3.91546855, 1.84153347e-03, 3.48744614e-06, -3.327506e-09, + 8.4996697e-13, 1.62856393e+04, 0.35173804] + - [3.54144382, 4.76788914e-03, -1.8214953e-06, 3.28879039e-10, + -2.22547534e-14, 1.62239645e+04, 1.66042831] + note: 'Thermo library: primaryThermoLibrary + radical(CH3)' + transport: + model: gas + geometry: nonlinear + well-depth: 144.001 + diameter: 3.8 + note: GRI-Mech + note: ' CH3(14)' +- name: CH2O(15) + composition: {C: 1, H: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1402.28, 5000.0] + data: + - [4.32289669, -5.06327946e-03, 2.15155802e-05, -1.76521656e-08, + 4.31815827e-12, -1.42789565e+04, 2.39242264] + - [3.17993633, 9.55601269e-03, -6.27302845e-06, 1.33554819e-09, + -9.68412621e-14, -1.50752191e+04, 4.3108517] + note: 'Thermo group additivity estimation: group(Cds-OdHH)' + transport: + model: gas + geometry: nonlinear + well-depth: 498.002 + diameter: 3.59 + rotational-relaxation: 2.0 + note: GRI-Mech + note: ' CH2O(15)' +- name: CH4(16) + composition: {C: 1, H: 4} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1084.12, 5000.0] + data: + - [4.20541325, -5.3555507e-03, 2.51122494e-05, -2.13761892e-08, + 5.97520127e-12, -1.01619432e+04, -0.92127211] + - [0.908277192, 0.0114540669, -4.57172762e-06, 8.29189195e-10, + -5.66312867e-14, -9719.97946, 13.9930295] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: nonlinear + well-depth: 141.4 + diameter: 3.746 + polarizability: 2.6 + rotational-relaxation: 13.0 + note: GRI-Mech + note: ' CH4(16)' +- name: CO2(17) + composition: {C: 1, O: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 988.89, 5000.0] + data: + - [3.27861396, 2.74149079e-03, 7.16085031e-06, -1.08028769e-08, + 4.1428828e-12, -4.84703146e+04, 5.97935566] + - [4.54608551, 2.91915053e-03, -1.15484744e-06, 2.27656089e-10, + -1.70911955e-14, -4.89803552e+04, -1.43268931] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + missing(O2d-Cdd) + + group(Cdd-OdOd)' + transport: + model: gas + geometry: linear + well-depth: 244.001 + diameter: 3.763 + polarizability: 2.65 + rotational-relaxation: 2.1 + note: GRI-Mech + note: ' CO2(17)' +- name: CH2OH(18) + composition: {C: 1, H: 3, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 895.01, 5000.0] + data: + - [3.71174788, 1.93104955e-03, 2.12342247e-05, -3.03158126e-08, + 1.24878212e-11, -4007.45954, 7.29199368] + - [6.0562988, 3.02173847e-03, 1.7209484e-08, -6.96273685e-11, + 5.18216423e-15, -4890.50553, -6.34765428] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH) + + radical(CsJOH)' + transport: + model: gas + geometry: nonlinear + well-depth: 417.002 + diameter: 3.69 + dipole: 1.7 + rotational-relaxation: 2.0 + note: GRI-Mech + note: ' CH2OH(18)' +- name: CH3O(19) + composition: {C: 1, H: 3, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 916.88, 5000.0] + data: + - [4.00135756, -4.15683599e-03, 3.26354326e-05, -3.71118106e-08, + 1.35709179e-11, -6.15257049, 6.81371404] + - [4.01622385, 6.26813207e-03, -1.58068048e-06, 2.44606571e-10, + -1.70337206e-14, -449.805468, 4.33879635] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH) + + radical(H3COJ)' + transport: + model: gas + geometry: nonlinear + well-depth: 417.002 + diameter: 3.69 + dipole: 1.7 + rotational-relaxation: 2.0 + note: GRI-Mech + note: ' CH3O(19)' +- name: CH3OH(20) + composition: {C: 1, H: 4, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 952.14, 5000.0] + data: + - [3.89496188, -7.71353403e-04, 2.64755162e-05, -2.91793631e-08, + 1.00834701e-11, -2.63358548e+04, 6.36475921] + - [3.1380783, 0.0103542064, -3.56957321e-06, 6.22286704e-10, + -4.27805568e-14, -2.65518956e+04, 8.08777794] + note: 'Thermo group additivity estimation: group(O2s-CsH) + group(Cs-OsHHH)' + transport: + model: gas + geometry: nonlinear + well-depth: 481.802 + diameter: 3.626 + rotational-relaxation: 1.0 + note: GRI-Mech + note: ' CH3OH(20)' +- name: C2H(21) + composition: {C: 2, H: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1076.57, 5000.0] + data: + - [3.03852842, 0.0115449446, -2.1326486e-05, 1.81933853e-08, + -5.41594365e-12, 6.63980141e+04, 5.96676387] + - [4.00847668, 2.06813253e-03, 6.05140392e-08, -1.17711432e-10, + 1.2928431e-14, 6.65295124e+04, 2.79643174] + note: 'Thermo group additivity estimation: group(Ct-CtH) + group(Ct-CtH) + + radical(Acetyl)' + transport: + model: gas + geometry: linear + well-depth: 209.001 + diameter: 4.1 + rotational-relaxation: 2.5 + note: GRI-Mech + note: ' C2H(21)' +- name: C2H2(22) + composition: {C: 2, H: 2} + thermo: + model: NASA7 + temperature-ranges: [100.0, 888.62, 5000.0] + data: + - [3.03575852, 7.71224879e-03, 2.53547285e-06, -1.08140914e-08, + 5.50793884e-12, 2.58526439e+04, 4.54457355] + - [5.76201702, 2.37163751e-03, -1.49612163e-07, -2.19083643e-11, + 2.21719408e-15, 2.50944613e+04, -9.82592794] + note: 'Thermo group additivity estimation: group(Ct-CtH) + group(Ct-CtH)' + transport: + model: gas + geometry: linear + well-depth: 209.001 + diameter: 4.1 + rotational-relaxation: 2.5 + note: GRI-Mech + note: ' C2H2(22)' +- name: HCCO(23) + composition: {C: 2, H: 1, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 936.07, 5000.0] + data: + - [3.4564722, 0.0105728707, -7.35997931e-06, 7.97486586e-10, + 8.64478893e-13, 2.25956881e+04, 7.0949663] + - [5.99810699, 3.14479413e-03, -9.57800744e-07, 1.55621067e-10, + -1.04308274e-14, 2.19694638e+04, -5.80237178] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + group(Cds-(Cdd-O2d)HH) + + missing(Cdd-CdO2d) + radical(Cds_P)' + transport: + model: gas + geometry: nonlinear + well-depth: 150.001 + diameter: 2.5 + rotational-relaxation: 1.0 + note: GRI-Mech + note: ' HCCO(23)' +- name: C2H3(24) + composition: {C: 2, H: 3} + thermo: + model: NASA7 + temperature-ranges: [100.0, 931.99, 5000.0] + data: + - [3.90664144, -4.06161805e-03, 3.86750556e-05, -4.62935629e-08, + 1.72881849e-11, 3.4797181e+04, 6.09811683] + - [5.44816135, 4.98322063e-03, -1.08800803e-06, 1.7978957e-10, + -1.45056338e-14, 3.38296948e+04, -4.87918004] + note: 'Thermo group additivity estimation: group(Cds-CdsHH) + group(Cds-CdsHH) + + radical(Cds_P)' + transport: + model: gas + geometry: nonlinear + well-depth: 209.001 + diameter: 4.1 + rotational-relaxation: 1.0 + note: GRI-Mech + note: ' C2H3(24)' +- name: CH2CO(25) + composition: {C: 2, H: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 956.66, 5000.0] + data: + - [3.52749371, 7.08332357e-03, 9.17849516e-06, -1.6427296e-08, + 6.71199378e-12, -7123.94295, 5.74368683] + - [5.76484386, 5.96577584e-03, -1.98497203e-06, 3.52770109e-10, + -2.51640774e-14, -7928.9566, -6.92117326] + note: 'Thermo group additivity estimation: missing(O2d-Cdd) + group(Cds-(Cdd-O2d)HH) + + missing(Cdd-CdO2d)' + transport: + model: gas + geometry: nonlinear + well-depth: 436.001 + diameter: 3.97 + rotational-relaxation: 2.0 + note: GRI-Mech + note: ' CH2CO(25)' +- name: C2H4(26) + composition: {C: 2, H: 4} + thermo: + model: NASA7 + temperature-ranges: [100.0, 940.44, 5000.0] + data: + - [3.97976108, -7.57580438e-03, 5.52980834e-05, -6.36232121e-08, + 2.31771904e-11, 5077.46015, 4.04616842] + - [5.20294093, 7.82451648e-03, -2.12688775e-06, 3.79703355e-10, + -2.94681413e-14, 3936.30299, -6.62381218] + note: 'Thermo group additivity estimation: group(Cds-CdsHH) + group(Cds-CdsHH)' + transport: + model: gas + geometry: nonlinear + well-depth: 280.801 + diameter: 3.971 + rotational-relaxation: 1.5 + note: GRI-Mech + note: ' C2H4(26)' +- name: C2H5(27) + composition: {C: 2, H: 5} + thermo: + model: NASA7 + temperature-ranges: [100.0, 900.31, 5000.0] + data: + - [3.82183669, -3.43361377e-03, 5.09257656e-05, -6.20212162e-08, + 2.37073603e-11, 1.30660129e+04, 7.61643111] + - [5.1562072, 9.43122823e-03, -1.81946146e-06, 2.21196126e-10, + -1.43481595e-14, 1.20640832e+04, -2.91097765] + note: 'Thermo group additivity estimation: group(Cs-CsHHH) + group(Cs-CsHHH) + + radical(CCJ)' + transport: + model: gas + geometry: nonlinear + well-depth: 252.301 + diameter: 4.302 + rotational-relaxation: 1.5 + note: GRI-Mech + note: ' C2H5(27)' +- name: H2O(28) + composition: {H: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1130.24, 5000.0] + data: + - [4.05763619, -7.8793987e-04, 2.90878807e-06, -1.47520429e-09, + 2.12849017e-13, -3.02815867e+04, -0.311365347] + - [2.84324805, 2.75108937e-03, -7.81033671e-07, 1.07244143e-10, + -5.79396342e-15, -2.99586117e+04, 5.91043358] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: nonlinear + well-depth: 572.402 + diameter: 2.605 + dipole: 1.844 + rotational-relaxation: 4.0 + note: GRI-Mech + note: ' H2O(28)' +- name: C(29) + composition: {C: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 3381.43, 5000.0] + data: + - [2.5, 9.62856372e-15, -1.44231294e-17, 7.11120356e-21, + -1.08146825e-24, 8.54745247e+04, 3.65978421] + - [2.49999999, 7.02725811e-12, -2.77499605e-15, 4.81886544e-19, + -3.10457944e-23, 8.54745247e+04, 3.65978425] + note: 'Thermo library: primaryThermoLibrary' + transport: + model: gas + geometry: atom + well-depth: 71.4 + diameter: 3.298 + note: GRI-Mech + note: ' C(29)' +- name: HCCOH(30) + composition: {C: 2, H: 2, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 1009.87, 5000.0] + data: + - [3.30409123, 0.012502446, -3.79505535e-06, -4.46330098e-09, + 2.66322547e-12, 8782.03542, 7.19716897] + - [6.71245515, 5.1483305e-03, -2.00078346e-06, 3.7881908e-10, + -2.74091247e-14, 7780.23552, -10.8313767] + note: 'Thermo group additivity estimation: group(O2s-CtH) + group(Ct-CtOs) + + group(Ct-CtH)' + transport: + model: gas + geometry: nonlinear + well-depth: 436.001 + diameter: 3.97 + rotational-relaxation: 2.0 + note: GRI-Mech + note: ' HCCOH(30)' +- name: CH2CHO(31) + composition: {C: 2, H: 3, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 914.22, 5000.0] + data: + - [3.34714889, 1.2878732e-03, 5.39964242e-05, -7.8411219e-08, + 3.24070869e-11, -2992.84402, 8.97310193] + - [11.7261546, -1.4736918e-03, 2.90748443e-06, -5.97016286e-10, + 3.70297526e-14, -5941.53894, -38.4471263] + note: 'Thermo group additivity estimation: group(O2s-(Cds-Cd)H) + group(Cds-CdsOsH) + + group(Cds-CdsHH) + radical(C=COJ)' + transport: + model: gas + geometry: nonlinear + well-depth: 436.001 + diameter: 3.97 + rotational-relaxation: 2.0 + note: GRI-Mech + note: ' CH2CHO(31)' +- name: CH3CHO(32) + composition: {C: 2, H: 4, O: 1} + thermo: + model: NASA7 + temperature-ranges: [100.0, 984.2, 5000.0] + data: + - [3.70078025, 3.87942004e-04, 3.8692487e-05, -4.52441752e-08, + 1.58856891e-11, -2.1380908e+04, 9.13565622] + - [4.58892873, 0.0128893134, -4.91498525e-06, 9.26500064e-10, + -6.71004429e-14, -2.23360293e+04, 0.900880582] + note: 'Thermo group additivity estimation: group(Cs-(Cds-O2d)HHH) + + group(Cds-OdCsH)' + transport: + model: gas + geometry: nonlinear + well-depth: 436.001 + diameter: 3.97 + rotational-relaxation: 2.0 + note: GRI-Mech + note: ' CH3CHO(32)' +- name: C3H8(33) + composition: {C: 3, H: 8} + thermo: + model: NASA7 + temperature-ranges: [100.0, 986.57, 5000.0] + data: + - [3.05256593, 0.0125099405, 3.79386257e-05, -5.12022084e-08, + 1.87064928e-11, -1.44541768e+04, 10.067246] + - [5.91316392, 0.0218762537, -8.1766077e-06, 1.49854525e-09, + -1.05991354e-13, -1.60388787e+04, -8.86555839] + note: 'Thermo group additivity estimation: group(Cs-CsCsHH) + group(Cs-CsHHH) + + group(Cs-CsHHH)' + transport: + model: gas + geometry: nonlinear + well-depth: 266.801 + diameter: 4.982 + rotational-relaxation: 1.0 + note: GRI-Mech + note: ' C3H8(33)' + +reactions: +- equation: O(2) + H2(3) <=> H(4) + OH(5) # Reaction 1 + rate-constant: {A: 3.87e+04, b: 2.7, Ea: 6.26} + note: | + Reaction index: Chemkin #1; RMG #1 + Library reaction: GRI-Mech3.0 + Flux pairs: O(2), OH(5); H2(3), H(4); +- equation: O(2) + HO2(6) <=> O2(7) + OH(5) # Reaction 2 + rate-constant: {A: 2.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #2; RMG #2 + Library reaction: GRI-Mech3.0 + Flux pairs: HO2(6), O2(7); O(2), OH(5); +- equation: O(2) + H2O2(8) <=> OH(5) + HO2(6) # Reaction 3 + rate-constant: {A: 9.63e+06, b: 2.0, Ea: 4.0} + note: | + Reaction index: Chemkin #3; RMG #3 + Library reaction: GRI-Mech3.0 + Flux pairs: H2O2(8), HO2(6); O(2), OH(5); +- equation: O(2) + CH(9) <=> H(4) + CO(10) # Reaction 4 + rate-constant: {A: 5.7e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #4; RMG #4 + Library reaction: GRI-Mech3.0 + Flux pairs: CH(9), CO(10); O(2), H(4); +- equation: O(2) + CH2(11) <=> H(4) + HCO(12) # Reaction 5 + rate-constant: {A: 8.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #5; RMG #5 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), HCO(12); O(2), H(4); +- equation: O(2) + CH2(S)(13) <=> H2(3) + CO(10) # Reaction 6 + rate-constant: {A: 1.5e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #6; RMG #6 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CO(10); O(2), H2(3); +- equation: O(2) + CH2(S)(13) <=> H(4) + HCO(12) # Reaction 7 + rate-constant: {A: 1.5e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #7; RMG #7 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), HCO(12); O(2), H(4); +- equation: O(2) + CH3(14) <=> H(4) + CH2O(15) # Reaction 8 + rate-constant: {A: 5.06e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #8; RMG #8 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH2O(15); O(2), H(4); +- equation: O(2) + CH4(16) <=> OH(5) + CH3(14) # Reaction 9 + rate-constant: {A: 1.02e+09, b: 1.5, Ea: 8.6} + note: | + Reaction index: Chemkin #9; RMG #9 + Library reaction: GRI-Mech3.0 + Flux pairs: CH4(16), CH3(14); O(2), OH(5); +- equation: O(2) + HCO(12) <=> OH(5) + CO(10) # Reaction 10 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #10; RMG #10 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), CO(10); O(2), OH(5); +- equation: O(2) + HCO(12) <=> H(4) + CO2(17) # Reaction 11 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #11; RMG #11 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), CO2(17); O(2), H(4); +- equation: O(2) + CH2O(15) <=> OH(5) + HCO(12) # Reaction 12 + rate-constant: {A: 3.9e+13, b: 0.0, Ea: 3.54} + note: | + Reaction index: Chemkin #12; RMG #12 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2O(15), HCO(12); O(2), OH(5); +- equation: O(2) + CH2OH(18) <=> OH(5) + CH2O(15) # Reaction 13 + rate-constant: {A: 1.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #13; RMG #13 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2OH(18), CH2O(15); O(2), OH(5); +- equation: O(2) + CH3O(19) <=> OH(5) + CH2O(15) # Reaction 14 + rate-constant: {A: 1.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #14; RMG #14 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3O(19), CH2O(15); O(2), OH(5); +- equation: O(2) + CH3OH(20) <=> OH(5) + CH2OH(18) # Reaction 15 + rate-constant: {A: 3.88e+05, b: 2.5, Ea: 3.1} + note: | + Reaction index: Chemkin #15; RMG #15 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH2OH(18); O(2), OH(5); +- equation: O(2) + CH3OH(20) <=> OH(5) + CH3O(19) # Reaction 16 + rate-constant: {A: 1.3e+05, b: 2.5, Ea: 5.0} + note: | + Reaction index: Chemkin #16; RMG #16 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH3O(19); O(2), OH(5); +- equation: O(2) + C2H(21) <=> CO(10) + CH(9) # Reaction 17 + rate-constant: {A: 5.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #17; RMG #17 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H(21), CO(10); O(2), CH(9); +- equation: O(2) + C2H2(22) <=> H(4) + HCCO(23) # Reaction 18 + rate-constant: {A: 1.35e+07, b: 2.0, Ea: 1.9} + note: | + Reaction index: Chemkin #18; RMG #18 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H2(22), HCCO(23); O(2), H(4); +- equation: O(2) + C2H2(22) <=> OH(5) + C2H(21) # Reaction 19 + rate-constant: {A: 4.6e+19, b: -1.41, Ea: 28.95} + note: | + Reaction index: Chemkin #19; RMG #19 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H2(22), C2H(21); O(2), OH(5); +- equation: O(2) + C2H2(22) <=> CO(10) + CH2(11) # Reaction 20 + rate-constant: {A: 6.94e+06, b: 2.0, Ea: 1.9} + note: | + Reaction index: Chemkin #20; RMG #20 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H2(22), CO(10); O(2), CH2(11); +- equation: O(2) + C2H3(24) <=> H(4) + CH2CO(25) # Reaction 21 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #21; RMG #21 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H3(24), CH2CO(25); O(2), H(4); +- equation: O(2) + C2H4(26) <=> HCO(12) + CH3(14) # Reaction 22 + rate-constant: {A: 1.25e+07, b: 1.83, Ea: 0.22} + note: | + Reaction index: Chemkin #22; RMG #22 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H4(26), HCO(12); O(2), CH3(14); +- equation: O(2) + C2H5(27) <=> CH2O(15) + CH3(14) # Reaction 23 + rate-constant: {A: 2.24e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #23; RMG #23 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H5(27), CH2O(15); O(2), CH3(14); +- equation: O(2) + ethane(1) <=> OH(5) + C2H5(27) # Reaction 24 + rate-constant: {A: 8.98e+07, b: 1.92, Ea: 5.69} + note: | + Reaction index: Chemkin #24; RMG #24 + Library reaction: GRI-Mech3.0 + Flux pairs: ethane(1), C2H5(27); O(2), OH(5); +- equation: O(2) + HCCO(23) <=> H(4) + CO(10) + CO(10) # Reaction 25 + rate-constant: {A: 1.0e+14, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #25; RMG #25 + Library reaction: GRI-Mech3.0 + Flux pairs: HCCO(23), CO(10); O(2), H(4); O(2), CO(10); +- equation: O(2) + CH2CO(25) <=> OH(5) + HCCO(23) # Reaction 26 + rate-constant: {A: 1.0e+13, b: 0.0, Ea: 8.0} + note: | + Reaction index: Chemkin #26; RMG #26 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CO(25), HCCO(23); O(2), OH(5); +- equation: O(2) + CH2CO(25) <=> CO2(17) + CH2(11) # Reaction 27 + rate-constant: {A: 1.75e+12, b: 0.0, Ea: 1.35} + note: | + Reaction index: Chemkin #27; RMG #27 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CO(25), CO2(17); O(2), CH2(11); +- equation: O2(7) + CO(10) <=> O(2) + CO2(17) # Reaction 28 + rate-constant: {A: 2.5e+12, b: 0.0, Ea: 47.8} + note: | + Reaction index: Chemkin #28; RMG #28 + Library reaction: GRI-Mech3.0 + Flux pairs: CO(10), CO2(17); O2(7), O(2); +- equation: O2(7) + CH2O(15) <=> HO2(6) + HCO(12) # Reaction 29 + rate-constant: {A: 1.0e+14, b: 0.0, Ea: 40.0} + note: | + Reaction index: Chemkin #29; RMG #29 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2O(15), HCO(12); O2(7), HO2(6); +- equation: O2(7) + O2(7) + H(4) <=> O2(7) + HO2(6) # Reaction 30 + rate-constant: {A: 2.08e+19, b: -1.24, Ea: 0.0} + note: | + Reaction index: Chemkin #30; RMG #30 + Library reaction: GRI-Mech3.0 + Flux pairs: O2(7), HO2(6); H(4), O2(7); O2(7), O2(7); +- equation: O2(7) + H(4) + H2O(28) <=> HO2(6) + H2O(28) # Reaction 31 + rate-constant: {A: 1.126e+19, b: -0.76, Ea: 0.0} + note: | + Reaction index: Chemkin #31; RMG #31 + Library reaction: GRI-Mech3.0 + Flux pairs: O2(7), HO2(6); H(4), H2O(28); H2O(28), H2O(28); +- equation: O2(7) + H(4) <=> O(2) + OH(5) # Reaction 32 + rate-constant: {A: 2.65e+16, b: -0.671, Ea: 17.041} + note: | + Reaction index: Chemkin #32; RMG #32 + Library reaction: GRI-Mech3.0 + Flux pairs: O2(7), OH(5); H(4), O(2); +- equation: H(4) + H(4) + H2(3) <=> H2(3) + H2(3) # Reaction 33 + rate-constant: {A: 9.0e+16, b: -0.6, Ea: 0.0} + note: | + Reaction index: Chemkin #33; RMG #33 + Library reaction: GRI-Mech3.0 + Flux pairs: H2(3), H2(3); H(4), H2(3); H(4), H2(3); +- equation: H(4) + H(4) + H2O(28) <=> H2(3) + H2O(28) # Reaction 34 + rate-constant: {A: 6.0e+19, b: -1.25, Ea: 0.0} + note: | + Reaction index: Chemkin #34; RMG #34 + Library reaction: GRI-Mech3.0 + Flux pairs: H2O(28), H2O(28); H(4), H2(3); H(4), H2(3); +- equation: H(4) + H(4) + CO2(17) <=> H2(3) + CO2(17) # Reaction 35 + rate-constant: {A: 5.5e+20, b: -2.0, Ea: 0.0} + note: | + Reaction index: Chemkin #35; RMG #35 + Library reaction: GRI-Mech3.0 + Flux pairs: CO2(17), CO2(17); H(4), H2(3); H(4), H2(3); +- equation: H(4) + HO2(6) <=> O(2) + H2O(28) # Reaction 36 + rate-constant: {A: 3.97e+12, b: 0.0, Ea: 0.671} + note: | + Reaction index: Chemkin #36; RMG #36 + Library reaction: GRI-Mech3.0 + Flux pairs: HO2(6), H2O(28); H(4), O(2); +- equation: H(4) + HO2(6) <=> O2(7) + H2(3) # Reaction 37 + rate-constant: {A: 4.48e+13, b: 0.0, Ea: 1.068} + note: | + Reaction index: Chemkin #37; RMG #37 + Library reaction: GRI-Mech3.0 + Flux pairs: HO2(6), O2(7); H(4), H2(3); +- equation: H(4) + HO2(6) <=> OH(5) + OH(5) # Reaction 38 + rate-constant: {A: 8.4e+13, b: 0.0, Ea: 0.635} + note: | + Reaction index: Chemkin #38; RMG #38 + Library reaction: GRI-Mech3.0 + Flux pairs: HO2(6), OH(5); H(4), OH(5); +- equation: H(4) + H2O2(8) <=> HO2(6) + H2(3) # Reaction 39 + rate-constant: {A: 1.21e+07, b: 2.0, Ea: 5.2} + note: | + Reaction index: Chemkin #39; RMG #39 + Library reaction: GRI-Mech3.0 + Flux pairs: H2O2(8), HO2(6); H(4), H2(3); +- equation: H(4) + H2O2(8) <=> OH(5) + H2O(28) # Reaction 40 + rate-constant: {A: 1.0e+13, b: 0.0, Ea: 3.6} + note: | + Reaction index: Chemkin #40; RMG #40 + Library reaction: GRI-Mech3.0 + Flux pairs: H2O2(8), H2O(28); H(4), OH(5); +- equation: H(4) + CH(9) <=> H2(3) + C(29) # Reaction 41 + rate-constant: {A: 1.65e+14, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #41; RMG #41 + Library reaction: GRI-Mech3.0 + Flux pairs: CH(9), C(29); H(4), H2(3); +- equation: H(4) + CH2(S)(13) <=> H2(3) + CH(9) # Reaction 42 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #42; RMG #42 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CH(9); H(4), H2(3); +- equation: H(4) + CH4(16) <=> H2(3) + CH3(14) # Reaction 43 + rate-constant: {A: 6.6e+08, b: 1.62, Ea: 10.84} + note: | + Reaction index: Chemkin #43; RMG #43 + Library reaction: GRI-Mech3.0 + Flux pairs: CH4(16), CH3(14); H(4), H2(3); +- equation: H(4) + HCO(12) <=> H2(3) + CO(10) # Reaction 44 + rate-constant: {A: 7.34e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #44; RMG #44 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), CO(10); H(4), H2(3); +- equation: H(4) + CH2O(15) <=> H2(3) + HCO(12) # Reaction 45 + rate-constant: {A: 5.74e+07, b: 1.9, Ea: 2.742} + note: | + Reaction index: Chemkin #45; RMG #45 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2O(15), HCO(12); H(4), H2(3); +- equation: H(4) + CH2OH(18) <=> H2(3) + CH2O(15) # Reaction 46 + rate-constant: {A: 2.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #46; RMG #46 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2OH(18), CH2O(15); H(4), H2(3); +- equation: H(4) + CH2OH(18) <=> OH(5) + CH3(14) # Reaction 47 + rate-constant: {A: 1.65e+11, b: 0.65, Ea: -0.284} + note: | + Reaction index: Chemkin #47; RMG #47 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2OH(18), CH3(14); H(4), OH(5); +- equation: H(4) + CH2OH(18) <=> H2O(28) + CH2(S)(13) # Reaction 48 + rate-constant: {A: 3.28e+13, b: -0.09, Ea: 0.61} + note: | + Reaction index: Chemkin #48; RMG #48 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2OH(18), CH2(S)(13); H(4), H2O(28); +- equation: H(4) + CH3O(19) <=> H(4) + CH2OH(18) # Reaction 49 + rate-constant: {A: 4.15e+07, b: 1.63, Ea: 1.924} + note: | + Reaction index: Chemkin #49; RMG #49 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3O(19), CH2OH(18); H(4), H(4); +- equation: H(4) + CH3O(19) <=> H2(3) + CH2O(15) # Reaction 50 + rate-constant: {A: 2.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #50; RMG #50 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3O(19), CH2O(15); H(4), H2(3); +- equation: H(4) + CH3O(19) <=> OH(5) + CH3(14) # Reaction 51 + rate-constant: {A: 1.5e+12, b: 0.5, Ea: -0.11} + note: | + Reaction index: Chemkin #51; RMG #51 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3O(19), CH3(14); H(4), OH(5); +- equation: H(4) + CH3O(19) <=> H2O(28) + CH2(S)(13) # Reaction 52 + rate-constant: {A: 2.62e+14, b: -0.23, Ea: 1.07} + note: | + Reaction index: Chemkin #52; RMG #52 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3O(19), CH2(S)(13); H(4), H2O(28); +- equation: H(4) + CH3OH(20) <=> H2(3) + CH2OH(18) # Reaction 53 + rate-constant: {A: 1.7e+07, b: 2.1, Ea: 4.87} + note: | + Reaction index: Chemkin #53; RMG #53 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH2OH(18); H(4), H2(3); +- equation: H(4) + CH3OH(20) <=> H2(3) + CH3O(19) # Reaction 54 + rate-constant: {A: 4.2e+06, b: 2.1, Ea: 4.87} + note: | + Reaction index: Chemkin #54; RMG #54 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH3O(19); H(4), H2(3); +- equation: H(4) + C2H3(24) <=> H2(3) + C2H2(22) # Reaction 55 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #55; RMG #55 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H3(24), C2H2(22); H(4), H2(3); +- equation: H(4) + C2H4(26) <=> H2(3) + C2H3(24) # Reaction 56 + rate-constant: {A: 1.325e+06, b: 2.53, Ea: 12.24} + note: | + Reaction index: Chemkin #56; RMG #56 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H4(26), C2H3(24); H(4), H2(3); +- equation: H(4) + C2H5(27) <=> H2(3) + C2H4(26) # Reaction 57 + rate-constant: {A: 2.0e+12, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #57; RMG #57 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H5(27), C2H4(26); H(4), H2(3); +- equation: H(4) + ethane(1) <=> H2(3) + C2H5(27) # Reaction 58 + rate-constant: {A: 1.15e+08, b: 1.9, Ea: 7.53} + note: | + Reaction index: Chemkin #58; RMG #58 + Library reaction: GRI-Mech3.0 + Flux pairs: ethane(1), C2H5(27); H(4), H2(3); +- equation: H(4) + HCCO(23) <=> CO(10) + CH2(S)(13) # Reaction 59 + rate-constant: {A: 1.0e+14, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #59; RMG #59 + Library reaction: GRI-Mech3.0 + Flux pairs: HCCO(23), CO(10); H(4), CH2(S)(13); +- equation: H(4) + CH2CO(25) <=> H2(3) + HCCO(23) # Reaction 60 + rate-constant: {A: 5.0e+13, b: 0.0, Ea: 8.0} + note: | + Reaction index: Chemkin #60; RMG #60 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CO(25), HCCO(23); H(4), H2(3); +- equation: H(4) + CH2CO(25) <=> CO(10) + CH3(14) # Reaction 61 + rate-constant: {A: 1.13e+13, b: 0.0, Ea: 3.428} + note: | + Reaction index: Chemkin #61; RMG #61 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CO(25), CO(10); H(4), CH3(14); +- equation: H(4) + HCCOH(30) <=> H(4) + CH2CO(25) # Reaction 62 + rate-constant: {A: 1.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #62; RMG #62 + Library reaction: GRI-Mech3.0 + Flux pairs: HCCOH(30), CH2CO(25); H(4), H(4); +- equation: OH(5) + H2(3) <=> H(4) + H2O(28) # Reaction 63 + rate-constant: {A: 2.16e+08, b: 1.51, Ea: 3.43} + note: | + Reaction index: Chemkin #63; RMG #63 + Library reaction: GRI-Mech3.0 + Flux pairs: OH(5), H2O(28); H2(3), H(4); +- equation: OH(5) + OH(5) <=> O(2) + H2O(28) # Reaction 64 + rate-constant: {A: 3.57e+04, b: 2.4, Ea: -2.11} + note: | + Reaction index: Chemkin #64; RMG #64 + Library reaction: GRI-Mech3.0 + Flux pairs: OH(5), H2O(28); OH(5), O(2); +- equation: OH(5) + HO2(6) <=> O2(7) + H2O(28) # Reaction 65 + duplicate: true + rate-constant: {A: 1.45e+13, b: 0.0, Ea: -0.5} + note: | + Reaction index: Chemkin #65; RMG #65 + Library reaction: GRI-Mech3.0 +- equation: OH(5) + HO2(6) <=> O2(7) + H2O(28) # Reaction 66 + duplicate: true + rate-constant: {A: 5.0e+15, b: 0.0, Ea: 17.33} + note: | + Reaction index: Chemkin #66; RMG #65 + Library reaction: GRI-Mech3.0 +- equation: OH(5) + H2O2(8) <=> HO2(6) + H2O(28) # Reaction 67 + duplicate: true + rate-constant: {A: 2.0e+12, b: 0.0, Ea: 0.427} + note: | + Reaction index: Chemkin #67; RMG #66 + Library reaction: GRI-Mech3.0 +- equation: OH(5) + H2O2(8) <=> HO2(6) + H2O(28) # Reaction 68 + duplicate: true + rate-constant: {A: 1.7e+18, b: 0.0, Ea: 29.41} + note: | + Reaction index: Chemkin #68; RMG #66 + Library reaction: GRI-Mech3.0 +- equation: OH(5) + C(29) <=> H(4) + CO(10) # Reaction 69 + rate-constant: {A: 5.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #69; RMG #67 + Library reaction: GRI-Mech3.0 + Flux pairs: C(29), CO(10); OH(5), H(4); +- equation: OH(5) + CH(9) <=> H(4) + HCO(12) # Reaction 70 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #70; RMG #68 + Library reaction: GRI-Mech3.0 + Flux pairs: CH(9), HCO(12); OH(5), H(4); +- equation: OH(5) + CH2(11) <=> H(4) + CH2O(15) # Reaction 71 + rate-constant: {A: 2.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #71; RMG #69 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), CH2O(15); OH(5), H(4); +- equation: OH(5) + CH2(11) <=> H2O(28) + CH(9) # Reaction 72 + rate-constant: {A: 1.13e+07, b: 2.0, Ea: 3.0} + note: | + Reaction index: Chemkin #72; RMG #70 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), CH(9); OH(5), H2O(28); +- equation: OH(5) + CH2(S)(13) <=> H(4) + CH2O(15) # Reaction 73 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #73; RMG #71 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CH2O(15); OH(5), H(4); +- equation: OH(5) + CH3(14) <=> H2O(28) + CH2(11) # Reaction 74 + rate-constant: {A: 5.6e+07, b: 1.6, Ea: 5.42} + note: | + Reaction index: Chemkin #74; RMG #72 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH2(11); OH(5), H2O(28); +- equation: OH(5) + CH3(14) <=> H2O(28) + CH2(S)(13) # Reaction 75 + rate-constant: {A: 6.44e+17, b: -1.34, Ea: 1.417} + note: | + Reaction index: Chemkin #75; RMG #73 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH2(S)(13); OH(5), H2O(28); +- equation: OH(5) + CH4(16) <=> H2O(28) + CH3(14) # Reaction 76 + rate-constant: {A: 1.0e+08, b: 1.6, Ea: 3.12} + note: | + Reaction index: Chemkin #76; RMG #74 + Library reaction: GRI-Mech3.0 + Flux pairs: CH4(16), CH3(14); OH(5), H2O(28); +- equation: OH(5) + CO(10) <=> H(4) + CO2(17) # Reaction 77 + rate-constant: {A: 4.76e+07, b: 1.228, Ea: 0.07} + note: | + Reaction index: Chemkin #77; RMG #75 + Library reaction: GRI-Mech3.0 + Flux pairs: CO(10), CO2(17); OH(5), H(4); +- equation: OH(5) + HCO(12) <=> H2O(28) + CO(10) # Reaction 78 + rate-constant: {A: 5.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #78; RMG #76 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), CO(10); OH(5), H2O(28); +- equation: OH(5) + CH2O(15) <=> H2O(28) + HCO(12) # Reaction 79 + rate-constant: {A: 3.43e+09, b: 1.18, Ea: -0.447} + note: | + Reaction index: Chemkin #79; RMG #77 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2O(15), HCO(12); OH(5), H2O(28); +- equation: OH(5) + CH2OH(18) <=> H2O(28) + CH2O(15) # Reaction 80 + rate-constant: {A: 5.0e+12, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #80; RMG #78 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2OH(18), CH2O(15); OH(5), H2O(28); +- equation: OH(5) + CH3O(19) <=> H2O(28) + CH2O(15) # Reaction 81 + rate-constant: {A: 5.0e+12, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #81; RMG #79 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3O(19), CH2O(15); OH(5), H2O(28); +- equation: OH(5) + CH3OH(20) <=> H2O(28) + CH2OH(18) # Reaction 82 + rate-constant: {A: 1.44e+06, b: 2.0, Ea: -0.84} + note: | + Reaction index: Chemkin #82; RMG #80 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH2OH(18); OH(5), H2O(28); +- equation: OH(5) + CH3OH(20) <=> H2O(28) + CH3O(19) # Reaction 83 + rate-constant: {A: 6.3e+06, b: 2.0, Ea: 1.5} + note: | + Reaction index: Chemkin #83; RMG #81 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH3O(19); OH(5), H2O(28); +- equation: OH(5) + C2H(21) <=> H(4) + HCCO(23) # Reaction 84 + rate-constant: {A: 2.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #84; RMG #82 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H(21), HCCO(23); OH(5), H(4); +- equation: OH(5) + C2H2(22) <=> H(4) + CH2CO(25) # Reaction 85 + rate-constant: {A: 2.18e-04, b: 4.5, Ea: -1.0} + note: | + Reaction index: Chemkin #85; RMG #83 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H2(22), CH2CO(25); OH(5), H(4); +- equation: OH(5) + C2H2(22) <=> H(4) + HCCOH(30) # Reaction 86 + rate-constant: {A: 5.04e+05, b: 2.3, Ea: 13.5} + note: | + Reaction index: Chemkin #86; RMG #84 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H2(22), HCCOH(30); OH(5), H(4); +- equation: OH(5) + C2H2(22) <=> H2O(28) + C2H(21) # Reaction 87 + rate-constant: {A: 3.37e+07, b: 2.0, Ea: 14.0} + note: | + Reaction index: Chemkin #87; RMG #85 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H2(22), C2H(21); OH(5), H2O(28); +- equation: OH(5) + C2H2(22) <=> CO(10) + CH3(14) # Reaction 88 + rate-constant: {A: 4.83e-04, b: 4.0, Ea: -2.0} + note: | + Reaction index: Chemkin #88; RMG #86 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H2(22), CO(10); OH(5), CH3(14); +- equation: OH(5) + C2H3(24) <=> H2O(28) + C2H2(22) # Reaction 89 + rate-constant: {A: 5.0e+12, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #89; RMG #87 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H3(24), C2H2(22); OH(5), H2O(28); +- equation: OH(5) + C2H4(26) <=> H2O(28) + C2H3(24) # Reaction 90 + rate-constant: {A: 3.6e+06, b: 2.0, Ea: 2.5} + note: | + Reaction index: Chemkin #90; RMG #88 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H4(26), C2H3(24); OH(5), H2O(28); +- equation: OH(5) + ethane(1) <=> H2O(28) + C2H5(27) # Reaction 91 + rate-constant: {A: 3.54e+06, b: 2.12, Ea: 0.87} + note: | + Reaction index: Chemkin #91; RMG #89 + Library reaction: GRI-Mech3.0 + Flux pairs: ethane(1), C2H5(27); OH(5), H2O(28); +- equation: OH(5) + CH2CO(25) <=> H2O(28) + HCCO(23) # Reaction 92 + rate-constant: {A: 7.5e+12, b: 0.0, Ea: 2.0} + note: | + Reaction index: Chemkin #92; RMG #90 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CO(25), HCCO(23); OH(5), H2O(28); +- equation: HO2(6) + HO2(6) <=> O2(7) + H2O2(8) # Reaction 93 + duplicate: true + rate-constant: {A: 1.3e+11, b: 0.0, Ea: -1.63} + note: | + Reaction index: Chemkin #93; RMG #91 + Library reaction: GRI-Mech3.0 +- equation: HO2(6) + HO2(6) <=> O2(7) + H2O2(8) # Reaction 94 + duplicate: true + rate-constant: {A: 4.2e+14, b: 0.0, Ea: 12.0} + note: | + Reaction index: Chemkin #94; RMG #91 + Library reaction: GRI-Mech3.0 +- equation: HO2(6) + CH2(11) <=> OH(5) + CH2O(15) # Reaction 95 + rate-constant: {A: 2.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #95; RMG #92 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), CH2O(15); HO2(6), OH(5); +- equation: HO2(6) + CH3(14) <=> O2(7) + CH4(16) # Reaction 96 + rate-constant: {A: 1.0e+12, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #96; RMG #93 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH4(16); HO2(6), O2(7); +- equation: HO2(6) + CH3(14) <=> OH(5) + CH3O(19) # Reaction 97 + rate-constant: {A: 3.78e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #97; RMG #94 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH3O(19); HO2(6), OH(5); +- equation: HO2(6) + CO(10) <=> OH(5) + CO2(17) # Reaction 98 + rate-constant: {A: 1.5e+14, b: 0.0, Ea: 23.6} + note: | + Reaction index: Chemkin #98; RMG #95 + Library reaction: GRI-Mech3.0 + Flux pairs: CO(10), CO2(17); HO2(6), OH(5); +- equation: HO2(6) + CH2O(15) <=> H2O2(8) + HCO(12) # Reaction 99 + rate-constant: {A: 5.6e+06, b: 2.0, Ea: 12.0} + note: | + Reaction index: Chemkin #99; RMG #96 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2O(15), HCO(12); HO2(6), H2O2(8); +- equation: O2(7) + C(29) <=> O(2) + CO(10) # Reaction 100 + rate-constant: {A: 5.8e+13, b: 0.0, Ea: 0.576} + note: | + Reaction index: Chemkin #100; RMG #97 + Library reaction: GRI-Mech3.0 + Flux pairs: C(29), CO(10); O2(7), O(2); +- equation: C(29) + CH2(11) <=> H(4) + C2H(21) # Reaction 101 + rate-constant: {A: 5.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #101; RMG #98 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), C2H(21); C(29), H(4); +- equation: C(29) + CH3(14) <=> H(4) + C2H2(22) # Reaction 102 + rate-constant: {A: 5.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #102; RMG #99 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), C2H2(22); C(29), H(4); +- equation: O2(7) + CH(9) <=> O(2) + HCO(12) # Reaction 103 + rate-constant: {A: 6.71e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #103; RMG #100 + Library reaction: GRI-Mech3.0 + Flux pairs: CH(9), HCO(12); O2(7), O(2); +- equation: H2(3) + CH(9) <=> H(4) + CH2(11) # Reaction 104 + rate-constant: {A: 1.08e+14, b: 0.0, Ea: 3.11} + note: | + Reaction index: Chemkin #104; RMG #101 + Library reaction: GRI-Mech3.0 + Flux pairs: CH(9), CH2(11); H2(3), H(4); +- equation: H2O(28) + CH(9) <=> H(4) + CH2O(15) # Reaction 105 + rate-constant: {A: 5.71e+12, b: 0.0, Ea: -0.755} + note: | + Reaction index: Chemkin #105; RMG #102 + Library reaction: GRI-Mech3.0 + Flux pairs: CH(9), CH2O(15); H2O(28), H(4); +- equation: CH(9) + CH2(11) <=> H(4) + C2H2(22) # Reaction 106 + rate-constant: {A: 4.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #106; RMG #103 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), C2H2(22); CH(9), H(4); +- equation: CH(9) + CH3(14) <=> H(4) + C2H3(24) # Reaction 107 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #107; RMG #104 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), C2H3(24); CH(9), H(4); +- equation: CH(9) + CH4(16) <=> H(4) + C2H4(26) # Reaction 108 + rate-constant: {A: 6.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #108; RMG #105 + Library reaction: GRI-Mech3.0 + Flux pairs: CH4(16), C2H4(26); CH(9), H(4); +- equation: CO2(17) + CH(9) <=> CO(10) + HCO(12) # Reaction 109 + rate-constant: {A: 1.9e+14, b: 0.0, Ea: 15.792} + note: | + Reaction index: Chemkin #109; RMG #106 + Library reaction: GRI-Mech3.0 + Flux pairs: CO2(17), HCO(12); CH(9), CO(10); +- equation: CH(9) + CH2O(15) <=> H(4) + CH2CO(25) # Reaction 110 + rate-constant: {A: 9.46e+13, b: 0.0, Ea: -0.515} + note: | + Reaction index: Chemkin #110; RMG #107 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2O(15), CH2CO(25); CH(9), H(4); +- equation: CH(9) + HCCO(23) <=> CO(10) + C2H2(22) # Reaction 111 + rate-constant: {A: 5.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #111; RMG #108 + Library reaction: GRI-Mech3.0 + Flux pairs: HCCO(23), C2H2(22); CH(9), CO(10); +- equation: O2(7) + CH2(11) => H(4) + OH(5) + CO(10) # Reaction 112 + rate-constant: {A: 5.0e+12, b: 0.0, Ea: 1.5} + note: | + Reaction index: Chemkin #112; RMG #109 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), CO(10); O2(7), H(4); O2(7), OH(5); +- equation: H2(3) + CH2(11) <=> H(4) + CH3(14) # Reaction 113 + rate-constant: {A: 5.0e+05, b: 2.0, Ea: 7.23} + note: | + Reaction index: Chemkin #113; RMG #110 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), CH3(14); H2(3), H(4); +- equation: CH2(11) + CH2(11) <=> H2(3) + C2H2(22) # Reaction 114 + rate-constant: {A: 1.6e+15, b: 0.0, Ea: 11.944} + note: | + Reaction index: Chemkin #114; RMG #111 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), C2H2(22); CH2(11), H2(3); +- equation: CH2(11) + CH3(14) <=> H(4) + C2H4(26) # Reaction 115 + rate-constant: {A: 4.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #115; RMG #112 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), C2H4(26); CH2(11), H(4); +- equation: CH2(11) + CH4(16) <=> CH3(14) + CH3(14) # Reaction 116 + rate-constant: {A: 2.46e+06, b: 2.0, Ea: 8.27} + note: | + Reaction index: Chemkin #116; RMG #113 + Library reaction: GRI-Mech3.0 + Flux pairs: CH4(16), CH3(14); CH2(11), CH3(14); +- equation: CH2(11) + HCCO(23) <=> CO(10) + C2H3(24) # Reaction 117 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #117; RMG #114 + Library reaction: GRI-Mech3.0 + Flux pairs: HCCO(23), C2H3(24); CH2(11), CO(10); +- equation: O2(7) + CH2(S)(13) <=> H(4) + OH(5) + CO(10) # Reaction 118 + rate-constant: {A: 2.8e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #118; RMG #115 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CO(10); O2(7), H(4); O2(7), OH(5); +- equation: O2(7) + CH2(S)(13) <=> H2O(28) + CO(10) # Reaction 119 + rate-constant: {A: 1.2e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #119; RMG #116 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CO(10); O2(7), H2O(28); +- equation: H2(3) + CH2(S)(13) <=> H(4) + CH3(14) # Reaction 120 + rate-constant: {A: 7.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #120; RMG #117 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CH3(14); H2(3), H(4); +- equation: H2O(28) + CH2(S)(13) <=> H2O(28) + CH2(11) # Reaction 121 + rate-constant: {A: 3.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #121; RMG #118 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CH2(11); H2O(28), H2O(28); +- equation: CH2(S)(13) + CH3(14) <=> H(4) + C2H4(26) # Reaction 122 + rate-constant: {A: 1.2e+13, b: 0.0, Ea: -0.57} + note: | + Reaction index: Chemkin #122; RMG #119 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), C2H4(26); CH2(S)(13), H(4); +- equation: CH2(S)(13) + CH4(16) <=> CH3(14) + CH3(14) # Reaction 123 + rate-constant: {A: 1.6e+13, b: 0.0, Ea: -0.57} + note: | + Reaction index: Chemkin #123; RMG #120 + Library reaction: GRI-Mech3.0 + Flux pairs: CH4(16), CH3(14); CH2(S)(13), CH3(14); +- equation: CO(10) + CH2(S)(13) <=> CO(10) + CH2(11) # Reaction 124 + rate-constant: {A: 9.0e+12, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #124; RMG #121 + Library reaction: GRI-Mech3.0 + Flux pairs: CO(10), CO(10); CH2(S)(13), CH2(11); +- equation: CO2(17) + CH2(S)(13) <=> CO2(17) + CH2(11) # Reaction 125 + rate-constant: {A: 7.0e+12, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #125; RMG #122 + Library reaction: GRI-Mech3.0 + Flux pairs: CO2(17), CO2(17); CH2(S)(13), CH2(11); +- equation: CO2(17) + CH2(S)(13) <=> CO(10) + CH2O(15) # Reaction 126 + rate-constant: {A: 1.4e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #126; RMG #123 + Library reaction: GRI-Mech3.0 + Flux pairs: CO2(17), CH2O(15); CH2(S)(13), CO(10); +- equation: CH2(S)(13) + ethane(1) <=> CH3(14) + C2H5(27) # Reaction 127 + rate-constant: {A: 4.0e+13, b: 0.0, Ea: -0.55} + note: | + Reaction index: Chemkin #127; RMG #124 + Library reaction: GRI-Mech3.0 + Flux pairs: ethane(1), C2H5(27); CH2(S)(13), CH3(14); +- equation: O2(7) + CH3(14) <=> O(2) + CH3O(19) # Reaction 128 + rate-constant: {A: 3.56e+13, b: 0.0, Ea: 30.48} + note: | + Reaction index: Chemkin #128; RMG #125 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH3O(19); O2(7), O(2); +- equation: O2(7) + CH3(14) <=> OH(5) + CH2O(15) # Reaction 129 + rate-constant: {A: 2.31e+12, b: 0.0, Ea: 20.315} + note: | + Reaction index: Chemkin #129; RMG #126 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH2O(15); O2(7), OH(5); +- equation: H2O2(8) + CH3(14) <=> HO2(6) + CH4(16) # Reaction 130 + rate-constant: {A: 2.45e+04, b: 2.47, Ea: 5.18} + note: | + Reaction index: Chemkin #130; RMG #127 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH4(16); H2O2(8), HO2(6); +- equation: CH3(14) + CH3(14) <=> H(4) + C2H5(27) # Reaction 131 + rate-constant: {A: 6.84e+12, b: 0.1, Ea: 10.6} + note: | + Reaction index: Chemkin #131; RMG #128 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), C2H5(27); CH3(14), H(4); +- equation: HCO(12) + CH3(14) <=> CO(10) + CH4(16) # Reaction 132 + rate-constant: {A: 2.648e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #132; RMG #129 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), CO(10); CH3(14), CH4(16); +- equation: CH2O(15) + CH3(14) <=> HCO(12) + CH4(16) # Reaction 133 + rate-constant: {A: 3320.0, b: 2.81, Ea: 5.86} + note: | + Reaction index: Chemkin #133; RMG #130 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2O(15), HCO(12); CH3(14), CH4(16); +- equation: CH3(14) + CH3OH(20) <=> CH2OH(18) + CH4(16) # Reaction 134 + rate-constant: {A: 3.0e+07, b: 1.5, Ea: 9.94} + note: | + Reaction index: Chemkin #134; RMG #131 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH2OH(18); CH3(14), CH4(16); +- equation: CH3(14) + CH3OH(20) <=> CH3O(19) + CH4(16) # Reaction 135 + rate-constant: {A: 1.0e+07, b: 1.5, Ea: 9.94} + note: | + Reaction index: Chemkin #135; RMG #132 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3OH(20), CH3O(19); CH3(14), CH4(16); +- equation: CH3(14) + C2H4(26) <=> CH4(16) + C2H3(24) # Reaction 136 + rate-constant: {A: 2.27e+05, b: 2.0, Ea: 9.2} + note: | + Reaction index: Chemkin #136; RMG #133 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H4(26), C2H3(24); CH3(14), CH4(16); +- equation: CH3(14) + ethane(1) <=> CH4(16) + C2H5(27) # Reaction 137 + rate-constant: {A: 6.14e+06, b: 1.74, Ea: 10.45} + note: | + Reaction index: Chemkin #137; RMG #134 + Library reaction: GRI-Mech3.0 + Flux pairs: ethane(1), C2H5(27); CH3(14), CH4(16); +- equation: H2O(28) + HCO(12) <=> H(4) + H2O(28) + CO(10) # Reaction 138 + rate-constant: {A: 1.5e+18, b: -1.0, Ea: 17.0} + note: | + Reaction index: Chemkin #138; RMG #135 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), CO(10); H2O(28), H(4); H2O(28), H2O(28); +- equation: O2(7) + HCO(12) <=> HO2(6) + CO(10) # Reaction 139 + rate-constant: {A: 1.345e+13, b: 0.0, Ea: 0.4} + note: | + Reaction index: Chemkin #139; RMG #136 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), CO(10); O2(7), HO2(6); +- equation: O2(7) + CH2OH(18) <=> HO2(6) + CH2O(15) # Reaction 140 + rate-constant: {A: 1.8e+13, b: 0.0, Ea: 0.9} + note: | + Reaction index: Chemkin #140; RMG #137 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2OH(18), CH2O(15); O2(7), HO2(6); +- equation: O2(7) + CH3O(19) <=> HO2(6) + CH2O(15) # Reaction 141 + rate-constant: {A: 4.28e-13, b: 7.6, Ea: -3.53} + note: | + Reaction index: Chemkin #141; RMG #138 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3O(19), CH2O(15); O2(7), HO2(6); +- equation: O2(7) + C2H(21) <=> CO(10) + HCO(12) # Reaction 142 + rate-constant: {A: 1.0e+13, b: 0.0, Ea: -0.755} + note: | + Reaction index: Chemkin #142; RMG #139 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H(21), HCO(12); O2(7), CO(10); +- equation: H2(3) + C2H(21) <=> H(4) + C2H2(22) # Reaction 143 + rate-constant: {A: 5.68e+10, b: 0.9, Ea: 1.993} + note: | + Reaction index: Chemkin #143; RMG #140 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H(21), C2H2(22); H2(3), H(4); +- equation: O2(7) + C2H3(24) <=> HCO(12) + CH2O(15) # Reaction 144 + rate-constant: {A: 4.58e+16, b: -1.39, Ea: 1.015} + note: | + Reaction index: Chemkin #144; RMG #141 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H3(24), CH2O(15); O2(7), HCO(12); +- equation: O2(7) + C2H5(27) <=> HO2(6) + C2H4(26) # Reaction 145 + rate-constant: {A: 8.4e+11, b: 0.0, Ea: 3.875} + note: | + Reaction index: Chemkin #145; RMG #142 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H5(27), C2H4(26); O2(7), HO2(6); +- equation: O2(7) + HCCO(23) <=> OH(5) + CO(10) + CO(10) # Reaction 146 + rate-constant: {A: 3.2e+12, b: 0.0, Ea: 0.854} + note: | + Reaction index: Chemkin #146; RMG #143 + Library reaction: GRI-Mech3.0 + Flux pairs: HCCO(23), CO(10); O2(7), OH(5); O2(7), CO(10); +- equation: HCCO(23) + HCCO(23) <=> CO(10) + CO(10) + C2H2(22) # Reaction 147 + rate-constant: {A: 1.0e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #147; RMG #144 + Library reaction: GRI-Mech3.0 + Flux pairs: HCCO(23), C2H2(22); HCCO(23), CO(10); HCCO(23), CO(10); +- equation: O(2) + CH3(14) => H(4) + H2(3) + CO(10) # Reaction 148 + rate-constant: {A: 3.37e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #148; RMG #145 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CO(10); O(2), H(4); O(2), H2(3); +- equation: O(2) + C2H4(26) <=> H(4) + CH2CHO(31) # Reaction 149 + rate-constant: {A: 6.7e+06, b: 1.83, Ea: 0.22} + note: | + Reaction index: Chemkin #149; RMG #146 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H4(26), CH2CHO(31); O(2), H(4); +- equation: O(2) + C2H5(27) <=> H(4) + CH3CHO(32) # Reaction 150 + rate-constant: {A: 1.096e+14, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #150; RMG #147 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H5(27), CH3CHO(32); O(2), H(4); +- equation: OH(5) + CH3(14) => H2(3) + CH2O(15) # Reaction 151 + rate-constant: {A: 8.0e+09, b: 0.5, Ea: -1.755} + note: | + Reaction index: Chemkin #151; RMG #148 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), CH2O(15); OH(5), H2(3); +- equation: O2(7) + CH2(11) => H(4) + H(4) + CO2(17) # Reaction 152 + rate-constant: {A: 5.8e+12, b: 0.0, Ea: 1.5} + note: | + Reaction index: Chemkin #152; RMG #149 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), CO2(17); O2(7), H(4); O2(7), H(4); +- equation: O2(7) + CH2(11) <=> O(2) + CH2O(15) # Reaction 153 + rate-constant: {A: 2.4e+12, b: 0.0, Ea: 1.5} + note: | + Reaction index: Chemkin #153; RMG #150 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), CH2O(15); O2(7), O(2); +- equation: CH2(11) + CH2(11) => H(4) + H(4) + C2H2(22) # Reaction 154 + rate-constant: {A: 2.0e+14, b: 0.0, Ea: 10.989} + note: | + Reaction index: Chemkin #154; RMG #151 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(11), C2H2(22); CH2(11), H(4); CH2(11), H(4); +- equation: H2O(28) + CH2(S)(13) => H2(3) + CH2O(15) # Reaction 155 + rate-constant: {A: 6.82e+10, b: 0.25, Ea: -0.935} + note: | + Reaction index: Chemkin #155; RMG #152 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2(S)(13), CH2O(15); H2O(28), H2(3); +- equation: O2(7) + C2H3(24) <=> O(2) + CH2CHO(31) # Reaction 156 + rate-constant: {A: 3.03e+11, b: 0.29, Ea: 0.011} + note: | + Reaction index: Chemkin #156; RMG #153 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H3(24), CH2CHO(31); O2(7), O(2); +- equation: O2(7) + C2H3(24) <=> HO2(6) + C2H2(22) # Reaction 157 + rate-constant: {A: 1.337e+06, b: 1.61, Ea: -0.384} + note: | + Reaction index: Chemkin #157; RMG #154 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H3(24), C2H2(22); O2(7), HO2(6); +- equation: O(2) + CH3CHO(32) <=> OH(5) + CH2CHO(31) # Reaction 158 + rate-constant: {A: 2.92e+12, b: 0.0, Ea: 1.808} + note: | + Reaction index: Chemkin #158; RMG #155 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CH2CHO(31); O(2), OH(5); +- equation: O(2) + CH3CHO(32) => OH(5) + CO(10) + CH3(14) # Reaction 159 + rate-constant: {A: 2.92e+12, b: 0.0, Ea: 1.808} + note: | + Reaction index: Chemkin #159; RMG #156 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CO(10); O(2), OH(5); O(2), CH3(14); +- equation: O2(7) + CH3CHO(32) => HO2(6) + CO(10) + CH3(14) # Reaction 160 + rate-constant: {A: 3.01e+13, b: 0.0, Ea: 39.15} + note: | + Reaction index: Chemkin #160; RMG #157 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CO(10); O2(7), HO2(6); O2(7), CH3(14); +- equation: H(4) + CH3CHO(32) <=> H2(3) + CH2CHO(31) # Reaction 161 + rate-constant: {A: 2.05e+09, b: 1.16, Ea: 2.405} + note: | + Reaction index: Chemkin #161; RMG #158 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CH2CHO(31); H(4), H2(3); +- equation: H(4) + CH3CHO(32) => H2(3) + CO(10) + CH3(14) # Reaction 162 + rate-constant: {A: 2.05e+09, b: 1.16, Ea: 2.405} + note: | + Reaction index: Chemkin #162; RMG #159 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CO(10); H(4), H2(3); H(4), CH3(14); +- equation: OH(5) + CH3CHO(32) => H2O(28) + CO(10) + CH3(14) # Reaction 163 + rate-constant: {A: 2.343e+10, b: 0.73, Ea: -1.113} + note: | + Reaction index: Chemkin #163; RMG #160 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CO(10); OH(5), H2O(28); OH(5), CH3(14); +- equation: HO2(6) + CH3CHO(32) => H2O2(8) + CO(10) + CH3(14) # Reaction 164 + rate-constant: {A: 3.01e+12, b: 0.0, Ea: 11.923} + note: | + Reaction index: Chemkin #164; RMG #161 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CO(10); HO2(6), H2O2(8); HO2(6), CH3(14); +- equation: CH3(14) + CH3CHO(32) => CO(10) + CH3(14) + CH4(16) # Reaction 165 + rate-constant: {A: 2.72e+06, b: 1.77, Ea: 5.92} + note: | + Reaction index: Chemkin #165; RMG #162 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3CHO(32), CO(10); CH3(14), CH3(14); CH3(14), CH4(16); +- equation: O(2) + CH2CHO(31) => H(4) + CO2(17) + CH2(11) # Reaction 166 + rate-constant: {A: 1.5e+14, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #166; RMG #163 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CHO(31), CO2(17); O(2), H(4); O(2), CH2(11); +- equation: O2(7) + CH2CHO(31) => OH(5) + CO(10) + CH2O(15) # Reaction 167 + rate-constant: {A: 1.81e+10, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #167; RMG #164 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CHO(31), CH2O(15); O2(7), OH(5); O2(7), CO(10); +- equation: O2(7) + CH2CHO(31) => OH(5) + HCO(12) + HCO(12) # Reaction 168 + rate-constant: {A: 2.35e+10, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #168; RMG #165 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CHO(31), HCO(12); O2(7), OH(5); O2(7), HCO(12); +- equation: H(4) + CH2CHO(31) <=> HCO(12) + CH3(14) # Reaction 169 + rate-constant: {A: 2.2e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #169; RMG #166 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CHO(31), HCO(12); H(4), CH3(14); +- equation: H(4) + CH2CHO(31) <=> H2(3) + CH2CO(25) # Reaction 170 + rate-constant: {A: 1.1e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #170; RMG #167 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CHO(31), CH2CO(25); H(4), H2(3); +- equation: OH(5) + CH2CHO(31) <=> H2O(28) + CH2CO(25) # Reaction 171 + rate-constant: {A: 1.2e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #171; RMG #168 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CHO(31), CH2CO(25); OH(5), H2O(28); +- equation: OH(5) + CH2CHO(31) <=> HCO(12) + CH2OH(18) # Reaction 172 + rate-constant: {A: 3.01e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #172; RMG #169 + Library reaction: GRI-Mech3.0 + Flux pairs: CH2CHO(31), CH2OH(18); OH(5), HCO(12); +- equation: O(2) + O(2) + M <=> O2(7) + M # Reaction 173 + type: three-body + rate-constant: {A: 1.2e+17, b: -1.0, Ea: 0.0} + efficiencies: {CO2(17): 3.6, ethane(1): 3.0, CH4(16): 2.0, H2O(28): + 15.4, H2(3): 2.4, Ar: 0.83} + note: | + Reaction index: Chemkin #173; RMG #170 + Library reaction: GRI-Mech3.0 + Flux pairs: O(2), O2(7); O(2), O2(7); +- equation: O(2) + H(4) + M <=> OH(5) + M # Reaction 174 + type: three-body + rate-constant: {A: 5.0e+17, b: -1.0, Ea: 0.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #174; RMG #171 + Library reaction: GRI-Mech3.0 + Flux pairs: O(2), OH(5); H(4), OH(5); +- equation: O2(7) + H(4) + M <=> HO2(6) + M # Reaction 175 + type: three-body + rate-constant: {A: 2.8e+18, b: -0.86, Ea: 0.0} + efficiencies: {CO2(17): 1.5, ethane(1): 1.5, H2O(28): 0.0, O2(7): + 0.0, N2: 0.0, Ar: 0.0} + note: | + Reaction index: Chemkin #175; RMG #172 + Library reaction: GRI-Mech3.0 + Flux pairs: O2(7), HO2(6); H(4), HO2(6); +- equation: H(4) + H(4) + M <=> H2(3) + M # Reaction 176 + type: three-body + rate-constant: {A: 1.0e+18, b: -1.0, Ea: 0.0} + efficiencies: {CH4(16): 2.0, CO2(17): 0.0, ethane(1): 3.0, H2O(28): + 0.0, H2(3): 0.0, Ar: 0.63} + note: | + Reaction index: Chemkin #176; RMG #173 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), H2(3); H(4), H2(3); +- equation: H(4) + OH(5) + M <=> H2O(28) + M # Reaction 177 + type: three-body + rate-constant: {A: 2.2e+22, b: -2.0, Ea: 0.0} + efficiencies: {ethane(1): 3.0, CH4(16): 2.0, H2(3): 0.73, H2O(28): + 3.65, Ar: 0.38} + note: | + Reaction index: Chemkin #177; RMG #174 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), H2O(28); OH(5), H2O(28); +- equation: HCO(12) + M <=> H(4) + CO(10) + M # Reaction 178 + type: three-body + rate-constant: {A: 1.87e+17, b: -1.0, Ea: 17.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 0.0, H2(3): 2.0} + note: | + Reaction index: Chemkin #178; RMG #175 + Library reaction: GRI-Mech3.0 + Flux pairs: HCO(12), H(4); HCO(12), CO(10); +- equation: O(2) + CO(10) (+M) <=> CO2(17) (+M) # Reaction 179 + type: falloff + low-P-rate-constant: {A: 6.02e+14, b: 0.0, Ea: 3.0} + high-P-rate-constant: {A: 1.8e+10, b: 0.0, Ea: 2.385} + efficiencies: {CH4(16): 2.0, CO2(17): 3.5, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, O2(7): 6.0, Ar: 0.5} + note: | + Reaction index: Chemkin #179; RMG #176 + Library reaction: GRI-Mech3.0 + Flux pairs: O(2), CO2(17); CO(10), CO2(17); +- equation: H(4) + CH2(11) (+M) <=> CH3(14) (+M) # Reaction 180 + type: falloff + low-P-rate-constant: {A: 1.04e+26, b: -2.76, Ea: 1.6} + high-P-rate-constant: {A: 6.0e+14, b: 0.0, Ea: 0.0} + Troe: {A: 0.562, T3: 91.0, T1: 5840.0, T2: 8550.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #180; RMG #177 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH3(14); CH2(11), CH3(14); +- equation: H(4) + CH3(14) (+M) <=> CH4(16) (+M) # Reaction 181 + type: falloff + low-P-rate-constant: {A: 2.62e+33, b: -4.76, Ea: 2.44} + high-P-rate-constant: {A: 1.39e+16, b: -0.534, Ea: 0.536} + Troe: {A: 0.783, T3: 74.0, T1: 2940.0, T2: 6960.0} + efficiencies: {CH4(16): 3.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #181; RMG #178 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH4(16); CH3(14), CH4(16); +- equation: H(4) + HCO(12) (+M) <=> CH2O(15) (+M) # Reaction 182 + type: falloff + low-P-rate-constant: {A: 2.47e+24, b: -2.57, Ea: 0.425} + high-P-rate-constant: {A: 1.09e+12, b: 0.48, Ea: -0.26} + Troe: {A: 0.7824, T3: 271.0, T1: 2760.0, T2: 6570.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #182; RMG #179 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH2O(15); HCO(12), CH2O(15); +- equation: H(4) + CH2O(15) (+M) <=> CH2OH(18) (+M) # Reaction 183 + type: falloff + low-P-rate-constant: {A: 1.27e+32, b: -4.82, Ea: 6.53} + high-P-rate-constant: {A: 5.4e+11, b: 0.454, Ea: 3.6} + Troe: {A: 0.7187, T3: 103.0, T1: 1290.0, T2: 4160.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0} + note: | + Reaction index: Chemkin #183; RMG #180 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH2OH(18); CH2O(15), CH2OH(18); +- equation: H(4) + CH2O(15) (+M) <=> CH3O(19) (+M) # Reaction 184 + type: falloff + low-P-rate-constant: {A: 2.2e+30, b: -4.8, Ea: 5.56} + high-P-rate-constant: {A: 5.4e+11, b: 0.454, Ea: 2.6} + Troe: {A: 0.758, T3: 94.0, T1: 1560.0, T2: 4200.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0} + note: | + Reaction index: Chemkin #184; RMG #181 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH3O(19); CH2O(15), CH3O(19); +- equation: H(4) + CH2OH(18) (+M) <=> CH3OH(20) (+M) # Reaction 185 + type: falloff + low-P-rate-constant: {A: 4.36e+31, b: -4.65, Ea: 5.08} + high-P-rate-constant: {A: 1.055e+12, b: 0.5, Ea: 0.086} + Troe: {A: 0.6, T3: 100.0, T1: 9.0e+04, T2: 1.0e+04} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0} + note: | + Reaction index: Chemkin #185; RMG #182 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH3OH(20); CH2OH(18), CH3OH(20); +- equation: H(4) + CH3O(19) (+M) <=> CH3OH(20) (+M) # Reaction 186 + type: falloff + low-P-rate-constant: {A: 4.66e+41, b: -7.44, Ea: 14.08} + high-P-rate-constant: {A: 2.43e+12, b: 0.515, Ea: 0.05} + Troe: {A: 0.7, T3: 100.0, T1: 9.0e+04, T2: 1.0e+04} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0} + note: | + Reaction index: Chemkin #186; RMG #183 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH3OH(20); CH3O(19), CH3OH(20); +- equation: H(4) + C2H(21) (+M) <=> C2H2(22) (+M) # Reaction 187 + type: falloff + low-P-rate-constant: {A: 3.75e+33, b: -4.8, Ea: 1.9} + high-P-rate-constant: {A: 1.0e+17, b: -1.0, Ea: 0.0} + Troe: {A: 0.6464, T3: 132.0, T1: 1320.0, T2: 5570.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #187; RMG #184 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), C2H2(22); C2H(21), C2H2(22); +- equation: H(4) + C2H2(22) (+M) <=> C2H3(24) (+M) # Reaction 188 + type: falloff + low-P-rate-constant: {A: 3.8e+40, b: -7.27, Ea: 7.22} + high-P-rate-constant: {A: 5.6e+12, b: 0.0, Ea: 2.4} + Troe: {A: 0.7507, T3: 98.5, T1: 1300.0, T2: 4170.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #188; RMG #185 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), C2H3(24); C2H2(22), C2H3(24); +- equation: H(4) + C2H3(24) (+M) <=> C2H4(26) (+M) # Reaction 189 + type: falloff + low-P-rate-constant: {A: 1.4e+30, b: -3.86, Ea: 3.32} + high-P-rate-constant: {A: 6.08e+12, b: 0.27, Ea: 0.28} + Troe: {A: 0.782, T3: 208.0, T1: 2660.0, T2: 6100.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #189; RMG #186 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), C2H4(26); C2H3(24), C2H4(26); +- equation: H(4) + C2H4(26) (+M) <=> C2H5(27) (+M) # Reaction 190 + type: falloff + low-P-rate-constant: {A: 6.0e+41, b: -7.62, Ea: 6.97} + high-P-rate-constant: {A: 5.4e+11, b: 0.454, Ea: 1.82} + Troe: {A: 0.9753, T3: 210.0, T1: 984.0, T2: 4370.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #190; RMG #187 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), C2H5(27); C2H4(26), C2H5(27); +- equation: H(4) + C2H5(27) (+M) <=> ethane(1) (+M) # Reaction 191 + type: falloff + low-P-rate-constant: {A: 1.99e+41, b: -7.08, Ea: 6.685} + high-P-rate-constant: {A: 5.21e+17, b: -0.99, Ea: 1.58} + Troe: {A: 0.8422, T3: 125.0, T1: 2220.0, T2: 6880.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #191; RMG #188 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), ethane(1); C2H5(27), ethane(1); +- equation: H2(3) + CO(10) (+M) <=> CH2O(15) (+M) # Reaction 192 + type: falloff + low-P-rate-constant: {A: 5.07e+27, b: -3.42, Ea: 84.35} + high-P-rate-constant: {A: 4.3e+07, b: 1.5, Ea: 79.6} + Troe: {A: 0.932, T3: 197.0, T1: 1540.0, T2: 1.03e+04} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #192; RMG #189 + Library reaction: GRI-Mech3.0 + Flux pairs: H2(3), CH2O(15); CO(10), CH2O(15); +- equation: OH(5) + OH(5) (+M) <=> H2O2(8) (+M) # Reaction 193 + type: falloff + low-P-rate-constant: {A: 2.3e+18, b: -0.9, Ea: -1.7} + high-P-rate-constant: {A: 7.4e+13, b: -0.37, Ea: 0.0} + Troe: {A: 0.7346, T3: 94.0, T1: 1760.0, T2: 5180.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #193; RMG #190 + Library reaction: GRI-Mech3.0 + Flux pairs: OH(5), H2O2(8); OH(5), H2O2(8); +- equation: OH(5) + CH3(14) (+M) <=> CH3OH(20) (+M) # Reaction 194 + type: falloff + low-P-rate-constant: {A: 4.0e+36, b: -5.92, Ea: 3.14} + high-P-rate-constant: {A: 2.79e+18, b: -1.43, Ea: 1.33} + Troe: {A: 0.412, T3: 195.0, T1: 5900.0, T2: 6390.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0} + note: | + Reaction index: Chemkin #194; RMG #191 + Library reaction: GRI-Mech3.0 + Flux pairs: OH(5), CH3OH(20); CH3(14), CH3OH(20); +- equation: CO(10) + CH(9) (+M) <=> HCCO(23) (+M) # Reaction 195 + type: falloff + low-P-rate-constant: {A: 2.69e+28, b: -3.74, Ea: 1.936} + high-P-rate-constant: {A: 5.0e+13, b: 0.0, Ea: 0.0} + Troe: {A: 0.5757, T3: 237.0, T1: 1650.0, T2: 5070.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #195; RMG #192 + Library reaction: GRI-Mech3.0 + Flux pairs: CO(10), HCCO(23); CH(9), HCCO(23); +- equation: CO(10) + CH2(11) (+M) <=> CH2CO(25) (+M) # Reaction 196 + type: falloff + low-P-rate-constant: {A: 2.69e+33, b: -5.11, Ea: 7.095} + high-P-rate-constant: {A: 8.1e+11, b: 0.5, Ea: 4.51} + Troe: {A: 0.5907, T3: 275.0, T1: 1230.0, T2: 5180.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #196; RMG #193 + Library reaction: GRI-Mech3.0 + Flux pairs: CO(10), CH2CO(25); CH2(11), CH2CO(25); +- equation: H2O(28) + CH2(S)(13) (+M) <=> CH3OH(20) (+M) # Reaction 197 + type: falloff + low-P-rate-constant: {A: 1.88e+38, b: -6.36, Ea: 5.04} + high-P-rate-constant: {A: 4.82e+17, b: -1.16, Ea: 1.145} + Troe: {A: 0.6027, T3: 208.0, T1: 3920.0, T2: 1.02e+04} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0} + note: | + Reaction index: Chemkin #197; RMG #194 + Library reaction: GRI-Mech3.0 + Flux pairs: H2O(28), CH3OH(20); CH2(S)(13), CH3OH(20); +- equation: CH3(14) + CH3(14) (+M) <=> ethane(1) (+M) # Reaction 198 + type: falloff + low-P-rate-constant: {A: 3.4e+41, b: -7.03, Ea: 2.762} + high-P-rate-constant: {A: 6.77e+16, b: -1.18, Ea: 0.654} + Troe: {A: 0.619, T3: 73.2, T1: 1180.0, T2: 1.0e+04} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #198; RMG #195 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), ethane(1); CH3(14), ethane(1); +- equation: C2H4(26) (+M) <=> H2(3) + C2H2(22) (+M) # Reaction 199 + type: falloff + low-P-rate-constant: {A: 1.58e+51, b: -9.3, Ea: 97.8} + high-P-rate-constant: {A: 8.0e+12, b: 0.44, Ea: 86.77} + Troe: {A: 0.7345, T3: 180.0, T1: 1040.0, T2: 5420.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #199; RMG #196 + Library reaction: GRI-Mech3.0 + Flux pairs: C2H4(26), H2(3); C2H4(26), C2H2(22); +- equation: H2(3) + CH(9) (+M) <=> CH3(14) (+M) # Reaction 200 + type: falloff + low-P-rate-constant: {A: 4.82e+25, b: -2.8, Ea: 0.59} + high-P-rate-constant: {A: 1.97e+12, b: 0.43, Ea: -0.37} + Troe: {A: 0.578, T3: 122.0, T1: 2540.0, T2: 9360.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #200; RMG #197 + Library reaction: GRI-Mech3.0 + Flux pairs: H2(3), CH3(14); CH(9), CH3(14); +- equation: H(4) + CH2CO(25) (+M) <=> CH2CHO(31) (+M) # Reaction 201 + type: falloff + low-P-rate-constant: {A: 1.012e+42, b: -7.63, Ea: 3.854} + high-P-rate-constant: {A: 4.865e+11, b: 0.422, Ea: -1.755} + Troe: {A: 0.465, T3: 201.0, T1: 1770.0, T2: 5330.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #201; RMG #198 + Library reaction: GRI-Mech3.0 + Flux pairs: H(4), CH2CHO(31); CH2CO(25), CH2CHO(31); +- equation: CH3(14) + C2H5(27) (+M) <=> C3H8(33) (+M) # Reaction 202 + type: falloff + low-P-rate-constant: {A: 2.71e+74, b: -16.82, Ea: 13.065} + high-P-rate-constant: {A: 9.43e+12, b: 0.0, Ea: 0.0} + Troe: {A: 0.1527, T3: 291.0, T1: 2740.0, T2: 7750.0} + efficiencies: {CH4(16): 2.0, CO2(17): 2.0, ethane(1): 3.0, H2O(28): + 6.0, H2(3): 2.0, Ar: 0.7} + note: | + Reaction index: Chemkin #202; RMG #199 + Library reaction: GRI-Mech3.0 + Flux pairs: CH3(14), C3H8(33); C2H5(27), C3H8(33); +- equation: H(4) + HO2(6) <=> H2O2(8) # Reaction 203 + rate-constant: {A: 5.25069e+09, b: 1.273, Ea: 0.0} + note: | + Reaction index: Chemkin #203; RMG #200 + Template reaction: R_Recombination + Flux pairs: HO2(6), H2O2(8); H(4), H2O2(8); + Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_2CNO->O_3R!H->O in family R_Recombination. +- equation: H(4) + CH(9) <=> CH2(S)(13) # Reaction 204 + rate-constant: {A: 5.37e+13, b: 0.154, Ea: 0.0} + note: | + Reaction index: Chemkin #204; RMG #201 + Template reaction: R_Recombination + Flux pairs: CH(9), CH2(S)(13); H(4), CH2(S)(13); + Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_N-2CNO->O in family R_Recombination. +- equation: H(4) + HCCO(23) <=> CH2CO(25) # Reaction 205 + rate-constant: {A: 1.1386e+13, b: 0.309, Ea: 0.0} + note: | + Reaction index: Chemkin #205; RMG #207 + Template reaction: R_Recombination + Flux pairs: HCCO(23), CH2CO(25); H(4), CH2CO(25); + Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_Sp-3R!H=2CCNNOO_N-3R!H->O_Ext-3CS-R in family R_Recombination. +- equation: OH(5) + C2H(21) <=> HCCOH(30) # Reaction 206 + rate-constant: {A: 7.7e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #206; RMG #209 + Template reaction: R_Recombination + Flux pairs: OH(5), HCCOH(30); C2H(21), HCCOH(30); + Estimated from node Root_N-1R->H_N-1CNOS->N_1COS->O_2R->C_Ext-2C-R in family R_Recombination. +- equation: H(4) + HCCO(23) <=> HCCOH(30) # Reaction 207 + rate-constant: {A: 2.80515e+12, b: 0.315, Ea: 0.0} + note: | + Reaction index: Chemkin #207; RMG #210 + Template reaction: R_Recombination + Flux pairs: H(4), HCCOH(30); HCCO(23), HCCOH(30); + Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_2CNO->O_N-3R!H->O in family R_Recombination. +- equation: HCO(12) + CH3(14) <=> CH3CHO(32) # Reaction 208 + rate-constant: {A: 1.81e+13, b: 0.0, Ea: 0.0} + note: | + Reaction index: Chemkin #208; RMG #214 + Template reaction: R_Recombination + Flux pairs: HCO(12), CH3CHO(32); CH3(14), CH3CHO(32); + Matched reaction 71 CH3 + CHO <=> C2H4O in R_Recombination/training + This reaction matched rate rule [Root_N-1R->H_N-1CNOS->N_N-1COS->O_1CS->C_N-1C-inRing_Ext-2R-R_N-Sp-3R!H-2R_3R!H->O] + family: R_Recombination +- equation: H(4) + CH2CHO(31) <=> CH3CHO(32) # Reaction 209 + rate-constant: {A: 7.82867e+13, b: 0.063, Ea: 0.0} + note: | + Reaction index: Chemkin #209; RMG #215 + Template reaction: R_Recombination + Flux pairs: CH2CHO(31), CH3CHO(32); H(4), CH3CHO(32); + Estimated from node Root_1R->H_N-2R->S_N-2CHNO->H_N-2CNO-inRing_Ext-2CNO-R_N-Sp-3R!H=2CCNNOO_N-2CNO->O_3R!H->C_Sp-3C-2CN in family R_Recombination. +- equation: CH(9) + CH(9) <=> C2H2(22) # Reaction 210 + rate-constant: {A: 9.9813e+10, b: 0.611, Ea: 0.0} + note: | + Reaction index: Chemkin #210; RMG #258 + Template reaction: R_Recombination + Flux pairs: CH(9), C2H2(22); CH(9), C2H2(22); + Estimated from node Root_N-1R->H_N-1CNOS->N_N-1COS->O_1CS->C_N-1C-inRing in family R_Recombination. diff --git a/test/rmgpy/yaml_cantera1Test.py b/test/rmgpy/yaml_cantera1Test.py new file mode 100644 index 00000000000..06ea5397e9c --- /dev/null +++ b/test/rmgpy/yaml_cantera1Test.py @@ -0,0 +1,500 @@ +#!/usr/bin/env python3 + +############################################################################### +# # +# RMG - Reaction Mechanism Generator # +# # +# Copyright (c) 2002-2026 Prof. William H. Green (whgreen@mit.edu), # +# Prof. Richard H. West (r.west@neu.edu) and the RMG Team (rmg_dev@mit.edu) # +# # +# Permission is hereby granted, free of charge, to any person obtaining a # +# copy of this software and associated documentation files (the 'Software'), # +# to deal in the Software without restriction, including without limitation # +# the rights to use, copy, modify, merge, publish, distribute, sublicense, # +# and/or sell copies of the Software, and to permit persons to whom the # +# Software is furnished to do so, subject to the following conditions: # +# # +# The above copyright notice and this permission notice shall be included in # +# all copies or substantial portions of the Software. # +# # +# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # +# DEALINGS IN THE SOFTWARE. # +# # +############################################################################### + +""" +Tests for rmgpy.yaml_cantera1 module. +""" + +import copy +import os +import pytest +import numpy as np +import yaml + +from rmgpy.species import Species +from rmgpy.reaction import Reaction +from rmgpy.thermo import NASA, NASAPolynomial +from rmgpy.transport import TransportData +from rmgpy.kinetics import ( + Arrhenius, + PDepArrhenius, + Troe, + ThirdBody, +) +from rmgpy.kinetics.surface import SurfaceArrhenius, StickingCoefficient +from rmgpy.yaml_cantera1 import ( + CanteraWriter1, + species_to_dict, + reaction_to_dicts, +) + + +def _make_nasa_thermo(): + coeffs = [1.0, 0.0, 0.0, 0.0, 0.0, -100.0, 1.0] + return NASA( + polynomials=[ + NASAPolynomial(coeffs=coeffs, Tmin=(200, "K"), Tmax=(1000, "K")), + NASAPolynomial(coeffs=coeffs, Tmin=(1000, "K"), Tmax=(6000, "K")), + ], + Tmin=(200, "K"), + Tmax=(6000, "K"), + ) + + +def _make_gas_species(label, smiles, index): + sp = Species(label=label, index=index) + sp.from_smiles(smiles) + sp.thermo = _make_nasa_thermo() + sp.transport_data = TransportData( + shapeIndex=1, + sigma=(3.0, "angstrom"), + epsilon=(100.0, "K"), + dipoleMoment=(0.0, "De"), + polarizability=(0.0, "angstrom^3"), + rotrelaxcollnum=1.0, + ) + return sp + + +def _make_surface_species(label, adjlist, index): + sp = Species(label=label, index=index) + sp.from_adjacency_list(adjlist) + sp.thermo = _make_nasa_thermo() + return sp + + +class TestYamlCantera1Functions: + """Unit tests for the individual helper functions in yaml_cantera1.""" + + # ------------------------------------------------------------------ + # Shared fixtures + # ------------------------------------------------------------------ + @pytest.fixture(autouse=True) + def _build_species(self): + self.h2 = _make_gas_species("H2", "[H][H]", index=1) + self.h = _make_gas_species("H", "[H]", index=2) + self.ar = _make_gas_species("Ar", "[Ar]", index=3) + self.x = _make_surface_species("X", "1 X u0 p0", index=4) + self.hx = _make_surface_species( + "H_X", "1 H u0 p0 {2,S}\n2 X u0 p0 {1,S}", index=5 + ) + self.all_gas = [self.h2, self.h, self.ar] + self.all_surface = [self.x, self.hx, self.h2] + + # ------------------------------------------------------------------ + # species_to_dict + # ------------------------------------------------------------------ + def test_species_to_dict_gas_name_and_thermo(self): + """Gas species: correct name, NASA7 thermo with two polynomial ranges.""" + d = species_to_dict(self.h2) + assert d["name"] == "H2(1)" + assert d["composition"] == {"H": 2.0} + assert d["thermo"]["model"] == "NASA7" + assert len(d["thermo"]["temperature-ranges"]) == 3 # low, mid, high + assert len(d["thermo"]["data"]) == 2 + + def test_species_to_dict_gas_transport(self): + """Gas species transport data is present and contains geometry.""" + d = species_to_dict(self.h2) + assert "transport" in d + assert d["transport"]["model"] == "gas" + assert d["transport"]["geometry"] == "linear" + assert np.isclose(d["transport"]["diameter"], 3.0) + assert np.isclose(d["transport"]["well-depth"], 100.0) + + def test_species_to_dict_surface_composition(self): + """Surface species has X in composition and no transport block.""" + d = species_to_dict(self.hx) + assert "X" in d["composition"] + assert d["composition"]["X"] == 1.0 + assert "H" in d["composition"] + assert "transport" not in d + + def test_species_to_dict_surface_thermo_model(self): + """Surface species reports NASA7 thermo.""" + d = species_to_dict(self.x) + assert d["thermo"]["model"] == "NASA7" + + # ------------------------------------------------------------------ + # reaction_to_dicts — gas-phase kinetics + # Units declared in yaml_cantera1: activation-energy: J/kmol, + # so all Ea values come through multiplied by 1000 relative to J/mol. + # ------------------------------------------------------------------ + def test_reaction_to_dicts_arrhenius_equation_and_rate(self): + """Arrhenius: equation string and rate-constant keys present with J/kmol Ea.""" + kin = Arrhenius(A=(1e13, "s^-1"), n=0.5, Ea=(10, "kJ/mol"), T0=(1, "K")) + rxn = Reaction(reactants=[self.h2], products=[self.h, self.h], kinetics=kin) + entries = reaction_to_dicts(rxn, self.all_gas) + assert len(entries) == 1 + d = entries[0] + assert d["equation"] == "H2(1) <=> 2 H(2)" + assert "rate-constant" in d + assert np.isclose(d["rate-constant"]["A"], 1e13) + assert np.isclose(d["rate-constant"]["b"], 0.5) + assert np.isclose(d["rate-constant"]["Ea"], 10e6) # 10 kJ/mol → 1e7 J/kmol + + def test_reaction_to_dicts_thirdbody(self): + """ThirdBody: equation uses M, efficiencies map present.""" + kin = ThirdBody( + arrheniusLow=Arrhenius( + A=(1e18, "cm^6/(mol^2*s)"), n=-1, Ea=(0, "J/mol"), T0=(1, "K") + ), + efficiencies={self.ar.molecule[0]: 0.7}, + ) + rxn = Reaction( + reactants=[self.h, self.h], products=[self.h2], kinetics=kin + ) + entries = reaction_to_dicts(rxn, self.all_gas) + d = entries[0] + assert "M" in d["equation"] + assert "rate-constant" in d + assert "efficiencies" in d + assert np.isclose(d["efficiencies"]["Ar(3)"], 0.7) + + def test_reaction_to_dicts_pdep_arrhenius(self): + """PDepArrhenius: type is pressure-dependent-Arrhenius, rate-constants list.""" + kin = PDepArrhenius( + pressures=([0.1, 1.0], "atm"), + arrhenius=[ + Arrhenius(A=(1e10, "s^-1"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K")), + Arrhenius(A=(1e12, "s^-1"), n=0, Ea=(15, "kJ/mol"), T0=(1, "K")), + ], + ) + rxn = Reaction(reactants=[self.h2], products=[self.h, self.h], kinetics=kin) + entries = reaction_to_dicts(rxn, self.all_gas) + d = entries[0] + assert d["type"] == "pressure-dependent-Arrhenius" + rates = d["rate-constants"] + assert len(rates) == 2 + assert np.isclose(rates[0]["P"], 0.1 * 101325.0) + assert np.isclose(rates[0]["A"], 1e10) + assert np.isclose(rates[0]["Ea"], 10e6) # J/kmol + assert np.isclose(rates[1]["P"], 1.0 * 101325.0) + assert np.isclose(rates[1]["A"], 1e12) + assert np.isclose(rates[1]["Ea"], 15e6) # J/kmol + + def test_reaction_to_dicts_troe(self): + """Troe: type falloff, Troe block present, high/low rate constants.""" + kin = Troe( + arrheniusHigh=Arrhenius( + A=(1e14, "s^-1"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K") + ), + arrheniusLow=Arrhenius( + A=(1e20, "cm^3/(mol*s)"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K") + ), + alpha=0.5, + T3=(100, "K"), + T1=(200, "K"), + T2=(300, "K"), + efficiencies={self.ar.molecule[0]: 2.0}, + ) + rxn = Reaction(reactants=[self.h], products=[self.h], kinetics=kin) + entries = reaction_to_dicts(rxn, self.all_gas) + d = entries[0] + assert d["type"] == "falloff" + assert "Troe" in d + assert np.isclose(d["Troe"]["A"], 0.5) + assert np.isclose(d["Troe"]["T3"], 100.0) + assert np.isclose(d["Troe"]["T1"], 200.0) + assert np.isclose(d["Troe"]["T2"], 300.0) + assert np.isclose(d["high-P-rate-constant"]["A"], 1e14) + assert np.isclose(d["high-P-rate-constant"]["Ea"], 10e6) # J/kmol + assert "efficiencies" in d + assert np.isclose(d["efficiencies"]["Ar(3)"], 2.0) + + # ------------------------------------------------------------------ + # reaction_to_dicts — surface kinetics + # ------------------------------------------------------------------ + def test_reaction_to_dicts_surface_arrhenius(self): + """SurfaceArrhenius: rate-constant present, A converted to /kmol.""" + kin = SurfaceArrhenius( + A=(1e13, "m^2/(mol*s)"), n=0.5, Ea=(50, "kJ/mol"), T0=(1, "K") + ) + rxn = Reaction( + reactants=[self.h2, self.x], + products=[self.hx, self.hx], + kinetics=kin, + ) + entries = reaction_to_dicts(rxn, self.all_surface) + d = entries[0] + assert "rate-constant" in d + # A in m^2/(mol*s) → ×1000 → m^2/(kmol*s) + assert np.isclose(d["rate-constant"]["A"], 1e16) + assert np.isclose(d["rate-constant"]["b"], 0.5) + assert np.isclose(d["rate-constant"]["Ea"], 50e6) # J/kmol + + def test_reaction_to_dicts_sticking_coefficient(self): + """StickingCoefficient: sticking-coefficient block present, A dimensionless.""" + kin = StickingCoefficient( + A=(0.1, ""), n=0, Ea=(0, "kJ/mol"), T0=(1, "K") + ) + rxn = Reaction( + reactants=[self.h2, self.x, self.x], + products=[self.hx, self.hx], + kinetics=kin, + ) + entries = reaction_to_dicts(rxn, self.all_surface) + d = entries[0] + assert "sticking-coefficient" in d + assert np.isclose(d["sticking-coefficient"]["A"], 0.1) + assert np.isclose(d["sticking-coefficient"]["Ea"], 0.0) + + def test_reaction_to_dicts_coverage_dependence(self): + """Coverage-dependent kinetics: coverage-dependencies block present with correct units. + + yaml_cantera1 declares activation-energy: J/kmol, so E must be ×1000 + relative to RMG's J/mol value_si. + """ + kin = StickingCoefficient( + A=(0.1, ""), + n=0, + Ea=(0, "kJ/mol"), + T0=(1, "K"), + coverage_dependence={ + self.hx: {"a": 0.5, "m": -1.0, "E": (5.0, "kJ/mol")} + }, + ) + rxn = Reaction( + reactants=[self.h2, self.x, self.x], + products=[self.hx, self.hx], + kinetics=kin, + ) + entries = reaction_to_dicts(rxn, self.all_surface) + d = entries[0] + assert "coverage-dependencies" in d + cov = d["coverage-dependencies"]["H_X(5)"] + assert np.isclose(cov["a"], 0.5) + assert np.isclose(cov["m"], -1.0) + # 5 kJ/mol = 5000 J/mol → ×1000 → 5 000 000 J/kmol + assert np.isclose(cov["E"], 5e6) + + +class TestCanteraWriter1: + """Tests for the CanteraWriter1 class.""" + + def test_can_instantiate(self): + """Test that CanteraWriter1 can be instantiated.""" + writer = CanteraWriter1() + assert writer is not None + +class CanteraYamlFileComparer: + """ + For comparing two Cantera YAML files. + This class provides methods to compare species and reactions between the two files. + + Args: + yaml_path_1: Path to the first YAML file, converted from Chemkin by ck2yaml. + yaml_path_2: Path to the second YAML file, written directly by RMG. + """ + yaml_path_1 = None + yaml_path_2 = None + + @pytest.fixture(autouse=True, scope="class") # loaded once per Class + def load_yaml_files(self, request): + """Load the two YAML files to be compared.""" + with open(request.cls.yaml_path_1, 'r') as file: + request.cls.yaml1 = yaml.safe_load(file) + with open(request.cls.yaml_path_2, 'r') as file: + request.cls.yaml2 = yaml.safe_load(file) + + @pytest.fixture(autouse=True) # runs before each test method + def copy_yaml_dicts(self): + """Make deep copies so tests can modify without affecting other tests.""" + self.yaml1 = copy.deepcopy(self.__class__.yaml1) + self.yaml2 = copy.deepcopy(self.__class__.yaml2) + + def testGeneratorsAsExpected(self): + "Check the two yaml files were generated by the expected tools (ck2yaml vs RMG)." + assert self.yaml1['generator'] == 'ck2yaml', "First YAML file should be generated by ck2yaml." + assert 'RMG' in self.yaml2['generator'], "Second YAML file should be generated by RMG." + + def testKeysMatch(self): + """Test that the top-level keys in both YAML files match, except those expected not to.""" + # Remove keys from ck2yaml output that are not present in RMG output + self.yaml1.pop('input-files', None) + self.yaml1.pop('cantera-version', None) + for model in [self.yaml1, self.yaml2]: + for phase in model['phases']: + for reactions_block in phase.get('reactions', []): # for multi-phase mechanisms, reactions are under each phase + assert reactions_block in model, f"Expected reactions block '{reactions_block}' not found in YAML file." + model.pop(reactions_block, None) # Remove reactions block to allow keys to match + assert self.yaml1.keys() == self.yaml2.keys(), "YAML files have different top-level keys." + + def testPhasesMatch(self): + """Test that the phase definitions in both YAML files match.""" + assert len(self.yaml1['phases']) == len(self.yaml2['phases']), "YAML files have different numbers of phases" + + for phase1, phase2 in zip(self.yaml1['phases'], self.yaml2['phases']): + assert phase1['name'] == phase2['name'], f"Phase names do not match: {phase1['name']} vs {phase2['name']}." + assert phase1['thermo'] == phase2['thermo'], f"Thermo definitions for phase {phase1['name']} do not match." + assert phase1.get('transport', '') == phase2.get('transport', ''), f"Transport definitions for phase {phase1['name']} do not match." + assert phase1.get('adjacent-phases', []) == phase2.get('adjacent-phases', []), f"Adjacent phases for phase {phase1['name']} do not match." + assert phase1.get('species', []) == phase2.get('species', []), f"Species lists for phase {phase1['name']} do not match." + assert phase1.get('reactions', []) == phase2.get('reactions', []), f"Reactions blocks for phase {phase1['name']} do not match." + # the ck2yaml has all elements in Titlecase, while RMG lets some isotopes be CI and OI (not Ci and Oi). + assert sorted(phase1.get('elements', [])) == sorted(e.title() for e in phase2.get('elements', [])), f"Element lists for phase {phase1['name']} do not match." + assert phase1.get('state', {}) == phase2.get('state', {}), f"State definitions for phase {phase1['name']} do not match." + + def testElementsMatch(self): + """Test that the element definitions in both YAML files match.""" + ck2yaml_elements = sorted(self.yaml1['elements'], key=lambda e: e['symbol']) + # Put symbol into Titlecase to match ck2yaml's formatting + rmg_elements = [{'symbol': e['symbol'].title(), 'atomic-weight': e['atomic-weight']} for e in self.yaml2['elements']] + # Sort by the 'symbol' key. + rmg_elements = sorted(rmg_elements, key=lambda e: e['symbol']) + # Compare symbols exactly, and atomic weights approximately + assert [e['symbol'] for e in ck2yaml_elements] == [e['symbol'] for e in rmg_elements], \ + "YAML files have different element symbols." + assert [e['atomic-weight'] for e in ck2yaml_elements] == pytest.approx( + [e['atomic-weight'] for e in rmg_elements], abs=1e-3 + ), "YAML files have different element atomic weights." + + def testSpeciesMatch(self): + """Test that species definitions match between the two YAML files.""" + species1 = {s['name']: s for s in self.yaml1['species']} + species2 = {s['name']: s for s in self.yaml2['species']} + assert species1.keys() == species2.keys(), "Species names do not match." + + for name in species1: + s1 = species1[name] + s2 = species2[name] + + # Composition: ck2yaml uses int values, RMG uses float + assert {k: int(v) for k, v in s2['composition'].items()} == s1['composition'], \ + f"Composition mismatch for {name}." + + # Thermo model + assert s1['thermo']['model'] == s2['thermo']['model'], \ + f"Thermo model mismatch for {name}." + + # Temperature ranges and polynomial data + # ck2yaml may collapse single-polynomial NASA7 (e.g. Ar) into one range + # while RMG always writes two polynomials with a midpoint temperature. + t_ranges1 = s1['thermo'].get('temperature-ranges', []) + t_ranges2 = s2['thermo'].get('temperature-ranges', []) + data1 = s1['thermo'].get('data', []) + data2 = s2['thermo'].get('data', []) + + if len(t_ranges1) == 2 and len(t_ranges2) == 3: + # ck2yaml collapsed to single polynomial; RMG has two identical ones + assert t_ranges1[0] == pytest.approx(t_ranges2[0], rel=1e-4), \ + f"Temperature range lower bound mismatch for {name}." + assert t_ranges1[1] == pytest.approx(t_ranges2[2], rel=1e-4), \ + f"Temperature range upper bound mismatch for {name}." + assert len(data1) == 1 and len(data2) == 2, \ + f"Expected 1 vs 2 polynomials for collapsed species {name}." + assert data1[0] == pytest.approx(data2[0], rel=1e-4), \ + f"Thermo polynomial mismatch for {name} (low range)." + assert data1[0] == pytest.approx(data2[1], rel=1e-4), \ + f"Thermo polynomial mismatch for {name} (high range should match low)." + else: + assert t_ranges1 == pytest.approx(t_ranges2, rel=1e-4), \ + f"Temperature ranges mismatch for {name}." + assert len(data1) == len(data2), \ + f"Number of thermo polynomial ranges differs for {name}." + for i, (poly1, poly2) in enumerate(zip(data1, data2)): + assert poly1 == pytest.approx(poly2, rel=1e-4), \ + f"Thermo polynomial {i} mismatch for {name}." + # Ideally thermo data would have notes. + + # RMG includes reference-pressure but ck2yaml does not (when it's non-default) + # (no assertion needed, just noting the known difference) + + # Transport data + assert ('transport' in s1) == ('transport' in s2), f"Transport data presence mismatch for {name}." + if 'transport' in s1 and 'transport' in s2: + t1 = s1['transport'] + t2 = s2['transport'] + assert t1['model'] == t2['model'], f"Transport model mismatch for {name}." + assert t1['geometry'] == t2['geometry'], f"Transport geometry mismatch for {name}." + assert t1.get('well-depth', 0) == pytest.approx( + t2.get('well-depth', 0), rel=1e-3 + ), f"Transport well-depth mismatch for {name}." + assert t1.get('diameter', 0) == pytest.approx( + t2.get('diameter', 0), rel=1e-3 + ), f"Transport diameter mismatch for {name}." + assert t1.get('polarizability', 0) == pytest.approx( + t2.get('polarizability', 0), rel=1e-3 + ), f"Transport polarizability mismatch for {name}." + assert t1.get('dipole', 0) == pytest.approx( + t2.get('dipole', 0), rel=1e-3 + ), f"Transport dipole mismatch for {name}." + assert t1.get('rotational-relaxation', 0) == pytest.approx( + t2.get('rotational-relaxation', 0), rel=1e-3 + ), f"Transport rotational-relaxation mismatch for {name}." + assert t1.get('note', '') == t2.get('note', ''), \ + f"Transport note mismatch for {name}." + +@pytest.mark.skip(reason="These files are out of date and have been removed.") +class TestPreviouslyWrittenCanteraYamlGasOnly(CanteraYamlFileComparer): + """Tests for comparing previously written Cantera YAML files, gas-only mechanism. + + These are stored in the testing data directory. + """ + test_data_folder='test/rmgpy/test_data/yaml_writer_data/' + # generated on the fly in recent functional test + yaml_path_1 = os.path.join(test_data_folder, 'chemkin/chem37.yaml') + yaml_path_2 = os.path.join(test_data_folder, 'cantera1/chem37.yaml') + +class TestRecentlyGeneratedCanteraYamlGasOnly(CanteraYamlFileComparer): + """Tests for comparing recently generated Cantera YAML files, gas-only mechanism. + + These are generated on the fly in the mainTest.py functional test and stored in the testing data directory. + """ + test_data_folder='test/rmgpy/test_data/yaml_writer_data/' + + @pytest.fixture(autouse=True, scope="class") + def find_recent_files(self, request): + """Find the YAML files generated by mainTest.""" + cantera_dir = os.path.join(self.test_data_folder, 'cantera1') + chemkin_dir = os.path.join(self.test_data_folder, 'ck2yaml') + + if not os.path.exists(cantera_dir) or not os.path.exists(chemkin_dir): + pytest.skip("YAML test data directories not found. Run mainTest first.") + + # Look for specifically named files from mainTest + cantera_file = os.path.join(cantera_dir, 'from_main_test.yaml') + chemkin_file = os.path.join(chemkin_dir, 'from_main_test.yaml') + + if not os.path.exists(cantera_file) or not os.path.exists(chemkin_file): + pytest.skip("from_main_test.yaml files not found. Run mainTest first.") + + request.cls.yaml_path_1 = chemkin_file + request.cls.yaml_path_2 = cantera_file + +@pytest.mark.skip(reason="These files are out of date and have been removed.") +class TestPreviouslyWrittenCanteraYamlWithSurface(CanteraYamlFileComparer): + """Tests for comparing previously written Cantera YAML files, with surface mechanism. + + These are stored in the testing data directory. + """ + test_data_folder='test/rmgpy/test_data/yaml_writer_data/' + # saved by Prosper in earlier commit + yaml_path_1 = os.path.join(test_data_folder, 'chemkin/chem0047-gas.yaml') + yaml_path_2 = os.path.join(test_data_folder, 'cantera1/chem47.yaml') diff --git a/test/rmgpy/yaml_cantera2Test.py b/test/rmgpy/yaml_cantera2Test.py new file mode 100644 index 00000000000..f4d588a4869 --- /dev/null +++ b/test/rmgpy/yaml_cantera2Test.py @@ -0,0 +1,543 @@ +#!/usr/bin/env python3 + +############################################################################### +# # +# RMG - Reaction Mechanism Generator # +# # +# Copyright (c) 2002-2023 Prof. William H. Green (whgreen@mit.edu), # +# Prof. Richard H. West (r.west@neu.edu) and the RMG Team (rmg_dev@mit.edu) # +# # +# Permission is hereby granted, free of charge, to any person obtaining a # +# copy of this software and associated documentation files (the 'Software'), # +# to deal in the Software without restriction, including without limitation # +# the rights to use, copy, modify, merge, publish, distribute, sublicense, # +# and/or sell copies of the Software, and to permit persons to whom the # +# Software is furnished to do so, subject to the following conditions: # +# # +# The above copyright notice and this permission notice shall be included in # +# all copies or substantial portions of the Software. # +# # +# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # +# DEALINGS IN THE SOFTWARE. # +# # +############################################################################### + + +import cantera as ct +import os +import shutil +import numpy as np +import pytest + +from rmgpy.species import Species +from rmgpy.reaction import Reaction +from rmgpy.kinetics import ( + Arrhenius, + PDepArrhenius, + MultiArrhenius, + Chebyshev, + Troe, + Lindemann, + ThirdBody, +) +from rmgpy.kinetics.surface import SurfaceArrhenius, StickingCoefficient +from rmgpy.thermo import NASA, NASAPolynomial +from rmgpy.transport import TransportData +from rmgpy.yaml_cantera2 import ( + CanteraWriter2, + save_cantera_files, + species_to_dict, + reaction_to_dict_list, + generate_cantera_data +) + + +class TestCanteraWriter2: + + def setup_method(self): + """ + Create a temporary directory for file I/O tests. + """ + base_dir = os.path.dirname(os.path.abspath(__file__)) + self.tmp_dir = os.path.join(base_dir, 'tmp') + + # Ensure a clean start: delete if exists, then create + if os.path.exists(self.tmp_dir): + shutil.rmtree(self.tmp_dir) + os.makedirs(self.tmp_dir) + + def teardown_method(self): + """ + Clean up the temporary directory after tests. + """ + shutil.rmtree(self.tmp_dir) + + + def _create_dummy_species(self, label, formula, index=-1): + """Helper to create a functional RMG Species object with thermo/transport""" + sp = Species(label=label).from_smiles(formula) + sp.index = index + coeffs = [1.0, 0.0, 0.0, 0.0, 0.0, -100.0, 1.0] + poly_low = NASAPolynomial(coeffs=coeffs, Tmin=(200, 'K'), Tmax=(1000, 'K')) + poly_high = NASAPolynomial(coeffs=coeffs, Tmin=(1000, 'K'), Tmax=(6000, 'K')) + sp.thermo = NASA(polynomials=[poly_low, poly_high], Tmin=(200, 'K'), Tmax=(6000, 'K')) + num_atoms = len(sp.molecule[0].atoms) + if num_atoms == 1: + shape_idx = 0 + elif num_atoms == 2: + shape_idx = 1 + else: + shape_idx = 2 + sp.transport_data = TransportData( + shapeIndex=shape_idx, + sigma=(3.0, 'angstrom'), + epsilon=(100.0, 'K'), + dipoleMoment=(1.7, 'De'), + polarizability=(0.0, 'angstrom^3'), + rotrelaxcollnum=1.0 + ) + return sp + + def test_species_to_dict_standard(self): + """Test conversion of a standard gas species.""" + sp = self._create_dummy_species("H2", "[H][H]", index=1) + d = species_to_dict(sp, [sp]) + + assert d['name'] == "H2(1)" + assert 'composition' in d + assert d['thermo']['model'] == 'NASA7' + assert len(d['thermo']['data']) == 2 + + # Verify Transport + assert 'transport' in d + assert d['transport']['model'] == 'gas' + assert d['transport']['geometry'] == 'linear' + # Diameter should be in angstroms ( https://cantera.org/dev/yaml/species.html#gas-transport ) + assert np.isclose(d['transport']['diameter'], 3.0) # Angstroms + assert np.isclose(d['transport']['dipole'], 1.7) # Debye + assert np.isclose(d['transport']['well-depth'], 100.0) # Kelvin + assert np.isclose(d['transport']['rotational-relaxation'], 1.0) + + def test_reaction_to_dict_arrhenius(self): + """Test standard Arrhenius kinetics.""" + r = self._create_dummy_species("R", "[CH2]O", index=1) + p = self._create_dummy_species("P", "C[O]", index=2) + rxn = Reaction( + reactants=[r], products=[p], + kinetics=Arrhenius(A=(1e10, "s^-1"), n=0.5, Ea=(10, "kJ/mol"), T0=(1, "K")) + ) + + entries = reaction_to_dict_list(rxn, species_list=[r, p]) + assert len(entries) == 1 + data = entries[0] + + assert data['equation'] == "R(1) <=> P(2)" + assert 'rate-constant' in data + assert np.isclose(data['rate-constant']['A'], 1e10) + assert np.isclose(data['rate-constant']['b'], 0.5) + assert np.isclose(data['rate-constant']['Ea'], 10000.0) + + def test_reaction_to_dict_duplicates(self): + """Test that MultiKinetics objects result in multiple YAML entries.""" + r = self._create_dummy_species("R", "[H]", index=1) + k1 = Arrhenius(A=(1e10, "s^-1"), n=0, Ea=(0, "J/mol"), T0=(1, "K")) + k2 = Arrhenius(A=(2e10, "s^-1"), n=0, Ea=(0, "J/mol"), T0=(1, "K")) + + rxn = Reaction( + reactants=[r], products=[r], + kinetics=MultiArrhenius(arrhenius=[k1, k2]), + duplicate=True + ) + + entries = reaction_to_dict_list(rxn, species_list=[r]) + assert len(entries) == 2 + assert entries[0]['rate-constant']['A'] == 1e10 + assert entries[1]['rate-constant']['A'] == 2e10 + assert entries[0].get('duplicate') is True + + def test_reaction_to_dict_troe(self): + """Test Falloff/Troe serialization.""" + r = self._create_dummy_species("R", "[H]", index=1) + M = self._create_dummy_species("M", "[Ar]", index=-1) + + # Troe + k_high = Arrhenius(A=(1e14, "s^-1"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K")) + k_low = Arrhenius(A=(1e20, "cm^3/(mol*s)"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K")) + + troe = Troe( + arrheniusHigh=k_high, arrheniusLow=k_low, + alpha=0.5, T3=(100, "K"), T1=(200, "K"), T2=(300, "K"), + efficiencies={M.molecule[0]: 2.0} + ) + + rxn = Reaction(reactants=[r], products=[r], kinetics=troe) + entries = reaction_to_dict_list(rxn, species_list=[r, M]) + data = entries[0] + + assert data['type'] == 'falloff' + assert 'Troe' in data + assert data['Troe']['A'] == 0.5 + assert data['Troe']['T2'] == 300.0 + # Efficiencies should map label -> val + assert data['efficiencies'] == {"M": 2.0} + + def test_generate_cantera_data_detects_plasma(self): + """Test that the writer detects 'e' and sets thermo: plasma.""" + h2 = self._create_dummy_species("H2", "[H][H]", index=1) + + # Case 1: No Electron + data = generate_cantera_data([h2], [], is_plasma=False) + phase = data['phases'][0] + assert phase['thermo'] == 'ideal-gas' + assert phase['transport'] == 'mixture-averaged' + + def test_full_integration_plasma_model(self): + """ + Create a comprehensive RMG model, write it to disk, and load it in Cantera + to ensure all fields are valid and parsed correctly. + """ + + # 1. Create Model Components + h2 = self._create_dummy_species("H2", "[H][H]", index=1) + h = self._create_dummy_species("H", "[H]", index=2) + ch4 = self._create_dummy_species("CH4", "C", index=3) + oh = self._create_dummy_species("OH", "[OH]", index=4) + ar = self._create_dummy_species("Ar", "[Ar]", index=-1) + + species = [h2, h, ch4, oh, ar] + + r1 = Reaction( + reactants=[h2], products=[h, h], + kinetics=Arrhenius(A=(1e13, "s^-1"), n=0, Ea=(400, "kJ/mol"), T0=(1, "K")) + ) + + r2 = Reaction( + reactants=[h, h], products=[h2], + kinetics=ThirdBody( + arrheniusLow=Arrhenius(A=(1e18, "cm^6/(mol^2*s)"), n=-1, Ea=(0, "J/mol"), T0=(1, "K")), + efficiencies={ar.molecule[0]: 0.7} + ) + ) + + reactions = [r1, r2] + + # 2. Mock RMG Object Structure + # The writer expects: rmg.output_directory and rmg.reaction_model.core + class MockCore: + def __init__(self): + self.species = species + self.reactions = reactions + + class MockModel: + def __init__(self): + self.core = MockCore() + self.edge = MockCore() # Empty for now + + class MockRMG: + def __init__(self, out_dir): + self.output_directory = out_dir + self.reaction_model = MockModel() + self.save_edge_species = False + self.verbose_comments = False + + mock_rmg = MockRMG(self.tmp_dir) + save_cantera_files(mock_rmg) + + yaml_file = os.path.join(self.tmp_dir, "cantera2", "chem.yaml") + versioned_file = os.path.join(self.tmp_dir, "cantera2", "chem0005.yaml") + assert os.path.exists(yaml_file) + assert os.path.exists(versioned_file) + + try: + sol = ct.Solution(yaml_file) + except Exception as e: + pytest.fail(f"Cantera failed to load the generated YAML: {e}") + + assert sol.n_species == 5 + + assert sol.n_reactions == 2 + + ct_r2 = sol.reaction(1) + assert "three-body" in ct_r2.reaction_type or "ThreeBody" in ct_r2.reaction_type + assert np.isclose(ct_r2.third_body.efficiencies["Ar"], 0.7) + + def test_reaction_to_dict_pdep_arrhenius(self): + """Test Pressure-Dependent Arrhenius (PLOG) structure.""" + r = self._create_dummy_species("R", "[CH2]O", index=1) + p = self._create_dummy_species("P", "C[O]", index=2) + + k_low = Arrhenius(A=(1e10, "s^-1"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K")) + k_high = Arrhenius(A=(1e12, "s^-1"), n=0, Ea=(15, "kJ/mol"), T0=(1, "K")) + + pdep = PDepArrhenius( + pressures=([0.1, 1.0], "atm"), + arrhenius=[k_low, k_high], + ) + + rxn = Reaction(reactants=[r], products=[p], kinetics=pdep) + + entries = reaction_to_dict_list(rxn, species_list=[r, p]) + data = entries[0] + + assert data['type'] == 'pressure-dependent-Arrhenius' + rates = data['rate-constants'] + assert len(rates) == 2 + + assert np.isclose(rates[0]['P'], 0.1 * 101325.0) + assert np.isclose(rates[0]['A'], 1e10) + assert np.isclose(rates[0]['Ea'], 10000.0) + + assert np.isclose(rates[1]['P'], 1.0 * 101325.0) + assert np.isclose(rates[1]['A'], 1e12) + assert np.isclose(rates[1]['Ea'], 15000.0) + + def test_reaction_to_dict_chebyshev(self): + """Test Chebyshev kinetics structure.""" + r = self._create_dummy_species("R", "[H]", index=1) + + # 2x2 Coefficients matrix + coeffs = np.array([[1.0, 2.0], [3.0, 4.0]]) + cheb = Chebyshev( + Tmin=(300, "K"), Tmax=(2000, "K"), + Pmin=(0.01, "atm"), Pmax=(100, "atm"), + coeffs=coeffs, + kunits="s^-1" + ) + + rxn = Reaction(reactants=[r], products=[r], kinetics=cheb) + + entries = reaction_to_dict_list(rxn, species_list=[r]) + data = entries[0] + + assert data['type'] == 'Chebyshev' + + assert np.allclose(data['temperature-range'], [300.0, 2000.0]) + assert np.allclose(data['pressure-range'], [0.01 * 101325.0, 100 * 101325.0]) + assert np.allclose(data['data'], coeffs) + + def test_reaction_to_dict_lindemann(self): + """Test Lindemann (Falloff without Troe parameters).""" + r = self._create_dummy_species("R", "[H]", index=1) + M = self._create_dummy_species("M", "[Ar]", index=-1) + + k_high = Arrhenius(A=(1e14, "s^-1"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K")) + k_low = Arrhenius(A=(1e21, "cm^3/(mol*s)"), n=0, Ea=(10, "kJ/mol"), T0=(1, "K")) + lind = Lindemann( + arrheniusHigh=k_high, + arrheniusLow=k_low, + efficiencies={M.molecule[0]: 5.0}, + ) + rxn = Reaction(reactants=[r], products=[r], kinetics=lind) + entries = reaction_to_dict_list(rxn, species_list=[r, M]) + data = entries[0] + + assert data['type'] == 'falloff' + assert 'high-P-rate-constant' in data + assert 'low-P-rate-constant' in data + assert np.isclose(data['high-P-rate-constant']['A'], 1e14) + assert np.isclose(data['low-P-rate-constant']['A'], 1e15) + assert data['efficiencies'] == {"M": 5.0} + assert 'Troe' not in data + + def test_cantera_writer_class_listener(self): + """ + Test the CanteraWriter2 class directly to ensure it correctly initializes + subdirectories and triggers the save on update(). + """ + writer = CanteraWriter2(self.tmp_dir) + cantera_dir = os.path.join(self.tmp_dir, 'cantera2') + assert os.path.exists(cantera_dir) + assert os.path.isdir(cantera_dir) + + mock_rmg = self._create_dummy_model() + writer.update(mock_rmg) + + versioned_file = os.path.join(cantera_dir, 'chem0002.yaml') + latest_file = os.path.join(cantera_dir, 'chem.yaml') + + assert os.path.exists(versioned_file) + assert os.path.exists(latest_file) + + with open(latest_file, 'r') as f: + content = f.read() + assert "generator: RMG-Py CanteraWriter2" in content or "generator: 'RMG-Py CanteraWriter2" in content + assert "phases:" in content + assert "species:" in content + + def _create_dummy_model(self): + """Creates a mock object structure resembling RMG.reaction_model""" + + # 1. Species + sp_H2 = self._create_dummy_species("H2", "[H][H]", index=1) + sp_H = self._create_dummy_species("H", "[H]", index=2) + species_list = [sp_H2, sp_H] + + # 2. Reactions + rxn_arr = Reaction( + reactants=[sp_H2], products=[sp_H, sp_H], + kinetics=Arrhenius(A=(1e13, "s^-1"), n=0.0, Ea=(200, "kJ/mol"), T0=(1, "K")) + ) + reaction_list = [rxn_arr] + + # Mock Object Structure + class MockCore: + def __init__(self, s, r): + self.species = s + self.reactions = r + + class MockModel: + def __init__(self, core): + self.core = core + self.edge = MockCore([], []) + self.output_species_list = [] + self.output_reaction_list = [] + + class MockRMG: + def __init__(self, out_dir, model): + self.output_directory = out_dir + self.reaction_model = model + self.save_edge_species = False + self.verbose_comments = False + + return MockRMG(self.tmp_dir, MockModel(MockCore(species_list, reaction_list))) + + def _create_surface_species(self, label, adjlist, index): + """Helper to create an RMG surface Species with NASA thermo (no transport).""" + sp = Species(label=label, index=index) + sp.from_adjacency_list(adjlist) + coeffs = [1.0, 0.0, 0.0, 0.0, 0.0, -100.0, 1.0] + sp.thermo = NASA( + polynomials=[ + NASAPolynomial(coeffs=coeffs, Tmin=(200, "K"), Tmax=(1000, "K")), + NASAPolynomial(coeffs=coeffs, Tmin=(1000, "K"), Tmax=(6000, "K")), + ], + Tmin=(200, "K"), + Tmax=(6000, "K"), + ) + return sp + + # ------------------------------------------------------------------ + # Surface species + # ------------------------------------------------------------------ + def test_species_to_dict_surface_no_transport(self): + """Surface species: composition contains X, no transport block.""" + sp = self._create_surface_species( + "X", "1 X u0 p0", index=10 + ) + d = species_to_dict(sp, [sp]) + assert "X" in d["composition"] + assert "transport" not in d + + def test_species_to_dict_surface_thermo(self): + """Surface species reports NASA7 thermo with two polynomial ranges.""" + hx = self._create_surface_species( + "H_X", "1 H u0 p0 {2,S}\n2 X u0 p0 {1,S}", index=11 + ) + d = species_to_dict(hx, [hx]) + assert d["thermo"]["model"] == "NASA7" + assert len(d["thermo"]["data"]) == 2 + assert d["composition"] == {"H": 1, "X": 1} + + # ------------------------------------------------------------------ + # Surface reactions + # yaml_cantera2 declares activation-energy: J/mol, so value_si is used + # directly without any ×1000 conversion. + # ------------------------------------------------------------------ + def test_reaction_to_dict_surface_arrhenius(self): + """SurfaceArrhenius: type is interface-Arrhenius, rate-constant in J/mol.""" + h2 = self._create_dummy_species("H2", "[H][H]", index=1) + x = self._create_surface_species("X", "1 X u0 p0", index=2) + hx = self._create_surface_species( + "H_X", "1 H u0 p0 {2,S}\n2 X u0 p0 {1,S}", index=3 + ) + kin = SurfaceArrhenius( + A=(1e13, "m^2/(mol*s)"), n=0.5, Ea=(50, "kJ/mol"), T0=(1, "K") + ) + rxn = Reaction( + reactants=[h2, x], products=[hx, hx], kinetics=kin + ) + entries = reaction_to_dict_list(rxn, species_list=[h2, x, hx]) + assert len(entries) == 1 + d = entries[0] + assert d["type"] == "interface-Arrhenius" + assert "rate-constant" in d + assert np.isclose(d["rate-constant"]["A"], 1e13) + assert np.isclose(d["rate-constant"]["b"], 0.5) + assert np.isclose(d["rate-constant"]["Ea"], 50000.0) # J/mol + + def test_reaction_to_dict_sticking_coefficient(self): + """StickingCoefficient: type is sticking-Arrhenius, A is dimensionless.""" + h2 = self._create_dummy_species("H2", "[H][H]", index=1) + x = self._create_surface_species("X", "1 X u0 p0", index=2) + hx = self._create_surface_species( + "H_X", "1 H u0 p0 {2,S}\n2 X u0 p0 {1,S}", index=3 + ) + kin = StickingCoefficient( + A=(0.1, ""), n=0, Ea=(0, "kJ/mol"), T0=(1, "K") + ) + rxn = Reaction( + reactants=[h2, x, x], products=[hx, hx], kinetics=kin + ) + entries = reaction_to_dict_list(rxn, species_list=[h2, x, hx]) + assert len(entries) == 1 + d = entries[0] + assert d["type"] == "sticking-Arrhenius" + assert "sticking-coefficient" in d + assert np.isclose(d["sticking-coefficient"]["A"], 0.1) + assert np.isclose(d["sticking-coefficient"]["Ea"], 0.0) + + def test_reaction_to_dict_coverage_dependence(self): + """Coverage-dependent kinetics: coverage-dependencies block written correctly. + + yaml_cantera2 declares activation-energy: J/mol, so E uses value_si + (J/mol) directly — no ×1000 conversion. + """ + h2 = self._create_dummy_species("H2", "[H][H]", index=1) + x = self._create_surface_species("X", "1 X u0 p0", index=2) + hx = self._create_surface_species( + "H_X", "1 H u0 p0 {2,S}\n2 X u0 p0 {1,S}", index=3 + ) + kin = StickingCoefficient( + A=(0.1, ""), + n=0, + Ea=(0, "kJ/mol"), + T0=(1, "K"), + coverage_dependence={ + hx: {"a": 0.5, "m": -1.0, "E": (5.0, "kJ/mol")} + }, + ) + rxn = Reaction( + reactants=[h2, x, x], products=[hx, hx], kinetics=kin + ) + entries = reaction_to_dict_list(rxn, species_list=[h2, x, hx]) + d = entries[0] + assert "coverage-dependencies" in d + cov = d["coverage-dependencies"]["H_X(3)"] + assert np.isclose(cov["a"], 0.5) + assert np.isclose(cov["m"], -1.0) + # 5 kJ/mol = 5000 J/mol — written directly (J/mol units declared) + assert np.isclose(cov["E"], 5000.0) + + def test_reaction_to_dict_thirdbody_unit(self): + """ThirdBody: type three-body, efficiencies map, rate-constant present.""" + h = self._create_dummy_species("H", "[H]", index=1) + h2 = self._create_dummy_species("H2", "[H][H]", index=2) + ar = self._create_dummy_species("Ar", "[Ar]", index=3) + kin = ThirdBody( + arrheniusLow=Arrhenius( + A=(1e18, "cm^6/(mol^2*s)"), n=-1, Ea=(0, "J/mol"), T0=(1, "K") + ), + efficiencies={ar.molecule[0]: 0.7}, + ) + rxn = Reaction(reactants=[h, h], products=[h2], kinetics=kin) + entries = reaction_to_dict_list(rxn, species_list=[h, h2, ar]) + d = entries[0] + assert d.get("type") == "three-body" + assert "rate-constant" in d + assert "efficiencies" in d + assert np.isclose(d["efficiencies"]["Ar(3)"], 0.7) diff --git a/test/rmgpy/yaml_writer/compare_yaml_outputs.py b/test/rmgpy/yaml_writer/compare_yaml_outputs.py new file mode 100644 index 00000000000..b5634792250 --- /dev/null +++ b/test/rmgpy/yaml_writer/compare_yaml_outputs.py @@ -0,0 +1,228 @@ +import os +import yaml +import pandas as pd +import re +from collections import Counter + +class YamlAnalyst: + def __init__(self, path_to_yaml_file): + self.path_to_yaml_file = path_to_yaml_file + + def get_absolute_path(self): + # If path is already absolute, use it; otherwise join with cwd + if os.path.isabs(self.path_to_yaml_file): + return self.path_to_yaml_file + return os.path.join(os.getcwd(), self.path_to_yaml_file) + + def load_yaml_file(self): + with open(self.get_absolute_path(), 'r') as file: + return yaml.safe_load(file) + + def get_species(self): + return self.load_yaml_file()['species'] + + def get_species_count(self): + return len(self.get_species()) + + def get_species_names(self): + return [specie['name'] for specie in self.get_species()] + + def get_species_count_per_phase(self): + return {f"specie_count_{phase['name']}": len(phase['species']) for phase in self.load_yaml_file()['phases']} + + def get_reactions_dict(self): + reactions_dict = {} + data = self.load_yaml_file() + for key, values in data.items(): + if key in [f"{phase['name']}-reactions" for phase in data['phases']]: + reactions_dict[key] = data[key] + elif key == 'gas_reactions': + reactions_dict['gas_reactions'] = data['gas_reactions'] + elif key == 'surface_reactions': + reactions_dict['surface_reactions'] = data['surface_reactions'] + elif key == 'reactions': + # Gas-only mechanisms use plain 'reactions' key + reactions_dict['reactions'] = data['reactions'] + return reactions_dict + + def create_reaction_df(self, reactions): + data = [] + for reaction in reactions: + row = {'equation': reaction['equation']} + if 'rate-constant' in reaction: + row.update(reaction['rate-constant']) + elif 'sticking-coefficient' in reaction: + row.update(reaction['sticking-coefficient']) + data.append(row) + return pd.DataFrame(data) + def get_reaction_df(self): + reaction_dfs = {key: self.create_reaction_df(value) for key, value in self.get_reactions_dict().items()} + return reaction_dfs + + def get_reaction_count(self): + return {key: len(value) for key, value in self.get_reactions_dict().items()} + +class CompareYaml: + ''' + Compare two YAML files. + + Args: + yaml_path_1: Path to the first YAML file. + yaml_path_2: Path to the second YAML file. + ''' + def __init__(self, yaml_path_1, yaml_path_2): + self.yaml1 = YamlAnalyst(yaml_path_1) + self.yaml2 = YamlAnalyst(yaml_path_2) + + def compare_species_count(self): + count1 = self.yaml1.get_species_count() + count2 = self.yaml2.get_species_count() + if count1 - count2 == 0: + return True + else: + return False + + def compare_species_names(self): + names1 = set(self.yaml1.get_species_names()) + names2 = set(self.yaml2.get_species_names()) + if set(names1) == set(names2): + return True + else: + return False + + def compare_species_count_per_phase(self): + count_per_phase1 = self.yaml1.get_species_count_per_phase() + count_per_phase2 = self.yaml2.get_species_count_per_phase() + phase_names1 = [phase['name'] for phase in self.yaml1.load_yaml_file()['phases']] + phase_names2 = [phase['name'] for phase in self.yaml2.load_yaml_file()['phases']] + all_phase_names = set(phase_names1).union(set(phase_names2)) + count_diff = {'gas': count_per_phase1[f"specie_count_{phase_names1[0]}"] - count_per_phase2[f"specie_count_{phase_names2[0]}"], + 'surface': count_per_phase1[f"specie_count_{phase_names1[1]}"] - count_per_phase2[f"specie_count_{phase_names2[1]}"] + } + if count_diff['gas'] == 0 and count_diff['surface'] == 0: + return True + else: + return False + + def normalize_equation(self, equation): + def process_side(side): + # Extract and remove (+M) or +M third-body markers + has_third_body = False + side_clean = side.strip() + if '(+M)' in side_clean: + has_third_body = True + side_clean = side_clean.replace('(+M)', '').strip() + elif side_clean.strip().endswith('+ M'): + has_third_body = True + side_clean = side_clean.rsplit('+ M', 1)[0].strip() + + components = side_clean.split('+') + expanded = [] + for component in components: + component = component.strip() + if not component: + continue + # Match optional integer coefficient prefix (e.g. "2 CH3(14)") + m = re.match(r'^(\d+)\s+(.+)$', component) + if m: + count = int(m.group(1)) + species = m.group(2).strip() + expanded.extend([species] * count) + else: + expanded.append(component) + + result = ' + '.join(sorted(expanded)) + if has_third_body: + result += ' (+M)' + return result + + # Handle both reversible (<=>) and irreversible (=>) reactions + if '<=>' in equation: + reactants, products = equation.split('<=>') + separator = '<=>' + elif '=>' in equation: + reactants, products = equation.split('=>') + separator = '=>' + else: + raise ValueError(f"Unknown reaction format: {equation}") + + normalized_reactants = process_side(reactants) + normalized_products = process_side(products) + return f"{normalized_reactants} {separator} {normalized_products}" + + def compare_reactions(self): + """Compare reactions between two YAML files. + + First checks that reaction counts and normalized equations match. + Then uses Cantera to load both files and compares forward rate + constants at a reference state to verify kinetic equivalence, + since the two files may use different unit systems internally. + """ + import cantera as ct + import numpy as np + + reactions1 = self.yaml1.get_reaction_df() + reactions2 = self.yaml2.get_reaction_df() + + # Check if total reaction counts match + count1 = sum(len(df) for df in reactions1.values()) + count2 = sum(len(df) for df in reactions2.values()) + if count1 != count2: + return False + + # Collect all normalized equations from each file (using Counter to handle duplicates) + all_eqs_1 = Counter() + all_eqs_2 = Counter() + for key, df in reactions1.items(): + all_eqs_1.update(df['equation'].apply(self.normalize_equation)) + for key, df in reactions2.items(): + all_eqs_2.update(df['equation'].apply(self.normalize_equation)) + + # Check that all reaction equations are present in both files + if all_eqs_1 != all_eqs_2: + return False + + # Use Cantera to compare actual rate constants, since the two files + # may store A/Ea values in different unit systems + yaml1_path = self.yaml1.get_absolute_path() + yaml2_path = self.yaml2.get_absolute_path() + try: + gas1 = ct.Solution(yaml1_path) + gas2 = ct.Solution(yaml2_path) + except Exception as e: + # If Cantera can't load the files, fall back to equation-only comparison + print(f"Warning: Cantera failed to load one or both files: {e}") + print(f"Falling back to equation-only comparison") + return True + + # Compare at a reference state + T, P = 1000.0, ct.one_atm + # Build a composition string from species common to both + species_names = [s.name for s in gas1.species()] + if len(species_names) >= 2: + comp = f"{species_names[0]}:0.5, {species_names[1]}:0.5" + else: + comp = f"{species_names[0]}:1.0" + + gas1.TPX = T, P, comp + gas2.TPX = T, P, comp + + kf1 = gas1.forward_rate_constants + kf2 = gas2.forward_rate_constants + + # Use relative tolerance for comparison; allow 1% difference + # to account for Chemkin format precision loss + result = np.allclose(kf1, kf2, rtol=0.01, atol=1e-50) + + if not result: + # Find which reactions differ + diff_mask = ~np.isclose(kf1, kf2, rtol=0.01, atol=1e-50) + diff_indices = np.where(diff_mask)[0] + print(f"\n{len(diff_indices)} reactions have mismatched rate constants:") + for idx in diff_indices[:5]: # Show first 5 + rxn1 = gas1.reaction(int(idx)) + rxn2 = gas2.reaction(int(idx)) + print(f" Reaction {idx}: {rxn1.equation}") + print(f" RMG kf: {kf1[idx]:.6e}, CK kf: {kf2[idx]:.6e}, ratio: {kf1[idx]/kf2[idx] if kf2[idx] != 0 else 'inf':.4f}") + + return result diff --git a/test/rmgpy/yaml_writer/test_yaml.py b/test/rmgpy/yaml_writer/test_yaml.py new file mode 100644 index 00000000000..9fa3f020db4 --- /dev/null +++ b/test/rmgpy/yaml_writer/test_yaml.py @@ -0,0 +1,28 @@ +from compare_yaml_outputs import CompareYaml +import os +import pytest + +@pytest.fixture(scope="module") +def compare_manager(): + '''Create instance of a Compare Yaml before each test''' + test_data_folder='test/rmgpy/test_data/yaml_writer_data/' + # saved by Prosper in earlier commit + yaml_path_1 = os.path.join(test_data_folder, 'chemkin/chem0047-gas.yaml') + yaml_path_2 = os.path.join(test_data_folder, 'cantera/chem47.yaml') + + # generated on the fly in recent functional test + yaml_path_1 = os.path.join(test_data_folder, 'chemkin/chem37.yaml') + yaml_path_2 = os.path.join(test_data_folder, 'cantera/chem37.yaml') + return CompareYaml(yaml_path_1, yaml_path_2) + +def test_compare_number_of_species(compare_manager): + assert compare_manager.compare_species_count() == True + +def test_compare_species_names(compare_manager): + assert compare_manager.compare_species_names() == True + +def test_compare_species_count_per_phase(compare_manager): + assert compare_manager.compare_species_count_per_phase() == True + +def test_compare_reactions(compare_manager): + assert compare_manager.compare_reactions() == True \ No newline at end of file