Python version of the amazing Reaction Mechanism Generator (RMG).

Reaction Mechanism Generator

Last update: Dec 27, 2022

Related tags

Deep Learning python chemistry reactions thermodynamics kinetics chemistry-discovery

Overview

Reaction Mechanism Generator (RMG)

Description

This repository contains the Python version of Reaction Mechanism Generator (RMG), a tool for automatically generating chemical reaction mechanisms for modeling reaction systems including pyrolysis, combustion, atmospheric science, and more.

It also includes Arkane, the package for calculating thermodynamics, high-pressure-limit rate coefficients, and pressure dependent rate coefficients from quantum chemical calculations. Arkane is compatible with a variety of ab initio quantum chemistry software programs: Gaussian, MOPAC, QChem, and MOLPRO.

Source Code Repository

RMG Github Repository: contains the latest source code for RMG
RMG-database Github Repository: contains source code for the latest version of the database

How to Install

You can either download the source from GitHub and compile yourself, or download the binaries from Anaconda. Please see the Download and Install page for detailed instructions.

Documentation

How to Contribute

Please see the Contributor Guidelines for details on how to contribute to RMG-Py or RMG-database.

How to Give Feedback

Please post any issues you may have to the issues page or drop in to the chat room or email [email protected] if you have questions.

Useful Links

Interactive Website: Visit this site to visualize RMG-generated models, view the databases, and perform thermodynamics and kinetics searches
Wiki: a wiki for developer notes
Issues Page: view current issues and feature requests

Credits

Resources and References

The resources and relevant publications are listed here on the RMG-website. Please at least cite our latest publication on Reaction Mechanism Generator v3.0 and other relevant publications when publishing the results using our software.

License Information

RMG is a free, open-source software package (distributed under the MIT/X11 license).

Comments

Using metal attributes
Motivation or Problem

Currently, RMG can only use surfaceThermoPt111 as it assumes the reference point is Pt111. We want to be able to:

use thermo from all sorts of different metals and use LSRs to scale to wherever

properly use kinetics training reactions that were on different metals (reverse reactions in particular)

This also adds a new metal database so users don't have to look up binding energies for specific metals of interest

Reviewer Tips

I just created this PR so we would have a place for discussion. Sister database PR is #387
Twin RMG-database PR Topic: Catalysis
opened by mazeau 68
Adding in coverage dependent effects to surface kinetics

Motivation or Problem

Coverage dependent effects are found in many surface mechanisms, and we have been unable to use them. These effects can become significant at high temperatures and pressures. Additionally, some models would have too much O2 adsorbing to the surface too quickly, blocking anything else from happening.

Description of Changes

A new kinetics attribute called coverage_dependence was added that is a dictionary of dictionaries that holds the Species the parameters correspond to and the coverage dependent parameters.

Testing

Unit tests to make sure RMG can read in kinetics entries with coverage dependent parameters, write chemkin and cantera output files with the coverage parameters, and use the parameters correctly. We've built a few models with it, and it seems to be working.

Note: dual PR with database.

Goes with https://github.com/ReactionMechanismGenerator/RMG-database/pull/462 The commits that add this to the CI testing should be removed from both PRs before merging.
Twin RMG-database PR Topic: Catalysis

opened by mazeau 41
Arkane output fixes

Motivation or Problem

Arkane makes calculating rate coefficients easy, but suffers from not outputting all information needed in publications and also sometimes has unexpected behavior due to poor structuring.

Description of Changes

This PR modularizes core methods, like loading statmech, kinetics, and thermo jobs; fixes the --plot option; uses species labels in chemkin files; adds try-except statments to prevent output from erroring; creates methods to parse T1 diagnostics, levels of theory, and geometries; allows for termolecular products to be output by pdep; outputs more quantum information necessary for publications; and makes chemkin output and merge models more robust.

Testing

Many of the new methods have unit tests to ensure proper functioning. I have run this version for large pressure dependent networks and highp kinetics and they function properly. I have not tested the explorer functionality, though the test methods for it continue to work.

Reviewer Tips

Test the explorer functionality. Ensure code makes sense and is written in a usable and expandable way.
Arkane Type: Code Organization Type: User Experience

opened by goldmanm 35
Multi-Dimensional Rotors
This PR enables ND empirical and semi-empirical rotor calculations along with 2D quantum mechanical rotor calculations.

ND empirical and semi-empirical rotors rely on scipy integration and interpolation algorithms. Frequencies are estimated by finding the hessian of a polynomial fit around the origin point of the rotor scans.

This PR enables 2D dimensional coupled rotor calculations using the 2D-NS approximation within Arkane using the external software Q2DTor written by David Ferro Costas and Antonio Fernandez Ramos. It adds a wrapper class in Arkane for computing the statistical mechanical properties of 2D coupled rotors using Q2DTor and adds rotor processing for 2D coupled rotors.

Installing my fork of Q2DTor:

git clone https://github.com/mjohnson541/Q2DTor.git git checkout arkane

add to your .bashrc or .bash_profile (as appropriate): export Q2DTor=/.../Q2DTor/src/Q2DTor.py (replacing ... with appropriate absolute path)

I've added an example for calculating the thermo of CH2CHOOH. However the full example takes ~5-8 hours of time to run. The wrapper (HinderedRotor2D) automatically checks for the presence of the .evals output file from Q2DTor that contains the eigenvalues of the Hamiltonian. If it finds this file it automatically skips the calculations and uses the eigenvalues to compute statistical mechanical properties. To shorten the example I've added all of the Q2DTor output files to the example allowing it to find the .evals file and finish rapidly.
Arkane Before Py3
opened by mjohnson541 32
Charged atom types
This must be pulled in simultaneously with the RMG-database PR also named chargedAT. Be sure to remove the first commit redirecting the travis build before merging

This PR adds the charge attribute to atomtypes with the goal to increase the diversity of nitrogen and sulfur groups we can represent. This also had some effect on the atomtypes for carbon monoxide. Additionally, we have renamed carbon and oxygen atomtypes to conform to the format of nitrogen and sulfur.

This was a major functional change, so many coding edits (besides refactoring atom type names in code and test database) were also included. Some of the major ones are listed below:

Molecule objects need correct lone pairs and charge to get correct atomtypes now. The Molecule.update() function and many tests were changed accordingly

Because of the previous point, sub-molecules used in the polycyclic thermo heuristic now need to be saturated before descending the tree for corrections. Otherwise, the charge/lone pairs get assumed incorrectly.

Now that we define lone pairs as part of the atom types, we no longer need to convert lone pairs to bi-radicals in solvation

Type: Feature Topic: Thermo Topic: Nitrogen Status: Ready for Review Twin RMG-database PR Topic: Sulfur
opened by nyee 30
surface bidentate thermo fix

Motivation or Problem

