Troubleshooting and Known Issues

Getting help

If the tips on this page don’t solve your problem, there are several ways you can ask for help, and we encourage you to do so. If we don’t hear what our users have trouble with, we can’t improve the software.

Users mailing list

There is an RMG-Users mailing list hosted by soureforge that you are welcome to join and/or email.

Developers mailing list

The developers can be reached quickly by emailing rmg_dev@mit.edu. We welcome your questions.

Issue Tracker

The developers use an issue tracker at https://github.com/GreenGroup/RMG-Java/issues/ to keep track of issues. Feel free to open an issue there. If searching for issues other people have had, be sure to check the closed issues too.

Known issues

Results differ from machine to machine.

The ODE solver (DASSL) will return slightly different results depending on the Fortran compiler, the compilation options, the machine architecture, etc. This is not a mistake, as all the results will be within the requested precision (ATOL and RTOL). However, in instances where two reaction fluxes have similar or identical rates, the small difference can lead to a different decision being made regarding which species to add to the core or which pressure-dependent network to explore next.

Results differ from run to run.

If you run the same input file twice on the same computer, the resulting chemistry should be the same. However, when a species with several isomers is created there is no guarantee that they will be numbered the same way. Therefore the species numbers (and hence names) will differ from run to run. This will make the log files and chemkin files look different.

Job freezes for a long time while running Fame.

Sometimes a pressure-dependent network calculation in Fame can have a very large output. When this output stretches to tens of megabytes, sometimes it can block the pipe through which the Fame program (written in Fortran) and the RMG program (in Java) communicate. When the computer is running low on memory this can be especially troublesome. On some computers the job has been known to freeze for tens of hours. The symptom is the job pauses, although the task manager of the computer suggests not a lot is happening. The only sure way to avoid this is to build a smaller model: use a higher termination criterion.

RMG does not recognize kinetics from multiple reaction family templates for the same structure

A “structure” is defined in RMG by a list of the reaction’s reactants and products, e.g., A <=> B or A <=> B + C. RMG can predict different pathways for the same structure, i.e. there are multiple ways for “A” to react to “B”. Some examples

1. n-butyl (.CH2-CH2-CH2-CH3) <=> iso-butyl (CH3-.CH-CH2-CH3)

   In this example, RMG will find two pathways between reactant and product: the three- and four-membered cyclic transition state. RMG estimates kinetics for each pathway and considers both in its mechanism generation algorithm.

   This materializes in the RMG output (particularly, the chem.inp file) in the following manner (for pressure-dependent simulations):

   C4H9-1(1)(+m)=C4H9-2(2)(+m)                             1.0E0 0.0 0.0   !NetReaction from PDepNetwork #1 (C4H9-1) High-P Limit: Summation of kinetics: !intra_H_migration estimate: (Average:)[ Others-R2H_S , C_rad_out_2H , Cs_H_out_H/(NonDeC/Cs) ]
   !intra_H_migration exact: [ Others-R3H_SS , C_rad_out_2H , Cs_H_out_H/NonDeC ]

   For pressure-independent simulations, the chem.inp will represent the multiple pathways in this manner:

   C4H9-1(1)=C4H9-2(2)                                  1.180e+10   0.82    35.10  !intra_H_migration exact:   [ Others-R3H_SS , C_rad_out_2H , Cs_H_out_H/NonDeC ]
   DUP
   C4H9-1(1)=C4H9-2(2)                                  1.938e+10   0.89    35.80  !intra_H_migration estimate: (Average:)  [ Others-R2H_S , C_rad_out_2H , Cs_H_out_H/(NonDeC/Cs) ]
   DUP

2. iso-propyl (CH3-.CH-CH3) + O2 <=> HO2 + propene

   In this example, RMG will find the chemical-activation route (i-C3H7 + O2 <–> .OOCH(CH3)2 <–> HOOCH(.CH2)(CH3) <–> HO2 + C3H6) and the pressure-independent route (via the Disproportionation reaction family template). These distinct kinetics materialize in the chem.inp (for pressure-dependent simulations) in the following manner:

   iC3H7(1)+O2(2)(+m)=C3H6(4)+HO2(3)(+m)                   1.0E0 0.0 0.0   !NetReaction from PDepNetwork #5 (adduct)
   TCHEB / 300.0 2000.0 /  PCHEB / 0.009869232667160128 98.69232667160128 /
   CHEB / 4        4 /
   CHEB / 1.1842000e+01 -6.3021000e-01 -1.3307000e-01 -1.8047000e-03 /
   CHEB / 6.3958000e-01 7.1487000e-01 1.1880000e-01 -1.4505000e-02 /
   CHEB / 1.0687000e-01 -5.1396000e-03 3.1099000e-02 1.5790000e-02 /
   CHEB / 1.7064000e-02 -7.5091000e-02 -8.5661000e-03 2.2822000e-03 /
   
   O2(2)+iC3H7(1)=HO2(3)+C3H6(4)                        1.270e+11   0.00    0.00   !Disproportionation exact:   [ O2_birad , Cmethyl_Csrad ]

3. C2H4 + .CH2-CH2-OH <=> .CH2-CH2-CH2-CH2-OH

   In this example, RMG can match this structure to two different reaction family templates: R_Addition_MultipleBond (where the C2H4 corresponds to .CH2-CH2-CH2-CH2-OH in the product) and 1,3_Insertion_ROR (where the C2H4 corresponds to .CH2-CH2-CH2-CH2-OH in the product). However, since the kinetics arise from different reaction family templates, RMG will currently only utilize the first set found in its mechanism generation algorithm (the other will be treated as a unwanted duplicate reaction and discarded).

   In a normal RMG run (with all reaction family templates turned on), the R_Addition_MultipleBond reaction family template will be found:

   C2H4(1)+SPC(2)=SPC(3)                                3.980e+03   2.44    5.37   !R_Addition_MultipleBond exact:   [ Cd/H2_Cd/H2 , C_rad/H2/Cs ]

   Turning off the R_Addition_MultipleBond reaction family template will produce this alternative result:

   C2H4(1)+SPC(2)=SPC(3)                                1.304e+03   2.92    44.63  !1,3_Insertion_ROR estimate: (Average:)  [ Cd/unsub_Cd/unsub , R_OH ]

   In this case, RMG (luckily) utilizes the faster of the two kinetics. However, this is NOT guaranteed: RMG uses the first kinetics instance found and ignores all other kinetics from different reaction family templates for the same structure.

While examples #1 and #2 are currently handled correctly in RMG, example #3 is not (only one instance of the B + C <=> A will be used in the simulation and reported in the output files).

RMG “Primary Kinetic Libraries” and “Reaction Libraries” do not handle irreversible reactions properly

If a reaction is specified as irreversible in a “Primary Kinetic Library” or “Reaction Library,” RMG will read in the reaction’s structure and kinetics properly. For example, suppose the reaction C2H5 => C2H4 + H were supplied in a “Primary Kinetic Library”. If a user supplied an input file to RMG with C2H5 in the condition file, RMG would run C2H5 against all RMG-defined reaction family templates. One of these templates would be R_Addition_MultipleBond; the reverse reaction family template (Beta_Scission) of which would find C2H5 = C2H4 + H. Thus, RMG would assign the kinetics supplied by the user in the “Primary Kinetic Library” to this reaction, instead of estimating it by traversing the kinetics tree.

However, the RMG reaction family template “Beta_Scission” is defined as reversible and thus RMG will also construct the reaction C2H4 + H => C2H5; the kinetics are computed through equilibrium. As of now, RMG cannot recognize that the user requested the reaction to be irreversible, so the mechanism generation algorithm will consider the reaction to be reversible. All RMG output files will thus report this reaction as reversible.

The user is advised NOT to supply irreversible reactions in any “Primary Kinetic Library” or any “Reaction Library”.

Troubleshooting

Final attempt (#36) on species ____ failed.

With QMTP: if after “Final attempt” it still fails, and reports the chemgraph of the species that failed, take this chemgraph and either provide thermochemistry for it in a primaryThermoLibrary, or else add it to your ForbiddenStructures section of your condition file or database.

Error with the ODE solver

You may see this at the end of your log file:

Reaction System 3 has not reached its termination criterion
although it seems to be valid (complete), so it was not interrupted for being invalid.
This probably means there was an error with the ODE solver, and we risk entering an endless loop.
Stopping.

If you scroll further up you will probably find that at least one of your reaction system simulations stopped with an error report from the ODE solver. This can happen if the system of differential equations becomes too stiff, and/or your error tolerances (ATOL and RTOL) for the solver are inappropriate. Try modifying them (either up or down), or use a looser termination criterion, or less extreme reaction system conditions. If RMG has nothing to do (all the systems have either converged or failed) then it would try running the simulations again without expanding the model, with the same result; to avoid an infinite loop, it stops with this message. The good news is, this only causes RMG to stop running if all the reaction systems that solved successfully have already converged and met their termination criteria.

Making valid CHEMKIN files

To create valid CHEMKIN files, ensure that any 3rd-body collider molecules used in your Seed Mechanisms or Reaction Libraries are either declared in their species.txt files (if they are reactive) or in the Inert Gases section of the input file. (i.e. it’s a good idea to list all of N2, Ne, He and Ar, even if their concentrations are 0).

The CHEMKIN input file chem.inp generated with the Verbose option turned “on” may have a comment that spans hundreds of characters. These verbose comments may cause the CHEMKIN interpreter to fail when running the Pre-Processor.

When running RMG on Windows it is possible that the chem.inp file will contain a mixture of linux and windows line endings. This can be a problem, for example if you want to read the chemkin file using Cantera. Convert the line endings using a program like dos2unix.