Surface bidentate reaction crashed (#2039) trying to get the thermo model for some species. It looks like it sometimes tried the wrong configuration of the gas-phase molecule.

Description of Changes

Added code to try multiple configurations and pick the one that works. If multiple configurations are valid it uses the lowest energy one.

Testing

Currently has thermo test for N(=X)N(X)OH and tests for the molecules mentioned in the issue 2039 thread: C*O* becomes C[-1]#O[+1] O*O* becomes [O][O] C*C* becomes [C]#[C] N*N*O becomes N#N=O (the middle Nitrogen has valence 5)

Reviewer Tips
Status: Ready for Review Topic: Catalysis

opened by sevyharris 28
Arkane Pdep Functional Test Fails Often
Bug Description

The latest build of #1561 failed with the following error:

====================================================================== FAIL: A general test for a PDep job in Arkane ---------------------------------------------------------------------- Traceback (most recent call last): File "/home/travis/build/ReactionMechanismGenerator/RMG-Py/arkane/pdepTest.py", line 104, in testPDepJob self.assertAlmostEquals(rxn.kinetics.getRateCoefficient(1000.0, 1.0), 88.88253229631246) AssertionError: 88.8819863725482 != 88.88253229631246 within 7 places

This PR does not change any part of Arkane or RMG's pdep code though, and in fact this error only showed when I recently rebased this branch on current master. I notice that this test fails often when I run the functional tests locally, and it appears that the number for the rate coefficient appears to drift slightly for reasons unknown (it appears to happen whenever we add a new Arkane example or functional test, for example I believe this was why the most recent change was made to this unit test here.)

I also wonder if it is somehow related to the error with the most recent Chlorine DB branch build here, where the order of the reactants has changed when the functional tests are run in this build.

A going theory that I have is that this is related to Arkane's use of global and module variables, which might cause problems when we run all of the Arkane examples at once, but I am not sure.

In the meantime, we might want to consider re-writing this test. Thoughts?

How To Reproduce

Run the RMG functional tests locally. Check out the errorCancelingReactions branch if need be.
Type: Risk of Error Arkane Topic: PDep Type: Bug Type: Testing
opened by amarkpayne 28
merge AFM code into RMG-Py

Motivation or Problem

Add fragment code to rmgpy/molecule

Description of Changes

Add fragment code, fragment test, fragment matching code under rmgpy/molecule folder

Testing

Add 60 tests in fragment_test.py

Reviewer Tips

Suggestions for verifying that this PR works or other notes for the reviewer.

Paired with rmg_database branch under RMG-database repo

opened by lily90502 27
"graphviz/libgvplugin_pango.so.6" - file not found" missing dependency on WSL installations
Topic

Kinetic Library Addition to RMG Training Data

Context

I couldn't work with "kinetics_library_to_training.ipynb" because of "error while loading shared libraries: libltdl.so.7" message. I tried to work with "kinetics_library_to_training_tools.py" but I didn't find how to use it.

Question

How to use "kinetics_library_to_training_tools.py" ?

Installation Information

OS : Windows 10, WSL, Ubuntu 18.04

Installation method: Miniconda using & download from github files

RMG version information:

RMG-Py: 3.1.0-59-g74b176a77

RMG-database: 3.0.0-206-g833577ec

kinetics_library_to_training_tools.txt kinetics_library_to_training.txt
Platform: Windows
opened by TaikiKato 25
Can rmg.py generate mechanism for reactive Nitrogen-containing molecules ?

Hi guys, I'm trying to generate n-phenyl-1-naphthylamines liquid phase oxidation mechanism in hexane solvent, and rmg reported that "PAN" is global forbidden species, so I went back to "ForbiddenStructures.py" and commented out species "N_birad_singlet_2singleBonds", systems started reporting error message: "Invalid valency for atom C with 0 unpaired electrons, 0 pairs of electrons, and 0 charge. "

I'm wondering if rmg.py can generate mechanism for reactive N-containing molecules, or seed mechanisms files or reaction libraries need to be pre-defined by the user in order to proceed?

Error messages are pasted below:

Traceback (most recent call last): File "C:\Anaconda2\RMGPycode\RMG-Py\rmg.py", line 165, in <module> rmg.execute(inputFile, output_dir, **kwargs) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\rmg\main.py", line 522, in execute self.initialize(inputFile, output_directory, **kwargs) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\rmg\main.py", line 434, in initialize raise ForbiddenStructureException("Input species {0} is globally forbidden. You may explicitly allow it, but it will remain inert unless found in a seed mechanism or reaction library.".format(spec.label)) rmgpy.data.base.ForbiddenStructureException: Input species PAN is globally forbidden. You may explicitly allow it, but it will remain inert unless found in a seed mechanism or reaction library.

Generating thermodynamics for new species... 1 radicals on [C]1=CC=CC2=CC=CC=C12 exceeds limit of 0. Using HBI method. Reading existing thermo file QMfiles\pm3\UFWIBTONFRDIAS-UHFFFAOYSA.thermo Traceback (most recent call last): File "C:\Anaconda2\RMGPycode\RMG-Py\rmg.py", line 165, in <module> rmg.execute(inputFile, output_dir, **kwargs) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\rmg\main.py", line 549, in execute bimolecularReact=self.bimolecularReact) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\rmg\model.py", line 752, in enlarge spec.generateThermoData(database, quantumMechanics=self.quantumMechanics) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\rmg\model.py", line 98, in generateThermoData thermo0 = database.thermo.getThermoData(self, trainingSet=None, quantumMechanics=quantumMechanics) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\data\thermo.py", line 755, in getThermoData tdata = self.estimateRadicalThermoViaHBI(molecule, quantumMechanics.getThermoData) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\data\thermo.py", line 1056, in estimateRadicalThermoViaHBI thermoData_sat = stableThermoEstimator(saturatedStruct) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\qm\main.py", line 194, in getThermoData thermo0 = qm_molecule_calculator.generateThermoData() File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\qm\molecule.py", line 324, in generateThermoData if self.loadThermoData(): File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\qm\molecule.py", line 374, in loadThermoData loadedMolecule = rmgpy.molecule.Molecule().fromAdjacencyList(local_context['adjacencyList']) File "rmgpy\molecule\molecule.py", line 1183, in rmgpy.molecule.molecule.Molecule.fromAdjacencyList (build\Release\pyrex\rmgpy\molecule\mo lecule.c:22764) File "rmgpy\molecule\molecule.py", line 1191, in rmgpy.molecule.molecule.Molecule.fromAdjacencyList (build\Release\pyrex\rmgpy\molecule\mo lecule.c:22339) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\molecule\adjlist.py", line 710, in fromAdjacencyList for atom in atoms: ConsistencyChecker.check_partial_charge(atom) File "C:\Anaconda2\RMGPycode\RMG-Py\rmgpy\molecule\adjlist.py", line 113, in check_partial_charge .format(symbol=atom.symbol, radicals=atom.radicalElectrons, lonePairs=atom.lonePairs, charge=atom.charge)) rmgpy.molecule.adjlist.InvalidAdjacencyListError: Invalid valency for atom C with 0 unpaired electrons, 0 pairs of electrons, and 0 charge.

opened by OUchemical 23
Enabling use of pyrms for RMG Simulations and Edge Analysis
This PR integrates pyrms into RMG enabling us to very easily write new reactor types running simulations and Edge Analysis in RMS.

There's a lot of small details that are worth mentioning:

Potentially farther reaching changes:

Species labels are forced to be unique

Kinetics and thermo are generated when the Species/Reaction objects are created instead of later in enlarge

As far as I can tell we seem to be unable to mix pyjulia and nosetests. This put some significant constraints on the structure of these changes. I managed to limit all the rms function calls to the new reactors.py file so this has almost no impact on our current testing infrastructure, however it does mean that the infrastructure in the reactors.py file can't be tested using our current nosetests framework. (This also means codecov is not going to like this PR).

Things this PR does not enable for RMS reactors:

Ranged reactors

Pressure dependence

Sensitivity analysis

save_simulation_profile

Surface (core-edge-surface) functionality (plan is to deprecate this since the branching algorithm is both simpler and more effective)

Since this PR is already very complex I elected to initially avoid some of the more complex RMG integrations, however none of these (apart from the surface one we were already planning to get rid of) will be very hard to do in the near future.

This PR is dependent on https://github.com/ReactionMechanismGenerator/ReactionMechanismSimulator.jl/pull/149 and will only pass tests once that RMS PR is merged.
opened by mjohnson541 21
Converting chemkin to RMG library

Topic

I would like to convert a chemkin file (txt format) from a literature paper, into RMG library, WITHOUT a species_dictionary file.

Context

The provided chemkin file in the literature basically has labels such as: M6C6H8O , B3, C5H7-1s-O , R4C6H7O. In most cases, the comment line has the following provided format: .ch2/ch2/ch3 , .c(//o)/o/ch3 (CH3OCO). Each paper in the literature has its own labels for species. For example, M4 can represent different species in different literature papers. I know there is a way to convert a chemkin file in RMG with a file of species_dictionary.txt. But, writing manually the species_dictionary.txt for all the species in a kinetic model provided by the paper, takes a lot of time.

Question

Is there a way to convert chemkin file without the species_dictionary file? (chemkin file from the literature is attached)

Thanks!

1-s2.0-S0010218017301256-mmc3.txt

opened by NellyMitnik 0
Duplicate reaction from different libraries make it into the model when only one of the reactions is ThirdBody
Bug Description

We ran RMG with primaryH2O2 and JetSurF2.0, and got the following reactions in the core:

! Reaction index: Chemkin #267; RMG #4198 ! Library reaction: JetSurF2.0 ! Flux pairs: H2O(7), H2O(7); H(3), H2(4); H(3), H2(4); H(3)+H(3)+H2O(7)=H2(4)+H2O(7) 5.624000e+19 -1.250 0.000 ! Reaction index: Chemkin #251; RMG #9 ! Library reaction: primaryH2O2 ! Flux pairs: H(3), H2(4); H(3), H2(4); H(3)+H(3)+M=H2(4)+M 7.000e+17 -1.000 0.000 Ar/0.00/ H2(4)/0.00/ H(3)/0.00/ H2O(7)/14.30/

Cantera complained that these are duplicate reactions:

CanteraError: ******************************************************************************* InputFileError thrown by Kinetics::checkDuplicates: Undeclared duplicate reactions detected: Reaction 264: 2 H(3) + M <=> H2(4) + M Reaction 248: 2 H(3) + H2O(7) <=> H2(4) + H2O(7) *******************************************************************************

Cantera is "correct" since the general reaction H(3)+H(3)+M=H2(4)+M also considers H2O as the collider (it's efficiency is not set to 0.

How To Reproduce

Run a model with both libraries that involves oxidation.

Expected Behavior

We expect that if a general reaction was added from one library (the +M reaction), then a specific reaction with a specific collider from another library will not be added. If the reverse occurs it is more problematic, yet we should (?) assume that each library is self-consistent and does not include only a single specific collider reaction without the "mother reaction".
opened by alongd 0
Make update

Motivation or Problem

I added a command to make for automating the updates for users that installed rmg from source. This is due to people having issues with forgetting to recompile after pulling. I think this process is a bit more user friendly, especially for the python users that sometimes forget to compile (myself included).

Description of Changes

I added a command to the Makefile for automatic updates, and added an appropriate explanation to the documentations.

opened by kfir4444 1
Runs fail due to Invalid k(E) values computed for path reaction.
Bug Description

Entire run fails due to Invalid k(E) values computed for path reaction. I was running a model in RMG, and recived the following traceback:

File "/home/kfir4444/Code/RMG-Py/rmgpy/pdep/network.py", line 841, in calculate_microcanonical_rates 'Invalid k(E) values computed for path reaction "{0}".'.format(rxn), k_ratio, Keq_ratio) rmgpy.exceptions.InvalidMicrocanonicalRateError: ('Invalid k(E) values computed for path reaction "[CH2]COCCOOC=COC=C(15350) <=> [CH2]COCCOOC(C=C)C=O(15448)".', 2.002077091766027, 1.0)

No, the model had core had 68 species and 1174 reactions, and the model edge had 15382 species and 32480 reactions prior to this, and I do not even know if that reaction would have made it to the core, which leads to wondering, whether this behavior is as intended.

How To Reproduce

Input file will be granted by request.

Expected Behavior

I would have wanted this reaction to be placed in the edge, and in another file, called requires_refinement.txt (or something of the sort) that I could use after this run.

Installation Information

Describe your installation method and system information.

OS Ubuntu 22.04

source

RMG version information:

RMG-Py: 3.1.0-616-gd82b6eddf

RMG-database: 3.0.0-577-g0de0ae134

Additional Context

I would like to suggest a fix for this problem myself, just need a developers opinion if it's a bug or a feature :)
opened by kfir4444 2
Add CITATION.bib file to make citing RMG easier

Motivation or Problem

RMG-py provides a list of citations, but does not take advantage of the GitHub Cite this Repository feature which automatically provides BibTex files with appropriate citations to users.

Description of Changes

This PR adds a single CITATION.cff file that is (hopefully) correctly formatted and accurate.

Testing

After merging, GitHub will automatically detect the file and add a Cite this Repository button, and any formatting/accuracy issues will then be obvious.

Reviewer Tips

The CITATION.cff file format is described here.

opened by JacksonBurns 6
Add CodeQL workflow for GitHub code scanning
Hi ReactionMechanismGenerator/RMG-Py!

This is a one-off automatically generated pull request from LGTM.com :robot:. You might have heard that we’ve integrated LGTM’s underlying CodeQL analysis engine natively into GitHub. The result is GitHub code scanning!

With LGTM fully integrated into code scanning, we are focused on improving CodeQL within the native GitHub code scanning experience. In order to take advantage of current and future improvements to our analysis capabilities, we suggest you enable code scanning on your repository. Please take a look at our blog post for more information.

This pull request enables code scanning by adding an auto-generated codeql.yml workflow file for GitHub Actions to your repository — take a look! We tested it before opening this pull request, so all should be working :heavy_check_mark:. In fact, you might already have seen some alerts appear on this pull request!

Where needed and if possible, we’ve adjusted the configuration to the needs of your particular repository. But of course, you should feel free to tweak it further! Check this page for detailed documentation.

Questions? Check out the FAQ below!

FAQ

Click here to expand the FAQ section

How often will the code scanning analysis run?

By default, code scanning will trigger a scan with the CodeQL engine on the following events:

On every pull request — to flag up potential security problems for you to investigate before merging a PR.

On every push to your default branch and other protected branches — this keeps the analysis results on your repository’s Security tab up to date.

Once a week at a fixed time — to make sure you benefit from the latest updated security analysis even when no code was committed or PRs were opened.

What will this cost?

Nothing! The CodeQL engine will run inside GitHub Actions, making use of your unlimited free compute minutes for public repositories.

What types of problems does CodeQL find?

The CodeQL engine that powers GitHub code scanning is the exact same engine that powers LGTM.com. The exact set of rules has been tweaked slightly, but you should see almost exactly the same types of alerts as you were used to on LGTM.com: we’ve enabled the security-and-quality query suite for you.

How do I upgrade my CodeQL engine?

No need! New versions of the CodeQL analysis are constantly deployed on GitHub.com; your repository will automatically benefit from the most recently released version.

The analysis doesn’t seem to be working

If you get an error in GitHub Actions that indicates that CodeQL wasn’t able to analyze your code, please follow the instructions here to debug the analysis.

How do I disable LGTM.com?

If you have LGTM’s automatic pull request analysis enabled, then you can follow these steps to disable the LGTM pull request analysis. You don’t actually need to remove your repository from LGTM.com; it will automatically be removed in the next few months as part of the deprecation of LGTM.com (more info here).

Which source code hosting platforms does code scanning support?

GitHub code scanning is deeply integrated within GitHub itself. If you’d like to scan source code that is hosted elsewhere, we suggest that you create a mirror of that code on GitHub.

How do I know this PR is legitimate?

This PR is filed by the official LGTM.com GitHub App, in line with the deprecation timeline that was announced on the official GitHub Blog. The proposed GitHub Action workflow uses the official open source GitHub CodeQL Action. If you have any other questions or concerns, please join the discussion here in the official GitHub community!

I have another question / how do I get in touch?

Please join the discussion here to ask further questions and send us suggestions!
opened by lgtm-com[bot] 1

Releases(3.1.0)

3.1.0(May 11, 2021)
RMG-Py Version 3.1.0

Date: April 23, 2021

We recommend creating a new conda environment using the latest environment.yml as many dependencies have changed, and upgrading an existing environment is always troublesome.

RMG-Py

Added support for Bromine

Added improved method to calculate temperature dependent solvation free energy

Made Rank 1 accuracy correspond to 0.2 kcal/mol instead of 0 kcal/mol

Improvements to Group Additivity comments, in particular adding missing group comments

Added support for trimolecular units in ArrheniusBM fits

Improvements to profiling

Use kekulized structures for transport estimation

Automatic tree generation script improvements

Properly short circuit is_isomorphic when strict=False

Added block for specifying species tuples to react when starting an RMG run

Improve ArrheniusBM fitting to a single reaction

Improvements in bidentate thermochemistry estimation

Added new surface attributes for metals and facets

Added support for Phosphorus

Enable use LSRs to scale thermo from different metals and enable proper use of training reactions from different metals

Added maximumSurfaceSites constraint

Arkane

Added frequency scaling factors for apfd/deef2tzvp and wb97xd/def2svp

Kinetics and pdep sensitivities additionally saved in YAML format

Enable automatic isodesmic reaction generation

AECs, BACs and frequency scaling factors moved from Arkane to RMG-database

Added functionality for Petersson and Melius BAC fitting using Arkane and the reference database

Enabled two parameter Arrhenius fit option

Added functionality for fitting AECs

Added classes to standardize model chemistry definitions

Use adjlists instead of smiles when saving

Bugfixes

QMTP updated to work with g16 executable

Fixed various Sticking Coefficient bugs

Fixed issues with Surface Arrhenius reactions written in the reverse being converted to ArrheniusEP instead of SurfaceArrheniusBEP

Fixed NaN handling in the explorer tool's steady state solve

Fixed determine_qm_software for Orca

Fixed bug where elementary_high_p library reactions with more than the maximum number of atoms for pdep never entered the edge

Fixed bug related to pdep networks having sources not contained in the core

Fixed various profiling bugs

Fixed issue with indexing when merging models

Fixed bug with ranged liquid reactors

Fixed bug with loading of autogenerated trees in Arkane

Fixed bug related to collision limit violation checks in LiquidReactor

Fixed bug related to Pmin and Pmax definition in SurfaceReactor

Fixed bugs in global uncertainty analysis for LiquidReactor

Fixed bug related to the units of reverse rate constants for reactions involving surface species

Fixed bug in Molecule isomorphism where it would simply assume the given initial map was correct

Remove deprecated matplotlib warn keyword

Fixed bug related to reading Chebyshev forms in Chemkin files

Fixed reference concentration for surface species when calculating Kc

Fixed issue with the reaction generation using the reversee of Surface_ElleyRideal_Addition_MultipleBond

Fixed bug with adjlist multiplicitly line being mistaken as the species name

Fixed bug with the library to training notebook

Remove temporary seed mechanisms if they exist from a previous run

Miscellaneous

Modified find_parameter_sources_and_assign_uncertainties to regenerate chem.inp as needed

Added option to save atom order when labeling template reactions

Added option to ignore atom type errors when creating molecule objects

Enable use of critical_distance_factor in from_xyz

Improved SIGINT handling when calling lpsolve

Enable H-bond drawing

Improvements to debug messages

Updated dependencies cclib and OpenBabel

Note that the upgrade to OpenBabel v3+ will change the interpretation of some ambiguous SMILES strings that use the lower-case aromatics notation. Although we think the new interpretation is not wrong, it might be different from previous versions, so take care.
Source code(tar.gz)
Source code(zip)
3.0.0(Dec 17, 2019)
This release represents a major milestone in RMG development and includes many backwards-incompatible changes, most notably Python 3 compatibility and major API changes. Users switching to RMG 3 will need to create new conda environments and update any scripts which access the API. We recommend using the futurize script from python-future for updating scripts for Python 3 and the provided rmg2to3.py script for updating scripts for RMG 3.

Python 3 #1724

RMG is now compatible with Python 3.7 and newer

RMG v2.x versions will no longer be supported

API changes

Method, function, and argument names have been standardized to use snake_case across RMG and Arkane

Input file related code was not changed, in order to continue support for existing syntax

Conversion script has been provided to aid transition (scripts/rmg2to3.py)

Standardized submodule names in the rmgpy.tools module #1794

Accompanying changes

Reduction and scoop_framework modules have been removed

New/updated hash and comparison methods for Species/Molecule/Atom/Bond classes

DDE thermochemistry estimator has been replaced by chemprop

Update example IPython notebooks #1735

Update global uncertainty module to work with MUQ 2 and Python 3 #1738

Miscellaneous clean up and bug fixes following transition #1741, #1744, #1752, #1759, #1785, #1802, #1798, #1799, #1808

Arkane

Improvements and refactoring of job output file creation and content #1607

Fix kinetics fitting bug #1672

Improvements to automatic network exploration tool #1647

Support for ND classical and semi-classical rotor calculations #1640, #1849

Support for 2D quantum mechanical rotor calculations using Q2DTor #1640

Support for providing absolute file paths #1685

Output RMG-style libraries #1769

Check for error termination in Gaussian log files #1766

Support for parsing Orca log files #1749

Support for parsing MP2, double hybrid DFT, CCSD, and CCSD(T) energies from Gaussian log files #1815

Support for TeraChem log files #1788

Miscellaneous bug fixes #1810

New features and other additions

Additional options for heterocycles in MLEstimator #1621

Automatic tree generation algorithm implementation completed #1486, #1675, #1848

New simulation restart approach using seed mechanisms (old pickle-based method removed) #1641

Added new MBSampledReactor type for simulating molecular beam experiments (does not support model generation) #1669

Improvements to group additivity thermo estimates for aromatics and sulfur species #1731, #1751

Improvements to solvation correction determination with multiple resonance structures #1832

Add support for reading and writing extended element syntax in Chemkin NASA polynomials #1636

Add support for fitting negative Arrhenius rates (found in MultiArrhenius data) #1834

Bug fixes

Fix numpy rcond usage to restore support for older numpy versions #1670

Fix bug with duplicate library reactions when using RMG generated seed mechanisms #1676

Move parse_command_line_arguments to facilitate importing in binary package #1717

Fix issues with is_identical_to methods of kinetics models #1705

Fix cython issue with make_object definitions #1817

Fix issue with estimating solvation corrections for radicals #1773

Fix parsing of certain types of RMG generated reaction comments #1842

Fix identifier generation for surface species using OpenBabel #1842

Fix mole fraction normalization for SimpleReactor #1809

Fix permissions error when writing seed mechanisms in WSL #1796

Fix issue with restarting from job without reaction filters #1847

Other

Improvements to mergeModels.py script #1649

Miscellaneous performance improvements #1677, #1765,

Raise errors when NaN is encountered in solver #1679

Allow sulfur species to have valence 12 in resonance algorithm #1751

Add support for maxproc argument to generate_reactions module #1780

Display atom index when drawing groups #1758

Update sensitivity example #1805

Update commented input file #1806

Generate reverse reaction recipes in reverse order of the forward recipe #1829

Add iodine to Chemkin elements list #1825

Remove unnecessary duplicate checking for seed mechanisms #1824

Organize examples for running RMG scripts #1840

Increase RDKit version requirement to avoid memory leak #1851

Logging changes #1721, #1755

Documentation updates #1680, #1709, #1767, #1781, #1784, #1807, #1845

Thanks to all contributors: ajocher, alongd, amarkpayne, cgrambow, dranasinghe, hwpang, kspieks, goldmanm, mazeau, mjohnson541, mliu49, oscarwumit, rwest, rgillis8, sarakha, sudoursa, xiaoruiDong, yunsiechung, zjburas
Source code(tar.gz)
Source code(zip)
2.4.1(Jul 23, 2019)
Bugfixes

Improve error handling in NASA as_dict method #1630

Fixes to Fluorine atomtypes #1656

Fix pressure dependent network generation #1658

Add support for reversing PDepArrhenius with MultiArrhenius rates #1659

Arkane

Implement ZPE scaling factor #1619

Refactor infrastructure for bond additivity corrections #1605

Add frequency scale factors for wb97xd/def2tzvp and apfd/def2tzvpp #1653

Fix frequency scale factors in example files #1657

Get element counts from conformers #1651

Miscellaneous

Update conda environment files #1623, #1644

Output RMS (Reaction Mechanism Simulator) format mechanism files #1629

Properly clean up files after running tests #1645

Documentation fixes #1650

Improve as_dict and make_object by making them recursive #1643

Source code(tar.gz)
Source code(zip)
2.4.0(Jun 14, 2019)
Heterogeneous catalysis!

RMG-cat fork has been merged #1573

Introduce SurfaceReactor

Thermo estimation for adsorbed species

Surface reaction generation and kinetics estimation

Introduce Van der Waals bonds (order 0) and quadruple bonds (order 4) #1542

Arkane

Automatically detect rotor symmetry #1526

Introduce new YAML files for storing and loading species statmech data #1402, #1551

Don't create species dictionary file if there are no structures #1528

Improvements to network explorer tool #1545

Improved class inheritance for quantum log file classes #1571

Automatic determination of optical isomers and symmetry using symmetry package #1571

Parse CCSD(T) energies from Molpro output #1592

Automatically determine molecule linearity #1601

Determine frequency scaling factor based on geom/freq method rather than sp method #1612

Improve logging related to energy barriers #1575

Ensure that translational mode is calculated for atoms #1620

Miscellaneous features

New enumerate_bonds method of Molecule to generate dictionary of bond types #1525

Introduce RMGObject parent class to support YAML dumping and loading #1402, #1540

Add support for fluorine atomtypes #1543

Introduce ArrheniusBM class for Blower-Masel kinetics #1461

Allow defining and using co-solvents for solvent libraries #1558

Introduce strict option to perform isomorphism between species/molecules while ignoring electrons and bond orders #1329

Molecule and Species objects can be instantiated by providing SMILES or InChI argument directly, and the identifiers can be accessed via the SMILES and InChI attributes #1329

Parallelization has been completely refactored using Python multiprocessing module in replacement of scoop, currently supports parallel reaction generation and QMTP #1459

Improvements to usability of uncertainty analysis functionality #1593

Bug fixes

Various fixes for supporting mono-atomic molecules in Arkane #1513, #1521

Ensure keras_backend is set consistently #1535

Fix handling of disconnected graphs in VF2 isomorphism algorithm #1538

Ignore hydrogen bonds when converting to RDKit molecule #1552

Other miscellaneous bugs #1546, #1556, #1593, #1600, #1622

Backward incompatible changes

Hydrogen bonds are now order 0.1 (instead of 0) #1542

New dependencies

pyyaml (required) #1402

scikit-learn (required) #1461

textgenrnn (optional) #1573

Other

Windows binaries are no longer officially supported. The new recommended way to use RMG on Windows computers is via a virtual machine or through the Linux subsystem. See documentation for updated installation instructions. #1531, #1534

Documentation updates #1544, #1567

Logging/exception improvements #1538, #1562

PEP-8 improvements #1566, #1592, #1596

Solver output files (png/csv) now report moles instead of mole fractions #1542

Replace global RMGDatabase object if the database is reloaded #1565

Print ML generated quote upon completion of RMG jobs #1573

Infrastructure for automatically generated reaction rate trees #1461

Testing related changes #1597, #1599

Updates to example Jupyter notebooks #1541, #1593

Source code(tar.gz)
Source code(zip)
2.3.0(Dec 21, 2018)
Arkane (formerly CanTherm):

CanTherm has been renamed to Arkane (Automated Reaction Kinetics And Network Exploration)

New network exploration functionality using RMG-database

Support for all elements has been added for reading quantum output files

New supporting information output file with rotational constants and frequencies

Known thermo and kinetics can be provided in addition to quantum information

Improve general user experience and error handling

New machine learning thermo estimator

Estimate species thermochemistry using a graph convolutional neural network

Estimator trained on quantum calculations at B3LYP and CCSD(T)-F12 levels

Currently supports C/H/O/N, with an emphasis on cyclic molecules

Resonance:

New pathways added for lone-pair multiple-bond resonance, replacing two pathways which were more specific

New pathways added for aryne resonance

Aromatic resonance pathways simplified and refactored to use filtration

Kekule structures are now considered unreactive structures

Miscellaneous changes:

Isotope support added for reading and writing InChI strings

New branching algorithm for picking up feedback loops implemented (beta)

Global forbidden structure checking is now only done for core species for efficiency, which may lead to forbidden species existing in the edge

Minor improvements to symmetry algorithm to fix a few incorrect cases

Bug fixes:

Fixed issue where react flags were being reset when filterReactions was used with multiple reactors, resulting in no reactions generated

File paths for collision violators log changed to output directory

Fixed bug in local uncertainty introduced by ranged reactor changes

Fixed bug with diffusion limitation calculations for multi-molecular reactions

Various other minor fixes

Source code(tar.gz)
Source code(zip)
2.2.1(Jul 23, 2018)
This release is minor patch which fixes a number of issues discovered after 2.2.0.

Collision limit checking:

RMG will now output a list of collision limit violations for the generated model

Fixes:

Ambiguous chemical formulas in SMILES lookup leading to incorrect SMILES generation

Fixed issue with reading geometries from QChem output files

React flags for reaction filter were not properly updated on each iteration

Fixed issue with inconsistent symmetry number calculation

Source code(tar.gz)
Source code(zip)
2.2.0(Jul 16, 2018)
New features:

New ring membership attribute added to atoms. Can be specified in group adjacency lists in order to enforce ring membership of atoms during subgraph matching.

Reactors now support specification of T, P, X ranges. Different conditions are sampled on each iteration to optimally capture the full parameter space.

New termination type! Termination rate ratio stops the simulation when the characteristic rate falls to the specified fraction of the maximum characteristic rate. Currently not recommended for systems with two-stage ignition.

New resonance transitions implemented for species with lone pairs (particularly N and S containing species). A filtration algorithm was also added to select only the most representative structures.

Formal support for trimolecular reaction families.

New isotopes module allows post-processing of RMG mechanisms to generate a mechanism with isotopic labeling.

Changes:

Library reactions can now be integrated into RMG pdep networks if the new elementary_high_p attribute is True

Library reactions may be duplicated by pdep reactions if the new allow_pdep_route attribute is True

Jupyter notebook for adding new training reactions has been revamped and is now located at ipython/kinetics_library_to_training.ipynb

Syntax for recommended families has changed to set notation instead of dictionaries, old style still compatible

Ranking system for database entries expanded to new 0-11 system from the old 0-5 system

Collision limit checking has been added for database entries

Cantherm:

Improved support for MolPro output files

Added iodine support

Automatically read spin multiplicity from quantum output

Automatically assign frequency scale factor for supported model chemistries

Plot calculated rates and thermo by default

New sensitivity analysis feature analyzes sensitivity of reaction rates to isomer/TS energies in pdep networks

Fixes:

Properly update charges when creating product templates in reaction families

Excessive duplicate reactions from different resonance structures has been fixed (bug introduced in 2.1.3)

Fixed rate calculation for MultiPdepArrhenius objects when member rates have different plists

A more formal deprecation process is now being trialed. Deprecation warnings have been added to functions to be removed in version 2.3.0:

All methods related to saving or reading RMG-Java databases and old-style adjacency lists

The group additivity method for kinetics estimation (unrelated to thermo group additivity)

The saveRestartPeriod option and the old method of saving restart files

Source code(tar.gz)
Source code(zip)
2.1.9(May 15, 2018)
Cantherm:

Atom counts are no longer necessary in input files and are automatically determined from geometries

Custom atom energies can now be specified in input files

Removed atom energies for a few ambiguous model chemistries

Add atom energies for B3LYP/6-311+g(3df,2p)

Changes:

Refactored molecule.parser and molecule.generator modules into molecule.converter and molecule.translator to improve code organization

SMILES generation now outputs canonical SMILES

Molecule.sortAtoms method restored for deterministic atom order

PDep reactions which match an existing library reaction are no longer added to the model

Fixes:

Fix issue with reaction filter initiation when using seed mechanisms

Source code(tar.gz)
Source code(zip)
2.1.8(May 2, 2018)
New features:

Chlorine and iodine atom types have been added, bringing support for these elements to RMG-database

Forbidden structures now support Molecule and Species definitions in addition to Group definitions

Changes:

Reaction pair generation will now fall back to generic method instead of raising an exception

Removed sensitivity.py script since it was effectively a duplicate of simulate.py

Thermo jobs in Cantherm now output a species dictionary

Fitted atom energy corrections added for B3LYP/6-31g**

Initial framework added for hydrogen bonding

Renamed molepro module and associated classes to molpro (MolPro) to match actual spelling of the program

Chemkin module is now cythonized to improve performance

Fixes:

Allow delocalization of triradicals to prevent hysteresis in resonance structure generation

Fix reaction comment parsing issue with uncertainty analysis

Fix numerical issue causing a number of pressure dependent RMG jobs to crash

Template reactions from seed mechanisms are now loaded as library reactions if the original family is not loaded

Fix issues with degeneracy calculation for identical reactants

Source code(tar.gz)
Source code(zip)
2.1.7(May 2, 2018)
Charged atom types:

Atom types now have a charge attribute to cover a wider range of species

New atom types added for nitrogen and sulfur groups

Carbon and oxygen atom types renamed following new valence based naming scheme

Ring perception:

Ring perception methods in the Graph class now use RingDecomposerLib

This includes the getSmallestSetOfSmallestRings methods and a newly added getRelevantCycles method

The set of relevant cycles is unique and generally more useful for chemical graphs

This also fixes inaccuracies with the original SSSR method

Other changes:

Automatically load reaction libraries when using a seed mechanism

Default kinetics estimator has been changed to rate rules instead of group additivity

Kinetics families can now be set to be irreversible

Model enlargement now occurs after each reactor simulation rather than after all of them

Updated bond additivity corrections for CBS-QB3 in Cantherm

Fixes:

Do not print SMILES when raising AtomTypeError to avoid further exceptions

Do not recalculate thermo if a species already has it

Fixes to parsing of family names in seed mechanisms

Source code(tar.gz)
Source code(zip)
2.1.6(May 2, 2018)
Model resurrection:

Automatically attempts to save simulation after encountering a DASPK error

Adds species and reactions in order to modify model dynamics and fix the error

New features:

Add functionality to read RCCSD(T)-F12 energies from MolPro log files

Add liquidReactor support to flux diagram generation

Other changes:

Removed rmgpy.rmg.model.Species class and merged functionality into main rmgpy.species.Species class

Refactored parsing of RMG-generated kinetics comments from Chemkin files and fixed related issues

Refactored framework for generating reactions to reduce code duplication

Resonance methods renamed from generateResonanceIsomers to generate_resonance_structures across all modules

Raise CpInf to Cphigh for entropy calculations to prevent invalid results

Fixes:

Update sensitivity analysis to use ModelSettings and SimulatorSettings classes introduced in v2.1.5

Fixed generate_reactions methods in KineticsDatabase to be directly usable again

Fixed issues with aromaticity perception and generation of aromatic resonance structures

Source code(tar.gz)
Source code(zip)
2.1.5(May 2, 2018)
New bicyclic formula:

Estimates polycyclic corrections for unsaturated bicyclics by adjusting the correction for the saturated version

Can provide a decent estimate in many cases where there is not an exact match

Other changes:

Refactored simulation algorithm to properly add multiple objects per iteration

Print equilibrium constant and reverse rate coefficient values when using Cantherm to calculate kinetics

Speed up degeneracy calculation by reducing unnecessary operations

Fixes:

Loosen tolerance for bond order identification to account for floating point error

Fixed uncertainty analysis to allow floats as bond orders

Fixed some comment parsing issues in uncertainty analysis

Added product structure atom relabeling for families added in RMG-database v2.1.5

Fixed issue with automatic debugging of kinetics errors due to forbidden structures

Source code(tar.gz)
Source code(zip)
2.1.4(May 2, 2018)
Accelerator tools:

Dynamics criterion provides another method to expand the mechanism by adding reactions to the core

Surface algorithm enables better control of species movement to the core when using the dynamics criterion

Multiple sets of model parameters can now be specified in a input file to allow different stages of model generation

A species number termination criterion can now be set to limit model size

Multiple items can now be added per iteration to speed up model construction

New ModelSettings and SimulatorSettings classes for storing input parameters

New features:

Kinetics libraries can now be automatically generated during RMG runs to be used as seeds for subsequent runs

Loading automatically generated seed mechanisms recreates the original template reaction objects to allow restarting runs from the seed mechanism

Carbene constraints can now be set in the species constraint block using maxSingletCarbenes and maxCarbeneRadicals

Chirality is now considered for determining symmetry numbers

Thermodynamic pruning has been added to allow removal of edge species with unfavorable free energy (beta)

Other changes:

RMG-Py exception classes have been consolidated in the rmgpy.exceptions module

Species labels will now inherit the label from a matched thermo library entry

Sensitivity analysis is now available for LiquidReactor

Fixes:

Fixed sensitivity analysis following changes to the simulate method

Add memory handling when generating collision matrix for pressure dependence

Improved error checking for MOPAC

Prevent infinite loops when retrieving thermo groups

Known issues:

Seed mechanisms cannot be loaded if the database settings are different from the original ones used to generate the seed

Source code(tar.gz)
Source code(zip)
2.1.3(May 2, 2018)
Thermo central database:

Framework for tracking and submitting species to a central database have been added

Following species submission, the central database will queue and submit quantum chemistry jobs for thermochemistry calculation

This is an initial step towards self-improving thermochemistry prediction

Rotor handling in Cantherm:

Free rotors can now be specified

Limit number of terms used when fitting hinder rotor scans

Fixed bug with ZPE calculation when using hindered rotors

New reaction degeneracy algorithm:

Use atom ID's to distinguish degenerate reactions from duplicates due to other factors

Degeneracy calculation now operates across all families rather than within each separately

Multiple transition states are now identified based on template comparisons and kept as duplicate reactions

Nodal distances:

Distances can now be assigned to trees in reaction families

This enables better rate averages with multiple trees

Fixed bug with finding the closest rate rule in the tree

New features:

Added methods for automatically writing RMG-database files

New symmetry algorithm improves symmetry number calculations for resonant and cyclic species

Group additivity algorithm updated to apply new long distance corrections

Specific colliders can now be specified for pressure-dependent rates

Very short superminimal example added (hydrogen oxidation) for checking basic RMG operation

Cantera now outputs a Chemkin file which can be directly imported into Chemkin

Fixes:

Fixed bug with negative activation energies when using Evans-Polanyi rates

Fixed walltime specification from command line when running RMG

Fixes and unit tests added for diffusionLimited module

Known issues:

The multiple transition state algorithm can result in undesired duplicate reactions for reactants with multiple resonance structures

Source code(tar.gz)
Source code(zip)
2.1.2(May 2, 2018)
Improvements:

New nitrogen atom types

Kinetics libraries can now be specified as a list of strings in the input file

New script to generate output HTML locally: generateChemkinHTML.py

New kekulization module replaces RDKit for generating Kekule structures

Benzene bonds can now be reacted in reaction families

Removed cantherm.geometry module due to redundancy with statmech.conformer

Fixes:

Reaction direction is now more deterministic after accounting for floating point error

Multiple bugs with resonance structure generation for aromatics have been addressed

Source code(tar.gz)
Source code(zip)
2.1.1(May 2, 2018)
Uncertainty analysis:

Local and global uncertainty analysis now available for RMG-generated models

Global uncertainty analysis uses MIT Uncertainty Quantification library, currently only supported on Linux systems

Examples for each module are available in localUncertainty.ipynb and globalUncertainty.ipynb

Fixes:

Clar structure generation no longer intercepts signals

Fixes to SMILES generation

Fix default spin state of [CH]

Source code(tar.gz)
Source code(zip)
2.1.0(Mar 8, 2017)
This release contains several new features and bug-fixes.

Clar structure generation

optimizes the aromatic isomer representations in RMG

lays the foundations for future development of poly-aromatic kinetics reaction families

Flux pathway analysis

introduces an ipython notebook for post-generatation pathway analysis (ipython.mechanism_analyzer.ipynb)

visualizes reactions and provides flux statistics in a more transparent way

Cantera mechanism

automatically writes cantera version of RMG-generated mechanism at the end of RMG jobs

Fixes bugs

upgrades pruning to fix new memory leaks introduced by recent functionalities

fixes the bug of duplicated species creation caused by getThermoData removing isomers unexpectedly

fixes restart file generation and parsing problems and users can choose restart mode again

upgrades bicyclic decomposition method such that more deterministic behaviors are ensured

change bond order type to float from string to improve RMG's symmetry calculation for species with multiple resonance structures

Source code(tar.gz)
Source code(zip)
2.0.0(Sep 17, 2016)
This release includes several milestones of RMG project (see installation here):

Parallelization finally introduced in RMG:

Generates reactions during enlarge step in parallel fashion (rmgpy.rmg.react)

Enables concurrent computing for QMTP thermochemistry calculations (rmgpy.thermo.thermoengine)

Instructions of running RMG parallel mode can be found here for SLURM scheduler and here for SGE scheduler.

Polycyclic thermochemistry estimation improved:

Extends group additivity method for polycyclics and estimates polycyclics of any large sizes by a heuristic method (bicyclics decomposition)

New tree averaging for kinetics:

Fixes previous issue of imcomplete generation of cross-level rate rules

Implements Euclidean distance algorithm for the selection of the best rate rules to use in estimateKinetics

Streamlines storage of kinetics comments for averaged rules, which can be analyzed by extractSourceFromComments

Database entry accessibility tests:

Adds entry accessibility tests for future entries (testing.databaseTest)

Fixes bugs

fluxdiagram generation is now fixed, one can use it to generate short video of fluxdigram evolution

mac environment yml file is introduced to make sure smooth RMG-Py installation and jobs on mac

fixes failure of checkForExistingSpecies for polyaromatics species

fixes execution failure when both pruning and pDep are turned on

fixes pDep irreversible reactions

fixes issue of valency of Cbf atom by dynamic benzene bond order assignment

Source code(tar.gz)
Source code(zip)
1.0.5(Aug 22, 2016)

Source code(tar.gz)
Source code(zip)
1.0.4(Mar 29, 2016)
IPython notebooks now found in the ipython folder and contains useful illustrative examples. Requires the installation of jupyter via the command conda install jupyter

Cantera support in RMG:

New module found in rmgpy.tools.canteraModel, which provides functions to help simulate RMG models using Cantera instead of native RMG solvers.

Has capability to generate cantera conditions and convert CHEMKIN files to cantera models, or use RMG to directly convert species and reactions objects to Cantera objects.

Demonstrative example found in ipython/canteraSimulation.ipynb

Module for regression testing of models generated by RMG

This new module is found at rmgpy.tools.observableRegression and helps identify differences between different versions of models generated by RMG, using the "observables" that the user cares about (i.e. main species mole fractions). Runs simulations via cantera.

Automatic plotting of simulations and sensitivities when generating models

Automatic plotting of simulations in the job's solver folder when saveSimulationProfiles is set to True in the input file.

Sensitivities for top 10 most sensitivie reactions and thermo now plotted automatically and stored in the solver folder.

New rmgpy.tools.plot module contains plotting classes useful for plotting simulations, sensitivities, and other data

CHEMKIN files are now read literally: unlisted bath gases are not added when loading a chemkin file

Functionality to assist in saving training reactions and thermo groups to RMG (see ipython notebook scripts in RMG-database/scripts/ for working examples)

Improved thermochemistry estimation (mostly for cyclics and polycyclics)

Add rank as an additional attribute in thermo database entries to determine trustworthiness

Fixes ring group retrieval when multiple rings or polycyclic rings are found in a single molecule

Changes to resonance isomer generation to fixes aromatic crashes and print more debugging information

Bug fixes:

Crashes with a useful error message when a Reaction Library and Seed Mechanism contains more than 3 reactants or products

Initial mole fractions get handled as floats to prevent integer division errors, and a useful message about renormalization is printed

Training reactions now load successfully regardless of generateSpeciesConstraints parameters (#602)

Transport data is now saved correctly to CHEMKIN tran.dat file and also imports successfully

Fixes appending of reactions to CHEMKIN file when reaction libraries are desired to be appended to output

Fixes writing of csv files for simulation and sensitivity results in Windows

Reverts the vertex connectivity value algorithm to prevent overflow errors

Fixes Reaction.draw() function to draw the entire reaction rather than a single species

Other fixes

Enforces compatible versions of matplotlib and cantera in anaconda build

Github pull requests from forked repo's will no longer fail Travis CI builds due to encrypted environment variable issues

Source code(tar.gz)
Source code(zip)
1.0.3(Feb 5, 2016)
Pdep convergence issues in RMG-Py v1.0.2 are now fixed.

RMG-database version information and anaconda binary version information is now recorded in the RMG log file.

Source code(tar.gz)
Source code(zip)
1.0.2(Feb 1, 2016)
Windows users can rejoice: RMG is now available in binary format on the Anaconda platform. Building by source is also much easier now through the Anaconda managed python environment for dependencies. See the updated Installation Page for more details

Reaction filtering for speeding up model generation has now been added. It has been shown to speed up model convergence by 7-10x. See more details about how to use it in your RMG job here. Learn more about the theory and algorithm on the Rate-based Model Enlarging Algorithm page.

The RMG native scripts are now organized under the rmgpy.tools submodule for developer ease and better extensibility in external scripts.

InChI conversion is now more robust for singlets and triplets, and augmented InChIs and InChI keys are now possible with new radical electron, lone pair, and multiplicity flags.

Output HTML for visualizing models are now cleaned up and also more functional, including features to display thermo comments, display enthalpy, entropy, and free energy of reaction, as well as filter reactions by species. You can use this new visualization format either by running a job in RMG v1.0.2 or revisualizing your CHEMKIN file and species dictionary using the visualization web tool

Source code(tar.gz)
Source code(zip)