release 2.0.0 william h. green, richard h. west, and the rmg team · 2017-01-12 ·...

⇌RMGRMG-Py API Reference

Release 2.0.0

William H. Green, Richard H. West, and the RMG Team

Sep 16, 2016

CONTENTS

1 RMG API Reference 31.1 CanTherm (rmgpy.cantherm) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Chemkin files (rmgpy.chemkin) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.3 Physical constants (rmgpy.constants) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.4 Database (rmgpy.data) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.5 Kinetics (rmgpy.kinetics) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641.6 Molecular representations (rmgpy.molecule) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841.7 Pressure dependence (rmgpy.pdep) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081.8 QMTP (rmgpy.qm) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1181.9 Physical quantities (rmgpy.quantity) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1361.10 Reactions (rmgpy.reaction) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1401.11 Reaction mechanism generation (rmgpy.rmg) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1431.12 Reaction system simulation (rmgpy.solver) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1571.13 Species (rmgpy.species) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1601.14 Statistical mechanics (rmgpy.statmech) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1631.15 Thermodynamics (rmgpy.thermo) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Bibliography 189

Python Module Index 191

Index 193

i

RMG-Py API Reference, Release 2.0.0

RMG is an automatic chemical reaction mechanism generator that constructs kinetic models composed of elementarychemical reaction steps using a general understanding of how molecules react.

This is the API Reference guide for RMG. For instructions on how to use RMG, please refer to the User Guide.

For the latest documentation and source code, please visit http://reactionmechanismgenerator.github.io/RMG-Py/

CONTENTS 1

http://reactionmechanismgenerator.github.io/RMG-Py/


2 CONTENTS

CHAPTER

ONE

RMG API REFERENCE

This document provides the complete details of the application programming interface (API) for the Python versionof the Reaction Mechanism Generator. The functionality of RMG-Py is divided into many modules and subpackages.An overview of these components is given in the table below. Click on the name of a component to learn more andview its API.

Module Descriptionrmgpy.cantherm Computing chemical properties from quantum chemistry calculationsrmgpy.chemkin Reading and writing models in Chemkin formatrmgpy.constants Physical constantsrmgpy.data Working with the RMG databasermgpy.kinetics Kinetics models of chemical reaction ratesrmgpy.molecule Molecular representations using chemical graph theoryrmgpy.pdep Pressure-dependent kinetics from master equation modelsrmgpy.qm On-the-fly quantum calculationsrmgpy.quantity Physical quantities and unit conversionsrmgpy.reaction Chemical reactionsrmgpy.rmg Automatic reaction mechanism generationrmgpy.solver Modeling reaction systemsrmgpy.species Chemical speciesrmgpy.statmech Statistical mechanics models of molecular degrees of freedomrmgpy.thermo Thermodynamics models of chemical species

1.1 CanTherm (rmgpy.cantherm)

The rmgpy.cantherm subpackage contains the main functionality for CanTherm, a tool for computing thermody-namic and kinetic properties of chemical species and reactions.

1.1.1 Reading Gaussian log files

Class DescriptionGaussianLog Extract chemical parameters from Gaussian log files

1.1.2 Geometry

Class DescriptionGeometry The three-dimensional geometry of a molecular conformation

3


1.1.3 Input

Function DescriptionloadInputFile() Load a CanTherm job input file

1.1.4 Job classes

Class DescriptionCanTherm Main class for CanTherm jobsStatMechJob Compute the molecular degrees of freedom for a molecular conformationThermoJob Compute the thermodynamic properties of a speciesKineticsJob Compute the high pressure-limit rate coefficient for a reaction using transition state

theoryPressureDependenceJobCompute the phenomenological pressure-dependent rate coefficients k(T, P ) for a

unimolecular reaction network

1.1.5 Exceptions

Exception DescriptionGaussianError Raised when an error occurs while working with a Gaussian log file

rmgpy.cantherm.gaussian.GaussianLog

class rmgpy.cantherm.gaussian.GaussianLog(path)Represent a log file from Gaussian. The attribute path refers to the location on disk of the Gaussian log file ofinterest. Methods are provided to extract a variety of information into CanTherm classes and/or NumPy arrays.

getNumberOfAtoms()Return the number of atoms in the molecular configuration used in the Gaussian log file.

loadConformer(symmetry=None, spinMultiplicity=None, opticalIsomers=1)Load the molecular degree of freedom data from a log file created as the result of a Gaussian “Freq”quantum chemistry calculation. As Gaussian’s guess of the external symmetry number is not alwayscorrect, you can use the symmetry parameter to substitute your own value; if not provided, the value in theGaussian log file will be adopted. In a log file with multiple Thermochemistry sections, only the last onewill be kept.

loadEnergy(frequencyScaleFactor=1.0)Load the energy in J/mol from a Gaussian log file. The file is checked for a complete basis set extrapolation;if found, that value is returned. Only the last energy in the file is returned. The zero-point energy is notincluded in the returned value; it is removed from the CBS-QB3 value.

loadForceConstantMatrix()Return the force constant matrix from the Gaussian log file. The job that generated the log file must havethe option iop(7/33=1) in order for the proper force constant matrix (in Cartesian coordinates) to beprinted in the log file. If multiple such matrices are identified, only the last is returned. The units ofthe returned force constants are J/m^2. If no force constant matrix can be found in the log file, None isreturned.

loadGeometry()Return the optimum geometry of the molecular configuration from the Gaussian log file. If multiple suchgeometries are identified, only the last is returned.

4 Chapter 1. RMG API Reference


loadNegativeFrequency()Return the negative frequency from a transition state frequency calculation in cm^-1.

loadScanEnergies()Extract the optimized energies in J/mol from a log file, e.g. the result of a Gaussian “Scan” quantumchemistry calculation.

loadZeroPointEnergy()Load the unscaled zero-point energy in J/mol from a Gaussian log file.

rmgpy.cantherm.geometry.Geometry

class rmgpy.cantherm.geometry.Geometry(coordinates, number, mass)The three-dimensional geometry of a molecular configuration. The attributes are:

Attribute Type Descriptioncoordinates numpy.ndarray An N x 3 array containing the 3D coordinates of each atomnumber numpy.ndarray An array containing the integer atomic number of each atommass numpy.ndarray An array containing the atomic mass in kg/mol of each atom

The integer index of each atom is consistent across all three attributes.

getCenterOfMass(atoms=None)Calculate and return the [three-dimensional] position of the center of mass of the current geometry. If alist atoms of atoms is specified, only those atoms will be used to calculate the center of mass. Otherwise,all atoms will be used.

getInternalReducedMomentOfInertia(pivots, top1)Calculate and return the reduced moment of inertia for an internal torsional rotation around the axis definedby the two atoms in pivots. The list top1 contains the atoms that should be considered as part of the rotatingtop; this list should contain the pivot atom connecting the top to the rest of the molecule. The procedureused is that of Pitzer 1, which is described as I(2,3) by East and Radom 2. In this procedure, the moleculeis divided into two tops: those at either end of the hindered rotor bond. The moment of inertia of each topis evaluated using an axis passing through the center of mass of both tops. Finally, the reduced moment ofinertia is evaluated from the moment of inertia of each top via the formula

1

I(2,3)=

1

I1+

1

I2

getMomentOfInertiaTensor()Calculate and return the moment of inertia tensor for the current geometry in kg*m^2. If the coordinatesare not at the center of mass, they are temporarily shifted there for the purposes of this calculation.

getPrincipalMomentsOfInertia()Calculate and return the principal moments of inertia and corresponding principal axes for the currentgeometry. The moments of inertia are in kg*m^2, while the principal axes have unit length.

getTotalMass(atoms=None)Calculate and return the total mass of the atoms in the geometry in kg/mol. If a list atoms of atoms isspecified, only those atoms will be used to calculate the center of mass. Otherwise, all atoms will be used.

CanTherm input files

rmgpy.cantherm.input.loadInputFile(path)Load the CanTherm input file located at path on disk, and return a list of the jobs defined in that file.

1 Pitzer, K. S. J. Chem. Phys. 14, p. 239-243 (1946).2 East, A. L. L. and Radom, L. J. Chem. Phys. 106, p. 6655-6674 (1997).

1.1. CanTherm (rmgpy.cantherm) 5


rmgpy.cantherm.KineticsJob

class rmgpy.cantherm.KineticsJob(reaction, Tmin=None, Tmax=None, Tlist=None, Tcount=0)A representation of a CanTherm kinetics job. This job is used to compute and save the high-pressure-limitkinetics information for a single reaction.

TlistThe temperatures at which the k(T) values are computed.

TmaxThe maximum temperature at which the computed k(T) values are valid, or None if not defined.

TminThe minimum temperature at which the computed k(T) values are valid, or None if not defined.

execute(outputFile=None, plot=False)Execute the kinetics job, saving the results to the given outputFile on disk.

generateKinetics(Tlist=None)Generate the kinetics data for the reaction and fit it to a modified Arrhenius model.

plot(outputDirectory)Plot both the raw kinetics data and the Arrhenius fit versus temperature. The plot is saved to the filekinetics.pdf in the output directory. The plot is not generated if matplotlib is not installed.

save(outputFile)Save the results of the kinetics job to the file located at path on disk.

rmgpy.cantherm.CanTherm

class rmgpy.cantherm.CanTherm(inputFile=None, outputDirectory=None, verbose=20)The CanTherm class represents an instance of CanTherm, a tool for computing properties of chemical speciesand reactions. The attributes are:

Attribute DescriptionjobList A list of the jobs to executeinputFile The path of the input file defining the jobs to executeoutputDirectory The directory in which to write the output filesverbose The level of detail in the generated logging messages

The output directory defaults to the same directory as the input file if not explicitly specified.

To use this class programmatically, create an instance and set its attributes using either the __init__()method or by directly accessing the attributes, and then invoke the execute() method. You can also popu-late the attributes from the command line using the parseCommandLineArguments() method before runningexecute().

execute()Execute, in order, the jobs found in input file specified by the inputFile attribute.

initializeLog(verbose=20, logFile=None)Set up a logger for CanTherm to use to print output to stdout. The verbose parameter is an integer speci-fying the amount of log text seen at the console; the levels correspond to those of the logging module.

loadInputFile(inputFile)Load a set of jobs from the given inputFile on disk. Returns the loaded set of jobs as a list.

logFooter(level=20)Output a footer to the log.



logHeader(level=20)Output a header containing identifying information about CanTherm to the log.

parseCommandLineArguments()Parse the command-line arguments being passed to CanTherm. This uses the argparse module, whichensures that the command-line arguments are sensible, parses them, and returns them.

Saving CanTherm output

rmgpy.cantherm.output.prettify(string, indent=4)Return a “pretty” version of the given string, representing a snippet of Python code such as a representation ofan object or function. This involves splitting of tuples, lists, and dicts (including parameter lists) onto multiplelines, indenting as appropriate for readability.

class rmgpy.cantherm.output.PrettifyVisitor(level=0, indent=4)A class for traversing an abstract syntax tree to assemble a prettier version of the code used to create the tree.Used by the prettify() function.

generic_visit(node)Called if no explicit visitor function exists for a node.

visit(node)Visit a node.

visit_Call(node)Return a pretty representation of the class or function call represented by node.

visit_Dict(node)Return a pretty representation of the dict represented by node.

visit_List(node)Return a pretty representation of the list represented by node.

visit_Num(node)Return a pretty representation of the number represented by node.

visit_Str(node)Return a pretty representation of the string represented by node.

visit_Tuple(node)Return a pretty representation of the tuple represented by node.

rmgpy.cantherm.PressureDependenceJob

class rmgpy.cantherm.PressureDependenceJob(network, Tmin=None, Tmax=None, Tcount=0,Tlist=None, Pmin=None, Pmax=None, Pcount=0,Plist=None, maximumGrainSize=None, mini-mumGrainCount=0, method=None, interpolation-Model=None, maximumAtoms=None, activeKRo-tor=True, activeJRotor=True, rmgmode=False)

A representation of a pressure dependence job. The attributes are:



Attribute DescriptionTmin The minimum temperature at which to compute k(T, P ) valuesTmax The maximum temperature at which to compute k(T, P ) valuesTcount The number of temperatures at which to compute k(T, P ) valuesPmin The minimum pressure at which to compute k(T, P ) valuesPmax The maximum pressure at which to compute k(T, P ) valuesPcount The number of pressures at which to compute k(T, P ) valuesEmin The minimum energy to use to compute k(T, P ) valuesEmax The maximum energy to use to compute k(T, P ) valuesmaximumGrainSize The maximum energy grain size to use to compute k(T, P ) valuesminimumGrainCount The minimum number of energy grains to use to compute k(T, P ) valuesmethod The method to use to reduce the master equation to k(T, P ) valuesinterpolationModel The interpolation model to fit to the computed k(T, P ) valuesmaximumAtoms The maximum number of atoms to apply pressure dependence to (in RMG jobs)activeKRotor A flag indicating whether to treat the K-rotor as active or adiabaticactiveJRotor A flag indicating whether to treat the J-rotor as active or adiabaticrmgmode A flag that toggles “RMG mode”, described belownetwork The unimolecular reaction networkTlist An array of temperatures at which to compute k(T, P ) valuesPlist An array of pressures at which to compute k(T, P ) valuesElist An array of energies to use to compute k(T, P ) values

In RMG mode, several alterations to the k(T,P) algorithm are made both for speed and due to the nature of theapproximations used:

•Densities of states are not computed for product channels

•Arbitrary rigid rotor moments of inertia are included in the active modes; these cancel in the ILT andequilibrium expressions

•k(E) for each path reaction is computed in the direction A -> products, where A is always an exploredisomer; the high-P kinetics are reversed if necessary for this purpose

•Thermodynamic parameters are always used to compute the reverse k(E) from the forward k(E) for eachpath reaction

RMG mode should be turned off by default except in RMG jobs.

PlistThe pressures at which the k(T,P) values are computed.

PmaxThe maximum pressure at which the computed k(T,P) values are valid, or None if not defined.

PminThe minimum pressure at which the computed k(T,P) values are valid, or None if not defined.

TlistThe temperatures at which the k(T,P) values are computed.

TmaxThe maximum temperature at which the computed k(T,P) values are valid, or None if not defined.

TminThe minimum temperature at which the computed k(T,P) values are valid, or None if not defined.

copy()Return a copy of the pressure dependence job.



draw(outputDirectory, format=’pdf’)Generate a PDF drawing of the pressure-dependent reaction network. This requires that Cairo and itsPython wrapper be available; if not, the drawing is not generated.

You may also generate different formats of drawings, by changing format to one of the following: pdf, svg,png.

generatePressureList()Returns an array of pressures based on the interpolation model, minimum and maximum pressures Pminand Pmax in Pa, and the number of pressures Pcount. For Chebyshev polynomials a Gauss-Chebyshevdistribution is used; for all others a linear distribution on an logarithmic pressure domain is used. Notethat the Gauss-Chebyshev grid does not place Pmin and Pmax at the endpoints, yet the interpolation is stillvalid up to these values.

generateTemperatureList()Returns an array of temperatures based on the interpolation model, minimum and maximum temperaturesTmin and Tmax in K, and the number of temperatures Tcount. For Chebyshev polynomials a Gauss-Chebyshev distribution is used; for all others a linear distribution on an inverse temperature domain is used.Note that the Gauss-Chebyshev grid does not place Tmin and Tmax at the endpoints, yet the interpolationis still valid up to these values.

maximumGrainSizeThe maximum allowed energy grain size, or None if not defined.

saveInputFile(path)Save a CanTherm input file for the pressure dependence job to path on disk.

rmgpy.cantherm.StatMechJob

class rmgpy.cantherm.StatMechJob(species, path)A representation of a CanTherm statistical mechanics job. This job is used to compute and save the statisticalmechanics information for a single species or transition state.

execute(outputFile=None, plot=False)Execute the statistical mechanics job, saving the results to the given outputFile on disk.

load()Load the statistical mechanics parameters for each conformer from the associated files on disk. CreatesConformer objects for each conformer and appends them to the list of confomers on the species object.

plotHinderedRotor(angle, Vlist, cosineRotor, fourierRotor, rotor, rotorIndex, directory)Plot the potential for the rotor, along with its cosine and Fourier series potential fits. The plot is saved to aset of files of the form hindered_rotor_1.pdf.

save(outputFile)Save the results of the statistical mechanics job to the file located at path on disk.

rmgpy.cantherm.ThermoJob

class rmgpy.cantherm.ThermoJob(species, thermoClass)A representation of a CanTherm thermodynamics job. This job is used to compute and save the thermodynamicsinformation for a single species.

execute(outputFile=None, plot=False)Execute the thermodynamics job, saving the results to the given outputFile on disk.



generateThermo()Generate the thermodynamic data for the species and fit it to the desired heat capacity model (as specifiedin the thermoClass attribute).

plot(outputDirectory)Plot the heat capacity, enthapy, entropy, and Gibbs free energy of the fitted thermodynamics model, alongwith the same values from the statistical mechanics model that the thermodynamics model was fitted to.The plot is saved to the file thermo.pdf in the output directory. The plot is not generated if matplotlibis not installed.

save(outputFile)Save the results of the thermodynamics job to the file located at path on disk.

1.2 Chemkin files (rmgpy.chemkin)

The rmgpy.chemkin module contains functions for reading and writing of Chemkin and Chemkin-like files.

1.2.1 Reading Chemkin files

Function DescriptionloadChemkinFile() Load a reaction mechanism from a Chemkin fileloadSpeciesDictionary() Load a species dictionary from a fileloadTransportFile() Load a Chemkin transport properties filereadKineticsEntry() Read a single reaction entry from a Chemkin filereadReactionComments() Read the comments associated with a reaction entryreadReactionsBlock() Read the reactions block of a Chemkin filereadThermoEntry() Read a single thermodynamics entry from a Chemkin fileremoveCommentFromLine() Remove comment text from a line of a Chemkin file or species dictionary

1.2.2 Writing Chemkin files

Function DescriptionsaveChemkinFile() Save a reaction mechanism to a Chemkin filesaveSpeciesDictionary() Save a species dictionary to a filesaveTransportFile() Save a Chemkin transport properties filesaveHTMLFile() Save an HTML file representing a Chemkin mechanismsaveJavaKineticsLibrary() Save a mechanism to a (Chemkin-like) kinetics library for RMG-JavagetSpeciesIdentifier() Return the Chemkin-valid identifier for a given speciesmarkDuplicateReactions() Find and mark all duplicate reactions in a mechanismwriteKineticsEntry() Write a single reaction entry to a Chemkin filewriteThermoEntry() Write a single thermodynamics entry to a Chemkin file

1.2.3 Exceptions

Exception DescriptionChemkinError Raised when an error occurs while working with a Chemkin file



Reading Chemkin files

Main functions

rmgpy.chemkin.loadChemkinFile(path, dictionaryPath=None, transportPath=None, readCom-ments=True, thermoPath=None, useChemkinNames=False)

Load a Chemkin input file located at path on disk to path, returning lists of the species and reactions in theChemkin file. The ‘thermoPath’ point to a separate thermo file, or, if ‘None’ is specified, the function will lookfor the thermo database within the chemkin mechanism file

rmgpy.chemkin.loadSpeciesDictionary(path)Load an RMG dictionary - containing species identifiers and the associated adjacency lists - from the file locatedat path on disk. Returns a dict mapping the species identifiers to the loaded species. Resonance isomers for eachspecies are automatically generated.

rmgpy.chemkin.loadTransportFile(path, speciesDict)Load a Chemkin transport properties file located at path and store the properties on the species in speciesDict.

Helper functions

rmgpy.chemkin.readKineticsEntry(entry, speciesDict, Aunits, Eunits)Read a kinetics entry for a single reaction as loaded from a Chemkin file. The associated mapping of labels tospecies speciesDict should also be provided. Returns a Reaction object with the reaction and its associatedkinetics.

rmgpy.chemkin.readReactionComments(reaction, comments, read=True)Parse the comments associated with a given reaction. If the comments come from RMG (Py or Java), parsethem and extract the useful information. Return the reaction object based on the information parsed from thesecomments. If read if False, the reaction is returned as an “Unclassified” LibraryReaction.

rmgpy.chemkin.readReactionsBlock(f, speciesDict, readComments=True)Read a reactions block from a Chemkin file stream.

This function can also read the reactions.txt and pdepreactions.txt files from RMG-Java kineticslibraries, which have a similar syntax.

rmgpy.chemkin.readThermoEntry(entry, Tmin=0, Tint=0, Tmax=0)Read a thermodynamics entry for one species in a Chemkin file. Returns the label of the species and thethermodynamics model as a NASA object.

Format specification at http://www2.galcit.caltech.edu/EDL/public/formats/chemkin.html

rmgpy.chemkin.removeCommentFromLine(line)Remove a comment from a line of a Chemkin file or species dictionary file.

Returns the line and the comment. If the comment is encoded with latin-1, it is converted to utf-8.

Writing Chemkin files

Main functions

rmgpy.chemkin.saveChemkinFile(path, species, reactions, verbose=True, checkForDuplicates=True)Save a Chemkin input file to path on disk containing the provided lists of species and reactions. If checkForDu-plicates is False then we don’t check for unlabeled duplicate reactions, thus saving time (eg. if you are sureyou’ve already labeled them as duplicate).

1.2. Chemkin files (rmgpy.chemkin) 11

http://www2.galcit.caltech.edu/EDL/public/formats/chemkin.html


rmgpy.chemkin.saveSpeciesDictionary(path, species, oldStyle=False)Save the given list of species as adjacency lists in a text file path on disk.

If oldStyle==True then it saves it in the old RMG-Java syntax.

rmgpy.chemkin.saveTransportFile(path, species)Save a Chemkin transport properties file to path on disk containing the transport properties of the given list ofspecies.

The syntax is from the Chemkin TRANSPORT manual. The first 16 columns in each line of the database arereserved for the species name (Presently CHEMKIN is programmed to allow no more than 16-character names.)Columns 17 through 80 are free-format, and they contain the molecular parameters for each species. They are,in order:

1.An index indicating whether the molecule has a monatomic, linear or nonlinear geometrical configuration.If the index is 0, the molecule is a single atom. If the index is 1 the molecule is linear, and if it is 2, themolecule is nonlinear.

2.The Lennard-Jones potential well depth ε/kB in Kelvins.

3.The Lennard-Jones collision diameter σ in Angstroms.

4.The dipole moment µ in Debye. Note: a Debye is 10−18cm3/2erg1/2.

5.The polarizability α in cubic Angstroms.

6.The rotational relaxation collision number Zrot at 298K.

7.After the last number, a comment field can be enclosed in parenthesis.

rmgpy.chemkin.saveHTMLFile(path, readComments=True)Save an output HTML file from the contents of a RMG-Java output folder

rmgpy.chemkin.saveJavaKineticsLibrary(path, species, reactions)Save the reaction files for a RMG-Java kinetics library: pdepreactions.txt and reactions.txt given a list of reac-tions, with species.txt containing the RMG-Java formatted dictionary.

Helper functions

rmgpy.chemkin.getSpeciesIdentifier(species)Return a string identifier for the provided species that can be used in a Chemkin file. Although the Chemkinformat allows up to 16 characters for a species identifier, this function uses a maximum of 10 to ensure that allreaction equations fit in the maximum limit of 52 characters.

rmgpy.chemkin.writeKineticsEntry(reaction, speciesList, verbose=True, javaLibrary=False)Return a string representation of the reaction as used in a Chemkin file. Use verbose = True to turn on comments.Use javaLibrary = True in order to generate a kinetics entry suitable for an RMG-Java kinetics library.

rmgpy.chemkin.writeThermoEntry(species, verbose=True)Return a string representation of the NASA model readable by Chemkin. To use this method you must haveexactly two NASA polynomials in your model, and you must use the seven-coefficient forms for each.

rmgpy.chemkin.markDuplicateReactions(reactions)For a given list of reactions, mark all of the duplicate reactions as understood by Chemkin.

This is pretty slow (quadratic in size of reactions list) so only call it if you’re really worried you may haveundetected duplicate reactions.



1.3 Physical constants (rmgpy.constants)

The rmgpy.constants module contains module-level variables defining relevant physical constants relevant inchemistry applications. The recommended method of importing this module is

import rmgpy.constants as constants

so as to not place the constants in the importing module’s global namespace.

The constants defined in this module are listed in the table below:

Table 1.1: Physical constants defined in the rmgpy.constants module

Symbol Constant Value DescriptionEh E_h 4.35974434× 10−18 J Hartree energyF F 96485.3365 C/mol Faraday constantG G 6.67384× 10−11 m3/kg · s2 Newtonian gravitational constantNA Na 6.02214179× 1023 mol−1 Avogadro constantR R 8.314472 J/mol ·K gas law constanta0 a0 5.2917721092× 10−11 m Bohr radiusc c 299792458 m/s speed of light in a vacuume e 1.602176565× 10−19 C elementary chargeg g 9.80665 m/s2 standard acceleration due to gravityh h 6.62606896× 10−34 J · s Planck constant~ hbar 1.054571726× 10−34 J · s reduced Planck constantkB kB 1.3806504× 10−23 J/K Boltzmann constantme m_e 9.10938291× 10−31 kg electron rest massmn m_n 1.674927351× 10−27 kg neutron rest massmp m_p 1.672621777× 10−27 kg proton rest massmu amu 1.660538921× 10−27 kg atomic mass unitπ pi 3.14159 . . .

1.4 Database (rmgpy.data)

1.4.1 General classes

Class/Function DescriptionEntry An entry in a databaseDatabase A database of entriesLogicNode A node in a database that represents a logical collection of entriesLogicAnd A logical collection of entries, where all entries in the collection must matchLogicOr A logical collection of entries, where any entry in the collection can matchmakeLogicNode() Create a LogicNode based on a string representation

1.3. Physical constants (rmgpy.constants) 13


1.4.2 Thermodynamics database

Class DescriptionThermoDepository A depository of all thermodynamics parameters for one or more speciesThermoLibrary A library of curated thermodynamics parameters for one or more speciesThermoGroups A representation of a portion of a database for implementing the Benson group additivity

methodThermoDatabase An entire thermodynamics database, including depositories, libraries, and groups

1.4.3 Kinetics database

Class DescriptionDepositoryReaction A reaction with kinetics determined from querying a kinetics depositoryLibraryReaction A reaction with kinetics determined from querying a kinetics libraryTemplateReaction A reaction with kinetics determined from querying a kinetics group additivity or rate

rules methodReactionRecipe A sequence of actions that represent the process of a chemical reactionKineticsDepository A depository of all kinetics parameters for one or more reactionsKineticsLibrary A library of curated kinetics parameters for one or more reactionsKineticsGroups A set of group additivity values for a reaction family, organized in a treeKineticsRules A set of rate rules for a reaction familyKineticsFamily A kinetics database for one reaction family, including depositories, libraries, groups, and

rulesKineticsDatabase A kinetics database for all reaction families, including depositories, libraries, groups, and

rules

1.4.4 Statistical mechanics database

Class DescriptionGroupFrequencies A set of characteristic frequencies for a group in the frequency databaseStatmechDepository A depository of all statistical mechanics parameters for one or more speciesStatmechLibrary A library of curated statistical mechanics parameters for one or more speciesStatmechGroups A set of characteristic frequencies for various functional groups, organized in a treeStatmechDatabase An entire statistical mechanics database, including depositories, libraries, and groups

1.4.5 Statistical mechanics fitting

Class/Function DescriptionDirectFit DQED class for fitting a small number of vibrational frequencies and hindered rotorsPseudoFit DQED class for fitting a large number of vibrational frequencies and hindered rotors by

assuming degeneracies for bothPseudoRotorFit DQED class for fitting a moderate number of vibrational frequencies and hindered

rotors by assuming degeneracies for hindered rotors onlyfitStatmechDirect()Directly fit a small number of vibrational frequencies and hindered rotorsfitStatmechPseudo() Fit a large number of vibrational frequencies and hindered rotors by assuming

degeneracies for bothfitStatmechPseudoRotors()Fit a moderate number of vibrational frequencies and hindered rotors by assuming

degeneracies for hindered rotors onlyfitStatmechToHeatCapacity()Fit vibrational and torsional degrees of freedom to heat capacity data



1.4.6 Exceptions

Exception DescriptionDatabaseError Raised when an error occurs while working with the databaseInvalidActionError Raised when an error occurs while applying a reaction recipeUndeterminableKineticsErrorRaised when the kinetics of a given reaction cannot be determinedStatmechFitError Raised when an error occurs while fitting internal degrees of freedom to heat

capacity data

rmgpy.data.base.Database

class rmgpy.data.base.Database(entries=None, top=None, label=’‘, name=’‘, solvent=None, short-Desc=’‘, longDesc=’‘)

An RMG-style database, consisting of a dictionary of entries (associating items with data), and an optional treefor assigning a hierarchy to the entries. The use of the tree enables the database to be easily extensible as moreparameters are available.

In constructing the tree, it is important to develop a hierarchy such that siblings are mutually exclusive, toensure that there is a unique path of descent down a tree for each structure. If non-mutually exclusive siblingsare encountered, a warning is raised and the parent of the siblings is returned.

There is no requirement that the children of a node span the range of more specific permutations of the parent.As the database gets more complex, attempting to maintain complete sets of children for each parent in eachdatabase rapidly becomes untenable, and is against the spirit of extensibility behind the database development.

You must derive from this class and implement the loadEntry(), saveEntry(),processOldLibraryEntry(), and generateOldLibraryEntry() methods in order to load andsave from the new and old database formats.

ancestors(node)Returns all the ancestors of a node, climbing up the tree to the top.

areSiblings(node, nodeOther)Return True if node and nodeOther have the same parent node. Otherwise, return False. Both node andnodeOther must be Entry types with items containing Group or LogicNode types.

descendTree(structure, atoms, root=None, strict=False)Descend the tree in search of the functional group node that best matches the local structure around atomsin structure.

If root=None then uses the first matching top node.

Returns None if there is no matching root.

Set strict to True if all labels in final matched node must match that of the structure. This is used inkinetics groups to find the correct reaction template, but not generally used in other GAVs due to speciesgenerally not being prelabeled.

descendants(node)Returns all the descendants of a node, climbing down the tree to the bottom.

generateOldTree(entries, level)Generate a multi-line string representation of the current tree using the old-style syntax.

getEntriesToSave()Return a sorted list of the entries in this database that should be saved to the output file.

getSpecies(path)Load the dictionary containing all of the species in a kinetics library or depository.

1.4. Database (rmgpy.data) 15


load(path, local_context=None, global_context=None)Load an RMG-style database from the file at location path on disk. The parameters local_context andglobal_context are used to provide specialized mapping of identifiers in the input file to correspondingfunctions to evaluate. This method will automatically add a few identifiers required by all data entries, soyou don’t need to provide these.

loadOld(dictstr, treestr, libstr, numParameters, numLabels=1, pattern=True)Load a dictionary-tree-library based database. The database is stored in three files: dictstr is the path tothe dictionary, treestr to the tree, and libstr to the library. The tree is optional, and should be set to ‘’ if notdesired.

loadOldDictionary(path, pattern)Parse an old-style RMG database dictionary located at path. An RMG dictionary is a list of key-valuepairs of a one-line string key and a multi-line string value. Each record is separated by at least one emptyline. Returns a dict object with the values converted to Molecule or Group objects depending on thevalue of pattern.

loadOldLibrary(path, numParameters, numLabels=1)Parse an RMG database library located at path.

loadOldTree(path)Parse an old-style RMG database tree located at path. An RMG tree is an n-ary tree representing thehierarchy of items in the dictionary.

matchNodeToChild(parentNode, childNode)Return True if parentNode is a parent of childNode. Otherwise, return False. Both parentNode andchildNode must be Entry types with items containing Group or LogicNode types. If parentNode andchildNode are identical, the function will also return False.

matchNodeToNode(node, nodeOther)Return True if node and nodeOther are identical. Otherwise, return False. Both node and nodeOther mustbe Entry types with items containing Group or LogicNode types.

matchNodeToStructure(node, structure, atoms, strict=False)Return True if the structure centered at atom matches the structure at node in the dictionary. The structureat node should have atoms with the appropriate labels because they are set on loading and never change.However, the atoms in structure may not have the correct labels, hence the atoms parameter. The atomsparameter may include extra labels, and so we only require that every labeled atom in the functional grouprepresented by node has an equivalent labeled atom in structure.

Matching to structure is more strict than to node. All labels in structure must be found in node. Howeverthe reverse is not true, unless strict is set to True.

At-tribute

Description

node Either an Entry or a key in the self.entries dictionary which has a Group or LogicNode asits Entry.item

struc-ture

A Group or a Molecule

atoms Dictionary of {label: atom} in the structure. A possible dictionary is the one produced bystructure.getLabeledAtoms()

strict If set to True, ensures that all the node’s atomLabels are matched by in the structure

parseOldLibrary(path, numParameters, numLabels=1)Parse an RMG database library located at path, returning the loaded entries (rather than storing them inthe database). This method does not discard duplicate entries.

removeGroup(groupToRemove)Removes a group that is in a tree from the database. In addition to deleting from self.entries, it must also



update the parent/child relationships

Returns the removed group

save(path)Save the current database to the file at location path on disk.

saveDictionary(path)Extract species from all entries associated with a kinetics library or depository and save them to the pathgiven.

saveOld(dictstr, treestr, libstr)Save the current database to a set of text files using the old-style syntax.

saveOldDictionary(path)Save the current database dictionary to a text file using the old-style syntax.

saveOldLibrary(path)Save the current database library to a text file using the old-style syntax.

saveOldTree(path)Save the current database tree to a text file using the old-style syntax.

rmgpy.data.kinetics.DepositoryReaction

class rmgpy.data.kinetics.DepositoryReaction(index=-1, reactants=None, products=None, kinet-ics=None, reversible=True, transitionState=None,duplicate=False, degeneracy=1, pairs=None, de-pository=None, family=None, entry=None)

A Reaction object generated from a reaction depository. In addition to the usual attributes, this class includesdepository and entry attributes to store the library and the entry in that depository that it was created from.

calculateMicrocanonicalRateCoefficient()Calculate the microcanonical rate coefficient k(E) for the reaction reaction at the energies Elist in J/mol.reacDensStates and prodDensStates are the densities of states of the reactant and product configurationsfor this reaction. If the reaction is irreversible, only the reactant density of states is required; if the reactionis reversible, then both are required. This function will try to use the best method that it can based on theinput data available:

•If detailed information has been provided for the transition state (i.e. the molecular degrees of free-dom), then RRKM theory will be used.

•If the above is not possible but high-pressure limit kinetics k∞(T ) have been provided, then theinverse Laplace transform method will be used.

The density of states for the product prodDensStates and the temperature of interest T in K can alsobe provided. For isomerization and association reactions prodDensStates is required; for dissociationreactions it is optional. The temperature is used if provided in the detailed balance expression to determinethe reverse kinetics, and in certain cases in the inverse Laplace transform method.

calculateTSTRateCoefficient()Evaluate the forward rate coefficient for the reaction with corresponding transition state TS at temperatureT in K using (canonical) transition state theory. The TST equation is

k(T ) = κ(T )kBT

h

Q‡(T )

QA(T )QB(T )exp

(− E0

kBT

)where Q‡ is the partition function of the transition state, QA and QB are the partition function of thereactants, E0 is the ground-state energy difference from the transition state to the reactants, T is the



absolute temperature, kB is the Boltzmann constant, and h is the Planck constant. κ(T ) is an optionaltunneling correction.

canTST()Return True if the necessary parameters are available for using transition state theory – or the microcanon-ical equivalent, RRKM theory – to compute the rate coefficient for this reaction, or False otherwise.

copy()Create a deep copy of the current reaction.

draw()Generate a pictorial representation of the chemical reaction using the draw module. Use path to specifythe file to save the generated image to; the image type is automatically determined by extension. Validextensions are .png, .svg, .pdf, and .ps; of these, the first is a raster format and the remainder arevector formats.

fixBarrierHeight()Turns the kinetics into Arrhenius (if they were ArrheniusEP) and ensures the activation energy is at leastthe endothermicity for endothermic reactions, and is not negative only as a result of using Evans Polanyiwith an exothermic reaction. If forcePositive is True, then all reactions are forced to have a non-negativebarrier.

fixDiffusionLimitedA()Decrease the pre-exponential factor (A) by the diffusion factor to account for the diffusion limit at thespecified temperature.

generate3dTS()Generate the 3D structure of the transition state. Called from model.generateKinetics().

self.reactants is a list of reactants self.products is a list of products

generatePairs()Generate the reactant-product pairs to use for this reaction when performing flux analysis. The exactprocedure for doing so depends on the reaction type:

Reaction type Template Resulting pairsIsomerization A -> C (A,C)Dissociation A -> C + D (A,C), (A,D)Association A + B -> C (A,C), (B,C)Bimolecular A + B -> C + D (A,C), (B,D) or (A,D), (B,C)

There are a number of ways of determining the correct pairing for bimolecular reactions. Here we try asimple similarity analysis by comparing the number of heavy atoms (carbons and oxygens at the moment).This should work most of the time, but a more rigorous algorithm may be needed for some cases.

generateReverseRateCoefficient()Generate and return a rate coefficient model for the reverse reaction. Currently this only works if thekinetics attribute is one of several (but not necessarily all) kinetics types.

getEnthalpiesOfReaction()Return the enthalpies of reaction in J/mol evaluated at temperatures Tlist in K.

getEnthalpyOfReaction()Return the enthalpy of reaction in J/mol evaluated at temperature T in K.

getEntropiesOfReaction()Return the entropies of reaction in J/mol*K evaluated at temperatures Tlist in K.

getEntropyOfReaction()Return the entropy of reaction in J/mol*K evaluated at temperature T in K.



getEquilibriumConstant()Return the equilibrium constant for the reaction at the specified temperature T in K. The type parameterlets you specify the quantities used in the equilibrium constant: Ka for activities, Kc for concentrations(default), or Kp for pressures. Note that this function currently assumes an ideal gas mixture.

getEquilibriumConstants()Return the equilibrium constants for the reaction at the specified temperatures Tlist in K. The type parame-ter lets you specify the quantities used in the equilibrium constant: Ka for activities, Kc for concentrations(default), or Kp for pressures. Note that this function currently assumes an ideal gas mixture.

getFreeEnergiesOfReaction()Return the Gibbs free energies of reaction in J/mol evaluated at temperatures Tlist in K.

getFreeEnergyOfReaction()Return the Gibbs free energy of reaction in J/mol evaluated at temperature T in K.

getRateCoefficient()Return the overall rate coefficient for the forward reaction at temperature T in K and pressure P in Pa,including any reaction path degeneracies.

If diffusionLimiter is enabled, the reaction is in the liquid phase and we use a diffusion limitation to correctthe rate. If not, then use the intrinsic rate coefficient.

getSource()Return the database that was the source of this reaction. For a DepositoryReaction this should be a Kinet-icsDepository object.

getStoichiometricCoefficient()Return the stoichiometric coefficient of species spec in the reaction. The stoichiometric coefficient isincreased by one for each time spec appears as a product and decreased by one for each time spec appearsas a reactant.

getURL()Get a URL to search for this reaction in the rmg website.

hasTemplate()Return True if the reaction matches the template of reactants and products, which are both lists ofSpecies objects, or False if not.

isAssociation()Return True if the reaction represents an association reaction A + B −−⇀↽−− C or False if not.

isBalanced()Return True if the reaction has the same number of each atom on each side of the reaction equation, orFalse if not.

isDissociation()Return True if the reaction represents a dissociation reaction A −−⇀↽−− B + C or False if not.

isIsomerization()Return True if the reaction represents an isomerization reaction A −−⇀↽−− B or False if not.

isIsomorphic()Return True if this reaction is the same as the other reaction, or False if they are different. If eitherDi-rection=False then the directions must match.

isUnimolecular()Return True if the reaction has a single molecule as either reactant or product (or both) A −−⇀↽−− B + C orA + B −−⇀↽−− C or A −−⇀↽−− B, or False if not.



matchesMolecules()Return True if the given reactants represent the total set of reactants or products for the currentreaction, or False if not. The reactants should be Molecule objects.

reverseThisArrheniusRate()Reverses the given kForward, which must be an Arrhenius type. You must supply the correct units for thereverse rate. The equilibrium constant is evaluated from the current reaction instance (self).

toCantera()Converts the RMG Reaction object to a Cantera Reaction object with the appropriate reaction class.

toChemkin()Return the chemkin-formatted string for this reaction.

If kinetics is set to True, the chemkin format kinetics will also be returned (requires the speciesList tofigure out third body colliders.) Otherwise, only the reaction string will be returned.

rmgpy.data.base.Entry

class rmgpy.data.base.Entry(index=-1, label=’‘, item=None, parent=None, children=None, data=None,reference=None, referenceType=’‘, shortDesc=’‘, longDesc=’‘,rank=None)

A class for representing individual records in an RMG database. Each entry in the database associates a chemicalitem (generally a species, functional group, or reaction) with a piece of data corresponding to that item. Asignificant amount of metadata can also be stored with each entry.

The attributes are:

Attribute Descriptionindex A unique nonnegative integer index for the entrylabel A unique string identifier for the entry (or ‘’ if not used)item The item that this entry representsparent The parent of the entry in the hierarchy (or None if not used)children A list of the children of the entry in the hierarchy (or None if not used)data The data to associate with the itemreference A Reference object containing bibliographic reference information to the source of the

datareference-Type

The way the data was determined: ’theoretical’, ’experimental’, or ’review’

shortDesc A brief (one-line) description of the datalongDesc A long, verbose description of the datarank An integer indicating the degree of confidence in the entry data, or None if not used

rmgpy.data.statmech.GroupFrequencies

class rmgpy.data.statmech.GroupFrequencies(frequencies=None, symmetry=1)Represent a set of characteristic frequencies for a group in the frequency database. These frequencies are storedin the frequencies attribute, which is a list of tuples, where each tuple defines a lower bound, upper bound,and degeneracy. Each group also has a symmetry correction.

generateFrequencies(count=1)Generate a set of frequencies. For each characteristic frequency group, the number of frequencies returnedis degeneracy * count, and these are distributed linearly between the lower and upper bounds.



rmgpy.data.kinetics.KineticsDatabase

class rmgpy.data.kinetics.KineticsDatabaseA class for working with the RMG kinetics database.

extractSourceFromComments(reaction)

reaction: A reaction object containing kinetics data and kinetics data comments. Should beeither a PDepReaction, LibraryReaction, or TemplateReaction object as loaded from thermgpy.chemkin.loadChemkinFile function

Parses the verbose string of comments from the thermo data of the species object, and extracts the thermosources.

Returns a dictionary with keys of either ‘Rate Rules’, ‘Training’, ‘Library’, or ‘PDep’. A reaction can onlybe estimated using one of these methods.

source = {‘RateRules’: (Family_Label, OriginalTemplate, RateRules), ‘Library’:String_Name_of_Library_Used, ‘PDep’: Network_Index, ‘Training’: (Family_Label, Train-ing_Reaction_Entry), }

generateReactions(reactants, products=None)Generate all reactions between the provided list of one or two reactants, which should be Moleculeobjects. This method searches the depository, libraries, and groups, in that order.

generateReactionsFromFamilies(reactants, products, only_families=None)Generate all reactions between the provided list of one or two reactants, which should be Moleculeobjects. This method applies the reaction family. If only_families is a list of strings, only families withthose labels are used.

generateReactionsFromLibraries(reactants, products)Generate all reactions between the provided list of one or two reactants, which should be Moleculeobjects. This method searches the depository.

generateReactionsFromLibrary(reactants, products, library)Generate all reactions between the provided list of one or two reactants, which should be Moleculeobjects. This method searches the depository.

getForwardReactionForFamilyEntry(entry, family, thermoDatabase)For a given entry for a reaction of the given reaction family (the string label of the family), return thereaction with kinetics and degeneracy for the “forward” direction as defined by the reaction family. Forfamilies that are their own reverse, the direction the kinetics is given in will be preserved. If the entrycontains functional groups for the reactants, assume that it is given in the forward direction and do noth-ing. Returns the reaction in the direction consistent with the reaction family template, and the matchingtemplate. Note that the returned reaction will have its kinetics and degeneracy set appropriately.

In order to reverse the reactions that are given in the reverse of the direction the family is defined, weneed to compute the thermodynamics of the reactants and products. For this reason you must also pass thethermoDatabase to use to generate the thermo data.

load(path, families=None, libraries=None, depositories=None)Load the kinetics database from the given path on disk, where path points to the top-level folder of thefamilies database.

loadFamilies(path, families=None, depositories=None)Load the kinetics families from the given path on disk, where path points to the top-level folder of thekinetics families.

loadLibraries(path, libraries=None)Load the listed kinetics libraries from the given path on disk.



Loads them all if libraries list is not specified or None. The path points to the folder of kinetics librariesin the database, and the libraries should be in files like <path>/<library>.py.

loadOld(path)Load the old RMG kinetics database from the given path on disk, where path points to the top-level folderof the old RMG database.

loadRecommendedFamiliesList(filepath)Load the list of recommended families from the given file

The file is usually ‘kinetics/families/recommended.py’. This is stored as a dictionary of True or Falsevalues (checked here), and should contain entries for every available family (checked in loadFamilies).

reconstructKineticsFromSource(reaction, source, fixBarrierHeight=False, forcePositiveBar-rier=False)

Reaction is the original reaction with original kinetics. Note that for Library and PDep reactions thisfunction does not do anything other than return the original kinetics...

You must enter source data in the appropriate format such as returned from returned fromself.extractSourceFromComments, self-constructed. fixBarrierHeight and forcePositiveBarrier willchange the kinetics based on the Reaction.fixBarrierHeight function. Return Arrhenius form kinetics ifthe source is from training reaction or rate rules.

save(path)Save the kinetics database to the given path on disk, where path points to the top-level folder of the kineticsdatabase.

saveFamilies(path)Save the kinetics families to the given path on disk, where path points to the top-level folder of the kineticsfamilies.

saveLibraries(path)Save the kinetics libraries to the given path on disk, where path points to the top-level folder of the kineticslibraries.

saveOld(path)Save the old RMG kinetics database to the given path on disk, where path points to the top-level folder ofthe old RMG database.

saveRecommendedFamilies(path)Save the list of recommended families in a dictionary stored at path/recommended.py

rmgpy.data.kinetics.KineticsDepository

class rmgpy.data.kinetics.KineticsDepository(label=’‘, name=’‘, shortDesc=’‘, longDesc=’‘)A class for working with an RMG kinetics depository. Each depository corresponds to a reaction family (aKineticsFamily object). Each entry in a kinetics depository involves a reaction defined either by a realreactant and product species (as in a kinetics library).






At-tribute

Description


struc-ture





removeGroup(groupToRemove)Removes a group that is in a tree from the database. In addition to deleting from self.entries, it must alsoupdate the parent/child relationships




saveEntry(f, entry)Write the given entry in the kinetics database to the file object f.





rmgpy.data.kinetics.KineticsFamily

class rmgpy.data.kinetics.KineticsFamily(entries=None, top=None, label=’‘, name=’‘, reverse=’‘,shortDesc=’‘, longDesc=’‘, forwardTemplate=None,forwardRecipe=None, reverseTemplate=None, re-verseRecipe=None, forbidden=None)

A class for working with an RMG kinetics family: a set of reactions with similar chemistry, and therefore similarreaction rates. The attributes are:



Attribute Type Descriptionreverse string The name of the reverse reaction familyforwardTem-plate

Reaction The forward reaction template

for-wardRecipe

ReactionRecipe The steps to take when applying the forward reaction to a set ofreactants

reverseTem-plate

Reaction The reverse reaction template

reverseRecipe ReactionRecipe The steps to take when applying the reverse reaction to a set ofreactants

forbidden ForbiddenStructures(Optional) Forbidden product structures in either directionownReverse Boolean It’s its own reverse?groups KineticsGroups The set of kinetics group additivity valuesrules KineticsRules The set of kinetics rate rules from RMG-Javadepositories list A set of additional depositories used to store kinetics data from

various sources

There are a few reaction families that are their own reverse (hydrogen abstraction and intramolecular hydrogenmigration); for these reverseTemplate and reverseRecipe will both be None.

addAtomLabelsForReaction(reaction)Apply atom labels on a reaction using the appropriate atom labels from this this reaction family. Thereaction’s reactants and products must be lists of Molecule objects. The reaction is modified to use Speciesobjects containing the labeled molecules after this function.

addKineticsRulesFromTrainingSet(thermoDatabase=None)For each reaction involving real reactants and products in the training set, add a rate rule for that reaction.


applyRecipe(reactantStructures, forward=True, unique=True)Apply the recipe for this reaction family to the list of Molecule objects reactantStructures. The atomsof the reactant structures must already be tagged with the appropriate labels. Returns a list of structurescorresponding to the products after checking that the correct number of products was produced.


calculateDegeneracy(reaction)For a reaction given in the direction in which the kinetics are defined, compute the reaction-path degener-acy.








estimateKineticsUsingGroupAdditivity(template, degeneracy=1)Determine the appropriate kinetics for a reaction with the given template using group additivity.

estimateKineticsUsingRateRules(template, degeneracy=1)Determine the appropriate kinetics for a reaction with the given template using rate rules.

extractSourceFromComments(reaction)Returns the rate rule associated with the kinetics of a reaction by parsing the comments.Will return the template associated with the matched rate rule. Returns a tuple containing(Boolean_Is_Kinetics_From_Training_reaction, Source_Data)

For a training reaction, the Source_Data returns [Family_Label, Training_Reaction_Entry, Kinet-ics_In_Reverse?]

For a reaction from rate rules, the Source_Data is a tuple containing [Family_Label, {‘template’: original-Template,

Unexpected indentation.

‘degeneracy’: degeneracy, ‘exact’: boolean_exact?, ‘rules’: a list of (original rate rule entry,weight in average) ‘training’: a list of (original rate rule entry associated with training entry,original training entry, weight in average) }]

Block quote ends without a blank line; unexpected unindent.

where TrainingReactions are ones that have created rules used in the estimate.

where Exact is a boolean of whether the rate is an exact match, Template is the reaction template used, andRateRules is a list of the rate rule entries containing the kinetics used

fillKineticsRulesByAveragingUp(verbose=False)Fill in gaps in the kinetics rate rules by averaging child nodes recursively starting from the top level roottemplate.


generateProductTemplate(reactants0)Generate the product structures by applying the reaction template to the top-level nodes. For reactantsdefined by multiple structures, only the first is used here; it is assumed to be the most generic.

generateReactions(reactants)Generate all reactions between the provided list of one or two reactants, which should be either singleMolecule objects or lists of same. Does not estimate the kinetics of these reactions at this time. Returns alist of TemplateReaction objects using Molecule objects for both reactants and products The reactionsare constructed such that the forward direction is consistent with the template of this reaction family.


getKinetics(reaction, template, degeneracy=1, estimator=’‘, returnAllKinetics=True)Return the kinetics for the given reaction by searching the various depositories as well as generating aresult using the user-specified estimator of either ‘group additivity’ or ‘rate rules.’ Unlike the regulargetKinetics() method, this returns a list of results, with each result comprising the kinetics, the source,and the entry. If it came from a template estimate, the source and entry will both be None. If returnAllKi-netics==False, only the first (best?) matching kinetics is returned.

getKineticsForTemplate(template, degeneracy=1, method=’rate rules’)Return an estimate of the kinetics for a reaction with the given template and reaction-path degeneracy.There are two possible methods to use: ‘group additivity’ (new RMG-Py behavior) and ‘rate rules’ (oldRMG-Java behavior).



getKineticsFromDepository(depository, reaction, template, degeneracy)Search the given depository in this kinetics family for kinetics for the given reaction. Returns a list of allof the matching kinetics, the corresponding entries, and True if the kinetics match the forward directionor False if they match the reverse direction.

getLabeledReactantsAndProducts(reactants, products)Given reactants, a list of Molecule objects, and products, a list of Molecule objects, return two newlists of Molecule objects with atoms labeled: one for reactants, one for products. Returned moleculesare totally new entities in memory so input molecules reactants and products won’t be affected. If RMGcannot find appropriate labels, (None, None) will be returned.

getRateRule(template)Return the rate rule with the given template. Raises a ValueError if no corresponding entry exists.

getReactionPairs(reaction)For a given reaction with properly-labeled Molecule objects as the reactants, return the reactant-productpairs to use when performing flux analysis.

getReactionTemplate(reaction)For a given reaction with properly-labeled Molecule objects as the reactants, determine the most specificnodes in the tree that describe the reaction.

getReactionTemplateLabels(reaction)Retrieve the template for the reaction and return the corresponding labels for each of the groups in thetemplate.

getRootTemplate()Return the root template for the reaction family. Most of the time this is the top-level nodes of the tree (asstored in the KineticsGroups object), but there are a few exceptions (e.g. R_Recombination).

getSourcesForTemplate(template)Returns the set of rate rules and training reactions used to average this template. Note that the tree must beaveraged with verbose=True for this to work.

Returns a tuple of rules, training

where rules are a list of tuples containing the [(original_entry, weight_used_in_average), ... ]

and training is a list of tuples containing the [(rate_rule_entry, training_reaction_entry,weight_used_in_average),...]


getTrainingDepository()Returns the training depository from self.depositories

hasRateRule(template)Return True if a rate rule with the given template currently exists, or False otherwise.

isMoleculeForbidden(molecule)Return True if the molecule is forbidden in this family, or False otherwise.

load(path, local_context=None, global_context=None, depositoryLabels=None)Load a kinetics database from a file located at path on disk.

If depositoryLabels is a list, eg. [’training’,’PrIMe’], then only those depositories are loaded, and they aresearched in that order when generating kinetics.

If depositoryLabels is None then load ‘training’ first then everything else. If depositoryLabels is not Nonethen load in the order specified in depositoryLabels.



loadForbidden(label, group, shortDesc=’‘, longDesc=’‘)Load information about a forbidden structure.

loadOld(path)Load an old-style RMG kinetics group additivity database from the location path.



loadOldTemplate(path)Load an old-style RMG reaction family template from the location path.


loadRecipe(actions)Load information about the reaction recipe.

loadTemplate(reactants, products, ownReverse=False)Load information about the reaction template.





At-tribute

Description


struc-ture









retrieveOriginalEntry(templateLabel)Retrieves the original entry, be it a rule or training reaction, given the template label in the form‘group1;group2’ or ‘group1;group2;group3’

Returns tuple in the form (RateRuleEntry, TrainingReactionEntry)

Where the TrainingReactionEntry is only present if it comes from a training reaction

retrieveTemplate(templateLabels)Reconstruct the groups associated with the labels of the reaction template and return a list.


saveDepository(depository, path)Save the given kinetics family depository to the location path on disk.


saveEntry(f, entry)Write the given entry in the thermo database to the file object f.

saveGroups(path)Save the current database to the file at location path on disk.

saveOld(path)Save the old RMG kinetics groups to the given path on disk.



saveOldTemplate(path)Save an old-style RMG reaction family template from the location path.


saveTrainingReactions(reactions, reference=None, referenceType=’‘, shortDesc=’‘, rank=3)This function takes a list of reactions appends it to the training reactions file. It ignores the existence ofduplicate reactions.

The rank for each new reaction’s kinetics is set to a default value of 3 unless the user specifies differentlyfor those reactions.

For each entry, the long description is imported from the kinetics comment.



rmgpy.data.kinetics.KineticsGroups

class rmgpy.data.kinetics.KineticsGroups(entries=None, top=None, label=’‘, name=’‘, short-Desc=’‘, longDesc=’‘, forwardTemplate=None,forwardRecipe=None, reverseTemplate=None, re-verseRecipe=None, forbidden=None)

A class for working with an RMG kinetics family group additivity values.








estimateKineticsUsingGroupAdditivity(template, referenceKinetics, degeneracy=1)Determine the appropriate kinetics for a reaction with the given template using group additivity.

generateGroupAdditivityValues(trainingSet, kunits, method=’Arrhenius’)Generate the group additivity values using the given trainingSet, a list of 2-tuples of the form (template,kinetics). You must also specify the kunits for the family and the method to use when generating thegroup values. Returns True if the group values have changed significantly since the last time they werefitted, or False otherwise.



getReactionTemplate(reaction)For a given reaction with properly-labeled Molecule objects as the reactants, determine the most specificnodes in the tree that describe the reaction.













At-tribute

Description


struc-ture















rmgpy.data.kinetics.KineticsLibrary

class rmgpy.data.kinetics.KineticsLibrary(label=’‘, name=’‘, solvent=None, shortDesc=’‘,longDesc=’‘)

A class for working with an RMG kinetics library.



checkForDuplicates(markDuplicates=False)Check that all duplicate reactions in the kinetics library are properly marked (i.e. with their duplicateattribute set to True). If markDuplicates is set to True, then ignore and mark all duplicate reactions asduplicate.

convertDuplicatesToMulti()Merge all marked duplicate reactions in the kinetics library into single reactions with multiple kinetics.









loadOld(path)Load an old-style RMG kinetics library from the location path.






markValidDuplicates(reactions1, reactions2)Check for reactions that appear in both lists, and mark them as (valid) duplicates.





At-tribute

Description


struc-ture








saveDictionary(path)Extract species from all entries associated with a kinetics library or depository and save them to the path



given.

saveEntry(f, entry)Write the given entry in the kinetics library to the file object f.

saveOld(path)Save an old-style reaction library to path. This creates files named species.txt, reactions.txt,and pdepreactions.txt in the given directory; these contain the species dictionary, high-pressure limitreactions and kinetics, and pressure-dependent reactions and kinetics, respectively.




rmgpy.data.kinetics.KineticsRules

class rmgpy.data.kinetics.KineticsRules(label=’‘, name=’‘, shortDesc=’‘, longDesc=’‘)A class for working with a set of “rate rules” for a RMG kinetics family.



calculateNormDistance(template, otherTemplate)Calculate the norm distance squared between two rate rules with template and otherTemplate. The normdistance is a^2 + b^2 + c^2 .... when a is the distance between the nodes in the first tree, b is the distancebetween the nodes in the second tree, etc.






estimateKinetics(template, degeneracy=1)Determine the appropriate kinetics for a reaction with the given template using rate rules.

fillRulesByAveragingUp(rootTemplate, alreadyDone, verbose=False)Fill in gaps in the kinetics rate rules by averaging child nodes. If verbose is set to True, then exact sourcesof kinetics are saved in the kinetics comments (warning: this uses up a lot of memory due to the extensivelylong comments)




getAllRules(template)Return all of the exact rate rules with the given template. Raises a ValueError if no corresponding entryexists.

getEntries()Return a list of all of the entries in the rate rules database, sorted by index.

getEntriesToSave()Return a sorted list of all of the entries in the rate rules database to save.

getRule(template)Return the exact rate rule with the given template, or None if no corresponding entry exists.


hasRule(template)Return True if a rate rule with the given template currently exists, or False otherwise.


loadOld(path, groups, numLabels)Load a set of old rate rules for kinetics groups into this depository.










At-tribute

Description


struc-ture





processOldLibraryEntry(data)Process a list of parameters data as read from an old-style RMG thermo database, returning the corre-sponding kinetics object.






saveOld(path, groups)Save a set of old rate rules for kinetics groups from this depository.




rmgpy.data.kinetics.LibraryReaction

class rmgpy.data.kinetics.LibraryReaction(index=-1, reactants=None, products=None, kinet-ics=None, reversible=True, transitionState=None,duplicate=False, degeneracy=1, pairs=None, li-brary=None, entry=None)

A Reaction object generated from a reaction library. In addition to the usual attributes, this class includes libraryand entry attributes to store the library and the entry in that library that it was created from.

calculateMicrocanonicalRateCoefficient()Calculate the microcanonical rate coefficient k(E) for the reaction reaction at the energies Elist in J/mol.reacDensStates and prodDensStates are the densities of states of the reactant and product configurationsfor this reaction. If the reaction is irreversible, only the reactant density of states is required; if the reaction



is reversible, then both are required. This function will try to use the best method that it can based on theinput data available:





k(T ) = κ(T )kBT

h

Q‡(T )

QA(T )QB(T )exp

(− E0

kBT

)where Q‡ is the partition function of the transition state, QA and QB are the partition function of thereactants, E0 is the ground-state energy difference from the transition state to the reactants, T is theabsolute temperature, kB is the Boltzmann constant, and h is the Planck constant. κ(T ) is an optionaltunneling correction.
























getSource()Return the database that was the source of this reaction. For a LibraryReaction this should be a Kinetic-sLibrary object.

















rmgpy.data.base.LogicNode

class rmgpy.data.base.LogicNode(items, invert)A base class for AND and OR logic nodes.

class rmgpy.data.base.LogicAnd(items, invert)A logical AND node. Structure must match all components.

matchToStructure(database, structure, atoms, strict=False)Does this node in the given database match the given structure with the labeled atoms?

Setting strict to True makes enforces matching of atomLabels in the structure to every atomLabel in thenode.

class rmgpy.data.base.LogicOr(items, invert)A logical OR node. Structure can match any component.

Initialize with a list of component items and a boolean instruction to invert the answer.



getPossibleStructures(entries)Return a list of the possible structures below this node.

matchLogicOr(other)Is other the same LogicOr group as self?

matchToStructure(database, structure, atoms, strict=False)Does this node in the given database match the given structure with the labeled atoms?

Setting strict to True makes enforces matching of atomLabels in the structure to every atomLabel in thenode.

rmgpy.data.base.makeLogicNode(string)Creates and returns a node in the tree which is a logic node.

String should be of the form:

•OR{}

•AND{}

•NOT OR{}

•NOT AND{}

And the returned object will be of class LogicOr or LogicAnd

rmgpy.data.kinetics.ReactionRecipe

class rmgpy.data.kinetics.ReactionRecipe(actions=None)Represent a list of actions that, when executed, result in the conversion of a set of reactants to a set of products.There are currently five such actions:

ActionName

Arguments Description

CHANGE_BONDcenter1, order,center2

change the bond order of the bond between center1 and center2 byorder; do not break or form bonds

FORM_BOND center1, order,center2

form a new bond between center1 and center2 of type order

BREAK_BONDcenter1, order,center2

break the bond between center1 and center2, which should be of typeorder

GAIN_RADICALcenter, radical increase the number of free electrons on center by radicalLOSE_RADICALcenter, radical decrease the number of free electrons on center by radicalGAIN_PAIR center, pair increase the number of lone electron pairs on center by pairLOSE_PAIR center, pair decrease the number of lone electron pairs on center by pair

The actions are stored as a list in the actions attribute. Each action is a list of items; the first is the action name,while the rest are the action parameters as indicated above.

addAction(action)Add an action to the reaction recipe, where action is a list containing the action name and the requiredparameters, as indicated in the table above.

applyForward(struct, unique=True)Apply the forward reaction recipe to molecule, a single Molecule object.

applyReverse(struct, unique=True)Apply the reverse reaction recipe to molecule, a single Molecule object.



getReverse()Generate a reaction recipe that, when applied, does the opposite of what the current recipe does, i.e., it isthe recipe for the reverse of the reaction that this is the recipe for.

rmgpy.data.statmech.StatmechDatabase

class rmgpy.data.statmech.StatmechDatabaseA class for working with the RMG statistical mechanics (frequencies) database.

getStatmechData(molecule, thermoModel=None)Return the thermodynamic parameters for a given Molecule object molecule. This function first searchesthe loaded libraries in order, returning the first match found, before falling back to estimation via groupadditivity.

getStatmechDataFromDepository(molecule)Return statmech data for the given Molecule object molecule by searching the entries in the depository.Returns a list of tuples (statmechData, depository, entry).

getStatmechDataFromGroups(molecule, thermoModel)Return statmech data for the given Molecule object molecule by estimating using characteristic groupfrequencies and fitting the remaining internal modes to heat capacity data from the given thermo modelthermoModel. This always returns valid degrees of freedom data.

getStatmechDataFromLibrary(molecule, library)Return statmech data for the given Molecule object molecule by searching the entries in the specifiedStatmechLibrary object library. Returns None if no data was found.

load(path, libraries=None, depository=True)Load the statmech database from the given path on disk, where path points to the top-level folder of thethermo database.

loadDepository(path)Load the statmech database from the given path on disk, where path points to the top-level folder of thethermo database.

loadGroups(path)Load the statmech database from the given path on disk, where path points to the top-level folder of thethermo database.

loadLibraries(path, libraries=None)Load the statmech database from the given path on disk, where path points to the top-level folder of thethermo database.

loadOld(path)Load the old RMG thermo database from the given path on disk, where path points to the top-level folderof the old RMG database.

save(path)Save the statmech database to the given path on disk, where path points to the top-level folder of thestatmech database.

saveDepository(path)Save the statmech depository to the given path on disk, where path points to the top-level folder of thestatmech depository.

saveGroups(path)Save the statmech groups to the given path on disk, where path points to the top-level folder of the statmechgroups.



saveLibraries(path)Save the statmech libraries to the given path on disk, where path points to the top-level folder of thestatmech libraries.

saveOld(path)Save the old RMG thermo database to the given path on disk, where path points to the top-level folder ofthe old RMG database.

rmgpy.data.statmech.StatmechDepository

class rmgpy.data.statmech.StatmechDepository(label=’‘, name=’‘, shortDesc=’‘, longDesc=’‘)A class for working with the RMG statistical mechanics (frequencies) depository.






















At-tribute

Description


struc-ture
















rmgpy.data.statmechfit

Fitting functions

rmgpy.data.statmechfit.fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None)For a given set of dimensionless heat capacity data Cvlist corresponding to temperature list Tlist in K, fit Nvibharmonic oscillator and Nrot hindered internal rotor modes. External and other previously-known modes shouldhave already been removed from Cvlist prior to calling this function. You must provide at least 7 values forCvlist.

This function returns a list containing the fitted vibrational frequencies in a HarmonicOscillator object andthe fitted 1D hindered rotors in HinderedRotor objects.

rmgpy.data.statmechfit.fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule=None)Fit Nvib harmonic oscillator and Nrot hindered internal rotor modes to the provided dimensionless heat capaci-ties Cvlist at temperatures Tlist in K. This method assumes that there are enough heat capacity points providedthat the vibrational frequencies and hindered rotation frequency- barrier pairs can be fit directly.

rmgpy.data.statmechfit.fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None)Fit Nvib harmonic oscillator and Nrot hindered internal rotor modes to the provided dimensionless heat capac-ities Cvlist at temperatures Tlist in K. This method assumes that there are enough heat capacity points pro-vided that the vibrational frequencies can be fit directly, but the hindered rotors must be combined into a single“pseudo-rotor”.

rmgpy.data.statmechfit.fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule=None)Fit Nvib harmonic oscillator and Nrot hindered internal rotor modes to the provided dimensionless heat capac-ities Cvlist at temperatures Tlist in K. This method assumes that there are relatively few heat capacity pointsprovided, so the vibrations must be combined into one real vibration and two “pseudo-vibrations” and the hin-dered rotors must be combined into a single “pseudo-rotor”.

Helper functions

rmgpy.data.statmechfit.harmonicOscillator_heatCapacity(T, freq)Return the heat capacity in J/mol*K at the given set of temperatures Tlist in K for the harmonic oscillator witha frequency freq in cm^-1.

rmgpy.data.statmechfit.harmonicOscillator_d_heatCapacity_d_freq(T, freq)Return the first derivative of the heat capacity with respect to the harmonic oscillator frequency in J/mol*K/cm^-1 at the given set of temperatures Tlist in K, evaluated at the frequency freq in cm^-1.

rmgpy.data.statmechfit.hinderedRotor_heatCapacity(T, freq, barr)Return the heat capacity in J/mol*K at the given set of temperatures Tlist in K for the 1D hindered rotor with afrequency freq in cm^-1 and a barrier height barr in cm^-1.

rmgpy.data.statmechfit.hinderedRotor_d_heatCapacity_d_freq(T, freq, barr)Return the first derivative of the heat capacity with respect to the hindered rotor frequency in J/mol*K/cm^-1 atthe given set of temperatures Tlist in K, evaluated at the frequency freq in cm^-1 and a barrier height barr incm^-1.



rmgpy.data.statmechfit.hinderedRotor_d_heatCapacity_d_barr(T, freq, barr)Return the first derivative of the heat capacity with respect to the hindered rotor frequency in J/mol*K/cm^-1 atthe given set of temperatures Tlist in K, evaluated at the frequency freq in cm^-1 and a barrier height barr incm^-1.

Helper classes

class rmgpy.data.statmechfit.DirectFit(Tdata, Cvdata, Nvib, Nrot)Class for fitting vibrational frequencies and hindered rotor frequency-barrier pairs for the case when there arefew enough oscillators and rotors that their values can be fit directly.

initialize()Initialize the DQED solver. The required parameters are:

•Neq - The number of algebraic equations.

•Nvars - The number of unknown variables.

•Ncons - The number of constraint equations.

The optional parameters are:

•bounds - A list of 2-tuples giving the lower and upper bound for each unknown variable. Use Noneif there is no bound in one or either direction. If provided, you must give bounds for every unknownvariable.

•tolf - The tolerance used for stopping when the norm of the residual has absolute length less than tolf,i.e. ‖~f‖ ≤ εf .

•told - The tolerance used for stopping when changes to the unknown variables has absolute length lessthan told, i.e. ‖∆~x‖ ≤ εd.

•tolx - The tolerance used for stopping when changes to the unknown variables has relative length lessthan tolx, i.e. ‖∆~x‖ ≤ εx · ‖~x‖.

•maxIter - The maximum number of iterations to use

•verbose - True to have DQED print extra information about the solve, False to only see printedoutput when the solver has an error.

solve()Using the initial guess x0, return the least-squares solution to the set of nonlinear algebraic equationsdefined by the evaluate() method of the derived class. This is the method that actually conducts thecall to DQED. Returns the solution vector and a flag indicating the status of the solve. The possible outputvalues of the flag are:



Value Meaning2 The norm of the residual is zero; the solution vector is a root of the system3 The bounds on the trust region are being encountered on each step; the solution vector may or

may not be a local minimum4 The solution vector is a local minimum5 A significant amount of noise or uncertainty has been observed in the residual; the solution

may or may not be a local minimum6 The solution vector is only changing by small absolute amounts; the solution may or may not

be a local minimum7 The solution vector is only changing by small relative amounts; the solution may or may not

be a local minimum8 The maximum number of iterations has been reached; the solution is the best found, but may

or may not be a local minimum9-18 An error occurred during the solve operation; the solution is not a local minimum

class rmgpy.data.statmechfit.PseudoRotorFit(Tdata, Cvdata, Nvib, Nrot)Class for fitting vibrational frequencies and hindered rotor frequency-barrier pairs for the case when there aretoo many oscillators and rotors for their values can be fit directly, and where collapsing the rotors into a singlepseudo-rotor allows for fitting the vibrational frequencies directly.





















class rmgpy.data.statmechfit.PseudoFit(Tdata, Cvdata, Nvib, Nrot)Class for fitting vibrational frequencies and hindered rotor frequency-barrier pairs for the case when there aretoo many oscillators and rotors for their values can be fit directly, and where we must collapse both the vibrationsand hindered rotations into “pseudo-oscillators” and “pseudo-rotors”.





















rmgpy.data.statmech.StatmechGroups

class rmgpy.data.statmech.StatmechGroups(label=’‘, name=’‘, shortDesc=’‘, longDesc=’‘)A class for working with an RMG statistical mechanics (frequencies) group database.








generateOldLibraryEntry(data)Return a list of values used to save entries to the old-style RMG thermo database based on the thermody-namics object data.



getFrequencyGroups(molecule)Return the set of characteristic group frequencies corresponding to the speficied molecule. This is done bysearching the molecule for certain functional groups for which characteristic frequencies are known, andusing those frequencies.




getStatmechData(molecule, thermoModel)Use the previously-loaded frequency database to generate a set of characteristic group frequencies corre-sponding to the speficied molecule. The provided thermo data in thermoModel is used to fit some frequen-cies and all hindered rotors to heat capacity data.










At-tribute

Description


struc-ture







processOldLibraryEntry(data)Process a list of parameters data as read from an old-style RMG statmech database, returning the corre-sponding thermodynamics object.










rmgpy.data.statmech.StatmechLibrary

class rmgpy.data.statmech.StatmechLibrary(label=’‘, name=’‘, shortDesc=’‘, longDesc=’‘)A class for working with a RMG statistical mechanics (frequencies) library.










At-tribute

Description


struc-ture





processOldLibraryEntry(data)Process a list of parameters data as read from an old-style RMG thermo database, returning the corre-sponding thermodynamics object.










rmgpy.data.kinetics.TemplateReaction

class rmgpy.data.kinetics.TemplateReaction(index=-1, reactants=None, products=None, kinet-ics=None, reversible=True, transitionState=None,duplicate=False, degeneracy=1, pairs=None, fam-ily=None, template=None, estimator=None, re-verse=None)

A Reaction object generated from a reaction family template. In addition to the usual attributes, this classincludes a family attribute to store the family that it was created from, as well as a estimator attribute to indicatewhether it came from a rate rules or a group additivity estimate.

calculateMicrocanonicalRateCoefficient()Calculate the microcanonical rate coefficient k(E) for the reaction reaction at the energies Elist in J/mol.



reacDensStates and prodDensStates are the densities of states of the reactant and product configurationsfor this reaction. If the reaction is irreversible, only the reactant density of states is required; if the reactionis reversible, then both are required. This function will try to use the best method that it can based on theinput data available:





k(T ) = κ(T )kBT

h

Q‡(T )

QA(T )QB(T )exp

(− E0

kBT

























getSource()Return the database that was the source of this reaction. For a TemplateReaction this should be a Kinetic-sGroups object.

















rmgpy.data.thermo.ThermoDatabase

class rmgpy.data.thermo.ThermoDatabaseA class for working with the RMG thermodynamics database.

computeGroupAdditivityThermo(molecule)Return the set of thermodynamic parameters corresponding to a given Molecule object molecule by esti-mation using the group additivity values. If no group additivity values are loaded, a DatabaseError israised.

The entropy is not corrected for the symmetry of the molecule. This should be done later by the callingfunction.

estimateRadicalThermoViaHBI(molecule, stableThermoEstimator)Estimate the thermodynamics of a radical by saturating it, applying the provided stableThermoEstimatormethod on the saturated species, then applying hydrogen bond increment corrections for the radical site(s)and correcting for the symmetry.



estimateThermoViaGroupAdditivity(molecule)Return the set of thermodynamic parameters corresponding to a given Molecule object molecule by esti-mation using the group additivity values. If no group additivity values are loaded, a DatabaseError israised.

extractSourceFromComments(species)species: A species object containing thermo data and thermo data comments

Parses the verbose string of comments from the thermo data of the species object, and extracts the thermosources.

Returns a dictionary with keys of either ‘Library’, ‘QM’, and/or ‘GAV’. Commonly, species thermo areestimated using only one of these sources. However, a radical can be estimated with more than one typeof source, for instance a saturated library value and a GAV HBI correction, or a QM saturated value and aGAV HBI correction.

source = {‘Library’: String_Name_of_Library_Used, ‘QM’: String_of_Method_Used, ‘GAV’: Dic-tionary_of_Groups_Used }

The Dictionary_of_Groups_Used looks like {‘groupType’:[List of tuples containing (Entry, Weight)]

getAllThermoData(species)Return all possible sets of thermodynamic parameters for a given Species object species. The hits fromthe depository come first, then the libraries (in order), and then the group additivity estimate. This methodis useful for a generic search job.

Returns: a list of tuples (ThermoData, source, entry) (Source is a library or depository, or None)

getRingGroupsFromComments(thermoData)Takes a string of comments from group additivity estimation, and extracts the ring and polycyclic ringgroups from them, returning them as lists.

getThermoData(species, trainingSet=None)Return the thermodynamic parameters for a given Species object species. This function first searchesthe loaded libraries in order, returning the first match found, before falling back to estimation via groupadditivity.

Returns: ThermoData

getThermoDataFromDepository(species)Return all possible sets of thermodynamic parameters for a given Species object species from the depos-itory. If no depository is loaded, a DatabaseError is raised.

Returns: a list of tuples (thermoData, depository, entry) without any Cp0 or CpInf data.

getThermoDataFromGroups(species)Return the set of thermodynamic parameters corresponding to a given Species object species by esti-mation using the group additivity values. If no group additivity values are loaded, a DatabaseError israised.

The resonance isomer (molecule) with the lowest H298 is used, and as a side-effect the resonance isomers(items in species.molecule list) are sorted in ascending order.

Returns: ThermoData

getThermoDataFromLibraries(species, trainingSet=None)Return the thermodynamic parameters for a given Species object species. This function first searches theloaded libraries in order, returning the first match found, before failing and returning None. trainingSet isused to identify if function is called during training set or not. During training set calculation we want touse gas phase thermo to not affect reverse rate calculation.

Returns: ThermoData or None



getThermoDataFromLibrary(species, library)Return the set of thermodynamic parameters corresponding to a given Species object species from thespecified thermodynamics library. If library is a string, the list of libraries is searched for a library withthat name. If no match is found in that library, None is returned. If no corresponding library is found, aDatabaseError is raised.

Returns a tuple: (ThermoData, library, entry) or None.

load(path, libraries=None, depository=True)Load the thermo database from the given path on disk, where path points to the top-level folder of thethermo database.

loadDepository(path)Load the thermo database from the given path on disk, where path points to the top-level folder of thethermo database.

loadGroups(path)Load the thermo database from the given path on disk, where path points to the top-level folder of thethermo database.

loadLibraries(path, libraries=None)Load the thermo database from the given path on disk, where path points to the top-level folder of thethermo database.

loadOld(path)Load the old RMG thermo database from the given path on disk, where path points to the top-level folderof the old RMG database.

prioritizeThermo(species, thermoDataList)Use some metrics to reorder a list of thermo data from best to worst. Return a list of indices with thedesired order associated with the index of thermo from the data list.

pruneHeteroatoms(allowed=[’C’, ‘H’, ‘O’, ‘S’])Remove all species from thermo libraries that contain atoms other than those allowed.

This is useful before saving the database for use in RMG-Java

save(path)Save the thermo database to the given path on disk, where path points to the top-level folder of the thermodatabase.

saveDepository(path)Save the thermo depository to the given path on disk, where path points to the top-level folder of thethermo depository.

saveGroups(path)Save the thermo groups to the given path on disk, where path points to the top-level folder of the thermogroups.

saveLibraries(path)Save the thermo libraries to the given path on disk, where path points to the top-level folder of the thermolibraries.

saveOld(path)Save the old RMG thermo database to the given path on disk, where path points to the top-level folder ofthe old RMG database.



rmgpy.data.thermo.ThermoDepository

class rmgpy.data.thermo.ThermoDepository(label=’‘, name=’‘, shortDesc=’‘, longDesc=’‘)A class for working with the RMG thermodynamics depository.
















matchNodeToChild(parentNode, childNode)Return True if parentNode is a parent of childNode. Otherwise, return False. Both parentNode and



childNode must be Entry types with items containing Group or LogicNode types. If parentNode andchildNode are identical, the function will also return False.




At-tribute

Description


struc-ture
















rmgpy.data.thermo.ThermoGroups

class rmgpy.data.thermo.ThermoGroups(label=’‘, name=’‘, shortDesc=’‘, longDesc=’‘)A class for working with an RMG thermodynamics group additivity database.



copyData(source, destination)This method copys the ThermoData object and all meta data from source to destination Args:

Unexpected indentation.

source: The entry for which data is being copied destination: The entry for which data is beingoverwritten












loadOldDictionary(path, pattern)Parse an old-style RMG database dictionary located at path. An RMG dictionary is a list of key-value



pairs of a one-line string key and a multi-line string value. Each record is separated by at least one emptyline. Returns a dict object with the values converted to Molecule or Group objects depending on thevalue of pattern.







At-tribute

Description


struc-ture






removeGroup(groupToRemove)Removes a group that is in a tree from the database. For thermo groups we also, need to re-point anyunicode thermoData that may have pointed to the entry.











rmgpy.data.thermo.ThermoLibrary

class rmgpy.data.thermo.ThermoLibrary(label=’‘, name=’‘, solvent=None, shortDesc=’‘,longDesc=’‘)

A class for working with a RMG thermodynamics library.























At-tribute

Description


struc-ture

















1.5 Kinetics (rmgpy.kinetics)

The rmgpy.kinetics subpackage contains classes that represent various kinetics models of chemical reaction ratesand models of quantum mechanical tunneling through an activation barrier.

1.5.1 Pressure-independent kinetics models

Class DescriptionKineticsData A kinetics model based on a set of discrete rate coefficient points in temperatureArrhenius A kinetics model based on the (modified) Arrhenius expressionMultiArrhenius A kinetics model based on a sum of Arrhenius expressions

1.5.2 Pressure-dependent kinetics models

Class DescriptionPDepKineticsData A kinetics model based on a set of discrete rate coefficient points in temperature and

pressurePDepArrhenius A kinetics model based on a set of Arrhenius expressions for a range of pressuresMultiPDepArrheniusA kinetics model based on a sum of PDepArrhenius expressionsChebyshev A kinetics model based on a Chebyshev polynomial representationThirdBody A low pressure-limit kinetics model based on the (modified) Arrhenius expression, with a

third bodyLindemann A kinetics model of pressure-dependent falloff based on the Lindemann modelTroe A kinetics model of pressure-dependent falloff based on the Lindemann model with the

Troe falloff factor



1.5.3 Tunneling models

Class DescriptionWigner A one-dimensional tunneling model based on the Wigner expressionEckart A one-dimensional tunneling model based on the (asymmetric) Eckart expression

rmgpy.kinetics.KineticsData

class rmgpy.kinetics.KineticsData(Tdata=None, kdata=None, Tmin=None, Tmax=None, Pmin=None,Pmax=None, comment=’‘)

A kinetics model based on an array of rate coefficient data vs. temperature. The attributes are:

Attribute DescriptionTdata An array of temperatures at which rate coefficient values are knownkdata An array of rate coefficient valuesTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedcomment Information about the model (e.g. its source)

PmaxThe maximum pressure at which the model is valid, or None if not defined.

PminThe minimum pressure at which the model is valid, or None if not defined.

TdataAn array of temperatures at which rate coefficient values are known.

TmaxThe maximum temperature at which the model is valid, or None if not defined.

TminThe minimum temperature at which the model is valid, or None if not defined.

commentcomment: str

discrepancy(self, KineticsModel otherKinetics)→ doubleReturns some measure of the discrepancy based on two different reaction models.

getRateCoefficient(self, double T, double P=0.0)→ doubleReturn the rate coefficient in the appropriate combination of m^3, mol, and s at temperature T in K.

isIdenticalTo(self, KineticsModel otherKinetics)→ boolReturns True if the kdata and Tdata match. Returns False otherwise.

isPressureDependent(self)→ boolReturn False since, by default, all objects derived from KineticsModel represent pressure-independentkinetics.

isSimilarTo(self, KineticsModel otherKinetics)→ boolReturns True if rates of reaction at temperatures 500,1000,1500,2000 K and 1 and 10 bar are within +/ .5for log(k), in other words, within a factor of 3.

isTemperatureValid(self, double T)→ boolReturn True if the temperature T in K is within the valid temperature range of the kinetic data, or Falseif not. If the minimum and maximum temperature are not defined, True is returned.

1.5. Kinetics (rmgpy.kinetics) 65


kdataAn array of rate coefficient values.

setCanteraKinetics(self, ctReaction, speciesList)Sets the kinetics for a cantera reaction object.

toHTML(self)Return an HTML rendering.

rmgpy.kinetics.Arrhenius

class rmgpy.kinetics.Arrhenius(A=None, n=0.0, Ea=None, T0=(1.0, ‘K’), Tmin=None, Tmax=None,Pmin=None, Pmax=None, comment=’‘)

A kinetics model based on the (modified) Arrhenius equation. The attributes are:

Attribute DescriptionA The preexponential factorT0 The reference temperaturen The temperature exponentEa The activation energyTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedcomment Information about the model (e.g. its source)

The Arrhenius equation, given below, accurately reproduces the kinetics of many reaction families:

k(T ) = A

(T

T0

)nexp

(− Ea

RT

)Above, A is the preexponential factor, T0 is the reference temperature, n is the temperature exponent, and Ea isthe activation energy.

AThe preexponential factor.

EaThe activation energy.



T0The reference temperature.



changeRate(self, double factor)Changes A factor in Arrhenius expression by multiplying it by a factor.

changeT0(self, double T0)Changes the reference temperature used in the exponent to T0 in K, and adjusts the preexponential factoraccordingly.



commentcomment: str


fitToData(self, ndarray Tlist, ndarray klist, str kunits, double T0=1, ndarray weights=None, bool three-Params=True)

Fit the Arrhenius parameters to a set of rate coefficient data klist in units of kunits corresponding to a setof temperatures Tlist in K. A linear least-squares fit is used, which guarantees that the resulting parametersprovide the best possible approximation to the data.


isIdenticalTo(self, KineticsModel otherKinetics)→ boolReturns True if kinetics matches that of another kinetics model. Must match temperature and pressurerange of kinetics model, as well as parameters: A, n, Ea, T0. (Shouldn’t have pressure range if it’sArrhenius.) Otherwise returns False.




nThe temperature exponent.

setCanteraKinetics(self, ctReaction, speciesList)Passes in a cantera ElementaryReaction() object and sets its rate to a Cantera Arrhenius() object.

toCanteraKinetics(self)Converts the Arrhenius object to a cantera Arrhenius object

Arrhenius(A,b,E) where A is in units of m^3/kmol/s, b is dimensionless, and E is in J/kmol


rmgpy.kinetics.MultiArrhenius

class rmgpy.kinetics.MultiArrhenius(arrhenius=None, Tmin=None, Tmax=None, Pmin=None,Pmax=None, comment=’‘)

A kinetics model based on a set of (modified) Arrhenius equations, which are summed to obtain the overall rate.The attributes are:

Attribute Descriptionarrhenius A list of the Arrhenius kineticsTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedcomment Information about the model (e.g. its source)







arrheniusarrhenius: list

changeRate(self, double factor)Change kinetics rate by a multiple factor.

commentcomment: str



isIdenticalTo(self, KineticsModel otherKinetics)→ boolReturns True if kinetics matches that of another kinetics model. Each duplicate reaction must be matchedand equal to that in the other MultiArrhenius model in the same order. Otherwise returns False




setCanteraKinetics(self, ctReaction, speciesList)Sets the kinetic rates for a list of cantera Reaction objects Here, ctReaction must be a list rather than asingle cantera reaction.

toArrhenius(self, double Tmin=-1, double Tmax=-1)→ ArrheniusReturn an Arrhenius instance of the kinetics model

Fit the Arrhenius parameters to a set of rate coefficient data generated from the MultiArrhenius kinetics,over the temperature range Tmin to Tmax, in Kelvin. If Tmin or Tmax are unspecified (or -1) then theMultiArrhenius’s Tmin and Tmax are used. A linear least-squares fit is used, which guarantees that theresulting parameters provide the best possible approximation to the data.




rmgpy.kinetics.PDepKineticsData

class rmgpy.kinetics.PDepKineticsData(Tdata=None, Pdata=None, kdata=None, Tmin=None,Tmax=None, Pmin=None, Pmax=None, comment=’‘)

A kinetics model based on an array of rate coefficient data vs. temperature and pressure. The attributes are:

Attribute DescriptionTdata An array of temperatures at which rate coefficient values are knownPdata An array of pressures at which rate coefficient values are knownkdata An array of rate coefficient values at each temperature and pressureTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedcomment Information about the model (e.g. its source)

PdataAn array of pressures at which rate coefficient values are known.



TdataAn array of temperatures at which rate coefficient values are known.



commentcomment: str


efficienciesefficiencies: dict

getCanteraEfficiencies(self, speciesList)Returns a dictionary containing the collider efficiencies for this PDepKineticsModel object suitablefor setting the efficiencies in the following cantera reaction objects: ThreeBodyReaction, FalloffReac-tion,‘ChemicallyActivatedReaction‘

getEffectiveColliderEfficiencies(self, list species)→ ndarrayReturn the effective collider efficiencies for all species in the form of a numpy array. This function helpsassist rapid effective pressure calculations in the solver.

getEffectivePressure(self, double P, list species, ndarray fractions)→ doubleReturn the effective pressure in Pa for a system at a given pressure P in Pa composed of the given list ofspecies (Species or Molecule objects) with the given fractions.

getRateCoefficient(self, double T, double P=0.0)→ doubleReturn the rate coefficient in the appropriate combination of m^3, mol, and s at temperature T in K andpressure P in Pa.



highPlimithighPlimit: rmgpy.kinetics.model.KineticsModel

isIdenticalTo(self, KineticsModel otherKinetics)→ boolReturns True if the kdata and Tdata match. Returns False otherwise.

isPressureDependent(self)→ boolReturn True since all objects derived from PDepKineticsModel represent pressure-dependent kinetics.

isPressureValid(self, double P)→ boolReturn True if the pressure P in Pa is within the valid pressure range of the kinetic data, or False if not.If the minimum and maximum pressure are not defined, True is returned.



kdataAn array of rate coefficient values at each temperature and pressure.

setCanteraKinetics(self, ctReaction, speciesList)Sets the kinetics for a cantera reaction object.


rmgpy.kinetics.PDepArrhenius

class rmgpy.kinetics.PDepArrhenius(pressures=None, arrhenius=None, highPlimit=None,Tmin=None, Tmax=None, Pmin=None, Pmax=None, com-ment=’‘)

A kinetic model of a phenomenological rate coefficient k(T, P ) where a set of Arrhenius kinetics are stored ata variety of pressures and interpolated between on a logarithmic scale. The attributes are:

Attribute Descriptionpressures The list of pressuresarrhenius The list of Arrhenius objects at each pressureTmin The minimum temperature in K at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature in K at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure in bar at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure in bar at which the model is valid, or zero if unknown or undefinedefficiencies A dict associating chemical species with associated efficienciesorder The reaction order (1 = first, 2 = second, etc.)comment Information about the model (e.g. its source)

The pressure-dependent Arrhenius formulation is sometimes used to extend the Arrhenius expression to handlepressure-dependent kinetics. The formulation simply parameterizes A, n, and Ea to be dependent on pressure:

k(T, P ) = A(P )

(T

T0

)n(P )

exp

(−Ea(P )

RT

)Although this suggests some physical insight, the k(T, P ) data is often highly complex and non-Arrhenius,limiting the usefulness of this formulation to simple systems.








changeRate(self, double factor)Changes kinetics rate by a multiple factor.

commentcomment: str



fitToData(self, ndarray Tlist, ndarray Plist, ndarray K, str kunits, double T0=1)Fit the pressure-dependent Arrhenius model to a matrix of rate coefficient data K with units of kunitscorresponding to a set of temperatures Tlist in K and pressures Plist in Pa. An Arrhenius model is fit cpdefchangeRate(self, double factor)at each pressure.




getRateCoefficient(self, double T, double P=0)→ doubleReturn the rate coefficient in the appropriate combination of m^3, mol, and s at temperature T in K andpressure P in Pa.


isIdenticalTo(self, KineticsModel otherKinetics)→ boolReturns True if kinetics matches that of another kinetics model. Each duplicate reaction must be matchedand equal to that in the other PDepArrhenius model in the same order. Otherwise returns False







pressuresThe list of pressures.

setCanteraKinetics(self, ctReaction, speciesList)Sets a Cantera PlogReaction()’s rates attribute with A list of tuples containing [(pressure in Pa, canteraarrhenius object), (..)]


rmgpy.kinetics.MultiPDepArrhenius

class rmgpy.kinetics.MultiPDepArrhenius(arrhenius=None, Tmin=None, Tmax=None, Pmin=None,Pmax=None, comment=’‘)

A kinetic model of a phenomenological rate coefficient k(T, P ) where sets of Arrhenius kinetics are stored at avariety of pressures and interpolated between on a logarithmic scale. The attributes are:

Attribute Descriptionarrhenius A list of the PDepArrhenius kinetics at each temperatureTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedcomment Information about the model (e.g. its source)






changeRate(self, double factor)Change kinetic rate by a multiple factor.

commentcomment: str








getRateCoefficient(self, double T, double P=0.0)→ doubleReturn the rate coefficient in the appropriate combination of m^3, mol, and s at temperature T in K andpressure P in Pa.


isIdenticalTo(self, KineticsModel otherKinetics)→ boolReturns True if kinetics matches that of another kinetics model. Each duplicate reaction must be matchedand equal to that in the other MultiArrhenius model in the same order. Otherwise returns False





setCanteraKinetics(self, ctReaction, speciesList)Sets the PLOG kinetics for multiple cantera Reaction objects, provided in a list. ctReaction is a list ofcantera reaction objects.


rmgpy.kinetics.Chebyshev

class rmgpy.kinetics.Chebyshev(coeffs=None, kunits=’‘, highPlimit=None, Tmin=None, Tmax=None,Pmin=None, Pmax=None, comment=’‘)

A model of a phenomenological rate coefficient k(T, P ) using a set of Chebyshev polynomials in temperatureand pressure. The attributes are:



Attribute Descriptioncoeffs Matrix of Chebyshev coefficients, such that the resulting k(T, P ) has units of cm^3, mol, skunits The units of the rate coefficientdegreeT The number of terms in the inverse temperature directiondegreeP The number of terms in the log pressure directionTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedcomment Information about the model (e.g. its source)

The Chebyshev polynomial formulation is a means of fitting a wide range of complex k(T, P ) behavior. How-ever, there is no meaningful physical interpretation of the polynomial-based fit, and one must take care tominimize the magnitude of Runge’s phenomenon. The formulation is as follows:

log k(T, P ) =

NT∑t=1

NP∑p=1

αtpφt(T )φp(P )

Above, αtp is a constant, φn(x) is the Chebyshev polynomial of degree n evaluated at x, and

T ≡ 2T−1 − T−1min − T−1max

T−1max − T−1min

P ≡ 2 logP − logPmin − logPmax

logPmax − logPmin

are reduced temperature and reduced pressure designed to map the ranges (Tmin, Tmax) and (Pmin, Pmax) to(−1, 1).





changeRate(self, double factor)Changes kinetics rates by a multiple factor.

coeffsThe Chebyshev coefficients.

commentcomment: str

degreePdegreeP: ‘int’

degreeTdegreeT: ‘int’





fitToData(self, ndarray Tlist, ndarray Plist, ndarray K, str kunits, int degreeT, int degreeP, doubleTmin, double Tmax, double Pmin, double Pmax)

Fit a Chebyshev kinetic model to a set of rate coefficients K, which is a matrix corresponding to thetemperatures Tlist in K and pressures Plist in Pa. degreeT and degreeP are the degree of the polynomialsin temperature and pressure, while Tmin, Tmax, Pmin, and Pmax set the edges of the valid temperatureand pressure ranges in K and bar, respectively.




getRateCoefficient(self, double T, double P=0)→ doubleReturn the rate coefficient in the appropriate combination of m^3, mol, and s at temperature T in K andpressure P in Pa by evaluating the Chebyshev expression.


isIdenticalTo(self, KineticsModel otherKinetics)→ boolChecks to see if kinetics matches that of other kinetics and returns True if coeffs, kunits, Tmin,





kunitskunits: str

setCanteraKinetics(self, ctReaction, speciesList)Sets the kinetics parameters for a Cantera ChebyshevReaction() object Usesset_parameters(self,Tmin,Tmax,Pmin,Pmax,coeffs) where T’s are in units of K, P’s in units of Pa,and coeffs is 2D array of (nTemperature, nPressure).




rmgpy.kinetics.ThirdBody

class rmgpy.kinetics.ThirdBody(arrheniusLow=None, Tmin=None, Tmax=None, Pmin=None,Pmax=None, efficiencies=None, comment=’‘)

A kinetic model of a phenomenological rate coefficient k(T, P ) using third-body kinetics. The attributes are:

Attribute DescriptionarrheniusLow The Arrhenius kinetics at the low-pressure limitTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedefficiencies A dict associating chemical species with associated efficienciescomment Information about the model (e.g. its source)

Third-body kinetics simply introduce an inert third body to the rate expression:

k(T, P ) = k0(T )[M]

Above, [M] ≈ P/RT is the concentration of the bath gas. This formulation is equivalent to stating that thekinetics are always in the low-pressure limit.





arrheniusLowarrheniusLow: rmgpy.kinetics.arrhenius.Arrhenius


commentcomment: str








getRateCoefficient(self, double T, double P=0.0)→ doubleReturn the value of the rate coefficient k(T ) in units of m^3, mol, and s at the specified temperatureT in K and pressure P in Pa. If you wish to consider collision efficiencies, then you should first usegetEffectivePressure() to compute the effective pressure, and pass that value as the pressure to thismethod.







setCanteraKinetics(self, ctReaction, speciesList)Sets the kinetics and efficiencies for a cantera ThreeBodyReaction object


rmgpy.kinetics.Lindemann

class rmgpy.kinetics.Lindemann(arrheniusHigh=None, arrheniusLow=None, Tmin=None, Tmax=None,Pmin=None, Pmax=None, efficiencies=None, comment=’‘)

A kinetic model of a phenomenological rate coefficient k(T, P ) using the Lindemann formulation. The attributesare:

Attribute DescriptionarrheniusHigh The Arrhenius kinetics at the high-pressure limitarrheniusLow The Arrhenius kinetics at the low-pressure limitTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedefficiencies A dict associating chemical species with associated efficienciescomment Information about the model (e.g. its source)

The Lindemann model qualitatively predicts the falloff of some simple pressure-dependent reaction kinetics.The formulation is as follows:

k(T, P ) = k∞(T )

[Pr

1 + Pr

]



where

Pr =k0(T )

k∞(T )[M]

k0(T ) = A0Tn0 exp

(− E0

RT

)k∞(T ) = A∞T

n∞ exp

(−E∞RT

)and [M] ≈ P/RT is the concentration of the bath gas. The Arrhenius expressions k0(T ) and k∞(T ) representthe low-pressure and high-pressure limit kinetics, respectively.





arrheniusHigharrheniusHigh: rmgpy.kinetics.arrhenius.Arrhenius



commentcomment: str















setCanteraKinetics(self, ctReaction, speciesList)Sets the efficiencies and kinetics for a cantera reaction.


rmgpy.kinetics.Troe

class rmgpy.kinetics.Troe(arrheniusHigh=None, arrheniusLow=None, alpha=0.0, T3=None, T1=None,T2=None, Tmin=None, Tmax=None, Pmin=None, Pmax=None, efficien-cies=None, comment=’‘)

A kinetic model of a phenomenological rate coefficient k(T, P ) using the Troe formulation. The attributes are:

Attribute DescriptionarrheniusHigh The Arrhenius kinetics at the high-pressure limitarrheniusLow The Arrhenius kinetics at the low-pressure limitalpha The α parameterT1 The T1 parameterT2 The T2 parameterT3 The T3 parameterTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedPmin The minimum pressure at which the model is valid, or zero if unknown or undefinedPmax The maximum pressure at which the model is valid, or zero if unknown or undefinedefficiencies A dict associating chemical species with associated efficienciescomment Information about the model (e.g. its source)

The Troe model attempts to make the Lindemann model quantitative by introducing a broadening factor F . Theformulation is as follows:

k(T, P ) = k∞(T )

[Pr

1 + Pr

]F



where

Pr =k0(T )

k∞(T )[M]

k0(T ) = A0Tn0 exp

(− E0

RT

)k∞(T ) = A∞T

n∞ exp

(−E∞RT

)and [M] ≈ P/RT is the concentration of the bath gas. The Arrhenius expressions k0(T ) and k∞(T ) representthe low-pressure and high-pressure limit kinetics, respectively. The broadening factor F is computed via

logF =

{1 +

[logPr + c

n− d(logPr + c)

]2}−1logFcent

c = −0.4− 0.67 logFcent

n = 0.75− 1.27 logFcent

d = 0.14

Fcent = (1− α) exp (−T/T3) + α exp (−T/T1) + exp (−T2/T )



T1The Troe T1 parameter.





alphaalpha: ‘double’

arrheniusHigharrheniusHigh: rmgpy.kinetics.arrhenius.Arrhenius



commentcomment: str















setCanteraKinetics(self, ctReaction, speciesList)Sets the efficiencies, kinetics, and troe falloff parameters for a cantera FalloffReaction.


rmgpy.kinetics.Wigner

class rmgpy.kinetics.Wigner(frequency)A tunneling model based on the Wigner formula. The attributes are:

Attribute Descriptionfrequency The imaginary frequency of the transition state



An early formulation for incorporating the effect of tunneling is that of Wigner [1932Wigner]:

κ(T ) = 1 +1

24

(h |νTS|kBT

)2

where h is the Planck constant, νTS is the negative frequency, kB is the Boltzmann constant, and T is theabsolute temperature.

The Wigner formula represents the first correction term in a perturbative expansion for a parabolic barrier[1959Bell], and is therefore only accurate in the limit of a small tunneling correction. There are many cases forwhich the tunneling correction is very large; for these cases the Wigner model is inappropriate.

calculateTunnelingFactor(self, double T)→ doubleCalculate and return the value of the Wigner tunneling correction for the reaction at the temperature T inK.

calculateTunnelingFunction(self, ndarray Elist)→ ndarrayRaises NotImplementedError, as the Wigner tunneling model does not have a well-defined energy-dependent tunneling function.

frequencyThe negative frequency along the reaction coordinate.

rmgpy.kinetics.Eckart

class rmgpy.kinetics.Eckart(frequency, E0_reac, E0_TS, E0_prod=None)A tunneling model based on the Eckart model. The attributes are:

Attribute Descriptionfrequency The imaginary frequency of the transition stateE0_reac The ground-state energy of the reactantsE0_TS The ground-state energy of the transition stateE0_prod The ground-state energy of the products

If E0_prod is not given, it is assumed to be the same as the reactants; this results in the so-called “symmetric”Eckart model. Providing E0_prod, and thereby using the “asymmetric” Eckart model, is the recommendedapproach.

The Eckart tunneling model is based around a potential of the form

V (x) =~2

2m

[Aex

1 + ex+

Bex

(1 + ex)2

]

where x represents the reaction coordinate and A and B are parameters. The potential is symmetric if A = 0and asymmetric if A 6= 0. If we add the constraint |B| > |A| then the potential has a maximum at

xmax = ln

(B +A

B −A

)

V (xmax) =~2

2m

(A+B)2

4B

The one-dimensional Schrodinger equation with the Eckart potential is analytically solvable. The resultingmicrocanonical tunneling factor κ(E) is a function of the total energy of the molecular system:

κ(E) = 1− cosh(2πa− 2πb) + cosh(2πd)

cosh(2πa+ 2πb) + cosh(2πd)



where

2πa =2√α1ξ

α−1/21 + α

−1/22

2πb =2√|(ξ − 1)α1 + α2|α−1/21 + α

−1/22

2πd = 2√|α1α2 − 4π2/16|

α1 = 2π∆V1h |νTS|

α2 = 2π∆V2h |νTS|

ξ =E

∆V1

∆V1 and ∆V2 are the thermal energy difference between the transition state and the reactants and products,respectively; νTS is the negative frequency, h is the Planck constant.

Applying a Laplace transform gives the canonical tunneling factor as a function of temperature T (expressed asβ ≡ 1/kBT ):

κ(T ) = eβΔV1

∫ ∞0

κ(E)e−βE dE

If product data is not available, then it is assumed that α2 ≈ α1.

The Eckart correction requires information about the reactants as well as the transition state. For best results,information about the products should also be given. (The former is called the symmetric Eckart correction, thelatter the asymmetric Eckart correction.) This extra information allows the Eckart correction to generally give abetter result than the Wigner correction.

E0_TSThe ground-state energy of the transition state.

E0_prodThe ground-state energy of the products.

E0_reacThe ground-state energy of the reactants.

calculateTunnelingFactor(self, double T)→ doubleCalculate and return the value of the Eckart tunneling correction for the reaction at the temperature T in K.

calculateTunnelingFunction(self, ndarray Elist)→ ndarrayCalculate and return the value of the Eckart tunneling function for the reaction at the energies Elist inJ/mol.

frequencyThe negative frequency along the reaction coordinate.



1.6 Molecular representations (rmgpy.molecule)

The rmgpy.molecule subpackage contains classes and functions for working with molecular representations, partic-ularly using chemical graph theory.

1.6.1 Graphs

Class DescriptionVertex A generic vertex (node) in a graphEdge A generic edge (arc) in a graphGraph A generic graph data type

1.6.2 Graph isomorphism

Class DescriptionVF2 Graph isomorphism using the VF2 algorithm

1.6.3 Elements and atom types

Class/Function DescriptionElement A model of a chemical elementgetElement() Return the Element object for a given atomic number or symbolAtomType A model of an atom type: an element and local bond structuregetAtomType() Return the AtomType object for a given atom in a molecule

1.6.4 Molecules

Class DescriptionAtom An atom in a moleculeBond A bond in a moleculeMolecule A molecular structure represented using a chemical graph

1.6.5 Functional groups

Class DescriptionGroupAtom An atom in a functional groupGroupBond A bond in a functional groupGroup A functional group structure represented using a chemical graph

1.6.6 Adjacency lists

Function DescriptionfromAdjacencyList() Convert an adjacency list to a set of atoms and bondstoAdjacencyList() Convert a set of atoms and bonds to an adjacency list



1.6.7 Symmetry numbers

Class DescriptioncalculateAtomSymmetryNumber() Calculate the atom-centered symmetry number for an atom in a moleculecalculateBondSymmetryNumber() Calculate the bond-centered symmetry number for a bond in a moleculecalculateAxisSymmetryNumber() Calculate the axis-centered symmetry number for a double bond axis in a

moleculecalculateCyclicSymmetryNumber()Calculate the ring-centered symmetry number for a ring in a moleculecalculateSymmetryNumber() Calculate the total internal + external symmetry number for a molecule

1.6.8 Molecule and reaction drawing

Class DescriptionMoleculeDrawer Draw the skeletal formula of a moleculeReactionDrawer Draw a chemical reaction

1.6.9 Exceptions

Exception DescriptionElementError Raised when an error occurs while working with chemical elementsAtomTypeError Raised when an error occurs while working with atom typesInvalidAdjacencyListError Raised when an invalid adjacency list is encounteredActionError Raised when an error occurs while working with a reaction recipe action

rmgpy.molecule.graph.Vertex

class rmgpy.molecule.graph.VertexA base class for vertices in a graph. Contains several connectivity values useful for accelerating isomorphismsearches, as proposed by Morgan (1965).

Attribute Type Descriptionconnectivity1 int The number of nearest neighborsconnectivity2 int The sum of the neighbors’ connectivity1 valuesconnectivity3 int The sum of the neighbors’ connectivity2 valuessortingLabel int An integer label used to sort the vertices

copy()Return a copy of the vertex. The default implementation assumes that no semantic information is associ-ated with each vertex, and therefore simply returns a new Vertex object.

equivalent()Return True if two vertices self and other are semantically equivalent, or False if not. You shouldreimplement this function in a derived class if your vertices have semantic information.

isSpecificCaseOf()Return True if self is semantically more specific than other, or False if not. You should reimplementthis function in a derived class if your edges have semantic information.

resetConnectivityValues()Reset the cached structure information for this vertex.

1.6. Molecular representations (rmgpy.molecule) 85

http://dx.doi.org/10.1021/c160017a018


rmgpy.molecule.graph.Edge

class rmgpy.molecule.graph.EdgeA base class for edges in a graph. This class does not store the vertex pair that comprises the edge; thatfunctionality would need to be included in the derived class.

copy()Return a copy of the edge. The default implementation assumes that no semantic information is associatedwith each edge, and therefore simply returns a new Edge object. Note that the vertices are not copied inthis implementation.

equivalent()Return True if two edges self and other are semantically equivalent, or False if not. You should reim-plement this function in a derived class if your edges have semantic information.

getOtherVertex()Given a vertex that makes up part of the edge, return the other vertex. Raise a ValueError if the givenvertex is not part of the edge.

isSpecificCaseOf()Return True if self is semantically more specific than other, or False if not. You should reimplementthis function in a derived class if your edges have semantic information.

rmgpy.molecule.graph.Graph

class rmgpy.molecule.graph.GraphA graph data type. The vertices of the graph are stored in a list vertices; this provides a consistent traversalorder. The edges of the graph are stored in a dictionary of dictionaries edges. A single edge can be accessedusing graph.edges[vertex1][vertex2] or the getEdge() method; in either case, an exception will beraised if the edge does not exist. All edges of a vertex can be accessed using graph.edges[vertex] or thegetEdges() method.

addEdge()Add an edge to the graph. The two vertices in the edge must already exist in the graph, or a ValueErroris raised.

addVertex()Add a vertex to the graph. The vertex is initialized with no edges.

copy()Create a copy of the current graph. If deep is True, a deep copy is made: copies of the vertices and edgesare used in the new graph. If deep is False or not specified, a shallow copy is made: the original verticesand edges are used in the new graph.

findIsomorphism()Returns True if other is subgraph isomorphic and False otherwise, and the matching mapping. Uses theVF2 algorithm of Vento and Foggia.

findSubgraphIsomorphisms()Returns True if other is subgraph isomorphic and False otherwise. Also returns the lists all of validmappings.

Uses the VF2 algorithm of Vento and Foggia.

getAllCycles()Given a starting vertex, returns a list of all the cycles containing that vertex.

getAllCyclicVertices()Returns all vertices belonging to one or more cycles.



getAllPolycyclicVertices()Return all vertices belonging to two or more cycles, fused or spirocyclic.

getDisparateRings()Return a list of distinct polycyclic and monocyclic rings within the graph. There is some code duplicationin this function in order to maximize speed up so as to call self.getSmallestSetOfSmallestRings() only once.

Returns: monocyclicRingsList, polycyclicRingsList

getEdge()Returns the edge connecting vertices vertex1 and vertex2.

getEdges()Return a list of the edges involving the specified vertex.

getMonocyclicRings()Return a list of cycles that are monocyclic.

getPolycyclicRings()Return a list of cycles that are polycyclic. In other words, merge the cycles which are fused or spirocyclicinto a single polycyclic cycle, and return only those cycles. Cycles which are not polycyclic are notreturned.

getSmallestSetOfSmallestRings()Return a list of the smallest set of smallest rings in the graph. The algorithm implements was adapted froma description by Fan, Panaye, Doucet, and Barbu (doi: 10.1021/ci00015a002)

B. T. Fan, A. Panaye, J. P. Doucet, and A. Barbu. “Ring Perception: A New Algorithm for Directly Findingthe Smallest Set of Smallest Rings from a Connection Table.” J. Chem. Inf. Comput. Sci. 33, p. 657-662(1993).

hasEdge()Returns True if vertices vertex1 and vertex2 are connected by an edge, or False if not.

hasVertex()Returns True if vertex is a vertex in the graph, or False if not.

isCyclic()Return True if one or more cycles are present in the graph or False otherwise.

isEdgeInCycle()Return True if the edge between vertices vertex1 and vertex2 is in one or more cycles in the graph, orFalse if not.

isIsomorphic()Returns True if two graphs are isomorphic and False otherwise. Uses the VF2 algorithm of Vento andFoggia.

isMappingValid()Check that a proposed mapping of vertices from self to other is valid by checking that the vertices andedges involved in the mapping are mutually equivalent.

isSubgraphIsomorphic()Returns True if other is subgraph isomorphic and False otherwise. Uses the VF2 algorithm of Vento andFoggia.

isVertexInCycle()Return True if the given vertex is contained in one or more cycles in the graph, or False if not.

merge()Merge two graphs so as to store them in a single Graph object.



removeEdge()Remove the specified edge from the graph. Does not remove vertices that no longer have any edges as aresult of this removal.

removeVertex()Remove vertex and all edges associated with it from the graph. Does not remove vertices that no longerhave any edges as a result of this removal.

resetConnectivityValues()Reset any cached connectivity information. Call this method when you have modified the graph.

sortVertices()Sort the vertices in the graph. This can make certain operations, e.g. the isomorphism functions, muchmore efficient.

split()Convert a single Graph object containing two or more unconnected graphs into separate graphs.

updateConnectivityValues()Update the connectivity values for each vertex in the graph. These are used to accelerate the isomorphismchecking.

rmgpy.molecule.vf2.VF2

class rmgpy.molecule.vf2.VF2An implementation of the second version of the Vento-Foggia (VF2) algorithm for graph and subgraph isomor-phism.

findIsomorphism()Return a list of dicts of all valid isomorphism mappings from graph graph1 to graph graph2 with theoptional initial mapping initialMapping. If no valid isomorphisms are found, an empty list is returned.

findSubgraphIsomorphisms()Return a list of dicts of all valid subgraph isomorphism mappings from graph graph1 to subgraph graph2with the optional initial mapping initialMapping. If no valid subgraph isomorphisms are found, an emptylist is returned.

isIsomorphic()Return True if graph graph1 is isomorphic to graph graph2 with the optional initial mapping initialMap-ping, or False otherwise.

isSubgraphIsomorphic()Return True if graph graph1 is subgraph isomorphic to subgraph graph2 with the optional initial mappinginitialMapping, or False otherwise.

rmgpy.molecule.Element

class rmgpy.molecule.ElementA chemical element. The attributes are:

Attribute Type Descriptionnumber int The atomic number of the elementsymbol str The symbol used for the elementname str The IUPAC name of the elementmass float The mass of the element in kg/molcovRadius float Covalent bond radius in Angstromisotope int The isotope integer of the element



This class is specifically for properties that all atoms of the same element share. Ideally there is only one instanceof this class for each element.

rmgpy.molecule.getElement()Return the Element object corresponding to the given parameter value. If an integer is provided, the value istreated as the atomic number. If a string is provided, the value is treated as the symbol. An ElementError israised if no matching element is found.

rmgpy.molecule.AtomType

class rmgpy.molecule.AtomTypeA class for internal representation of atom types. Using unique objects rather than strings allows us to use fastpointer comparisons instead of slow string comparisons, as well as store extra metadata. In particular, we storemetadata describing the atom type’s hierarchy with regard to other atom types, and the atom types that can resultwhen various actions involving this atom type are taken. The attributes are:

Malformed table. Text in column margin in table line 16.

=================== =================== ====================================Attribute Type Description=================== =================== ====================================`label` ``str`` A unique label for the atom type`generic` ``list`` The atom types that are more generic than this one`specific` ``list`` The atom types that are more specific than this oneìncrementBond` ``list`` The atom type(s) that result when an adjacent bond's order is incremented`decrementBond` ``list`` The atom type(s) that result when an adjacent bond's order is decremented`formBond` ``list`` The atom type(s) that result when a new single bond is formed to this atom type`breakBond` ``list`` The atom type(s) that result when an existing single bond to this atom type is brokenìncrementRadical` ``list`` The atom type(s) that result when the number of radical electrons is incremented`decrementRadical` ``list`` The atom type(s) that result when the number of radical electrons is decrementedìncrementLonePair` ``list`` The atom type(s) that result when the number of lone electron pairs is incremented`decrementLonePair` ``list`` The atom type(s) that result when the number of lone electron pairs is decremented

The following features are what are required in a given atomtype. Any int in the list is acceptable.An empty list is a wildcard'single' ''list'' The total number of single bonds on the atom'allDouble' ''list'' The total number of double bonds on the atom'rDouble' ''list'' The number of double bonds to any non-oxygen, nonsulfur'oDouble' ''list'' The number of double bonds to oxygen'sDouble' ''list'' The number of double bonds to sulfur'triple' ''list'' The total number of triple bonds on the atom'benzene' ''list'' The total number of benzene bonds on the atom'lonePairs' ''list'' The number of lone pairs on the atom=================== =================== ====================================

equivalent()Returns True if two atom types atomType1 and atomType2 are equivalent or False otherwise. Thisfunction respects wildcards, e.g. R!H is equivalent to C.

getFeatures()Returns a list of the features that are checked to determine atomtype

isSpecificCaseOf()Returns True if atom type atomType1 is a specific case of atom type atomType2 or False otherwise.

rmgpy.molecule.getAtomType()Determine the appropriate atom type for an Atom object atom with local bond structure bonds, a dict containingatom-bond pairs.



The atom type of an atom describes the atom itself and (often) something about the local bond structure aroundthat atom. This is a useful semantic tool for accelerating graph isomorphism queries, and a useful shorthand whenspecifying molecular substructure patterns via an RMG-style adjacency list.

We define the following basic atom types:

Atom type DescriptionGeneral atom typesR any atom with any local bond structureR!H any non-hydrogen atom with any local bond structureCarbon atom typesC carbon atom with any local bond structureCs carbon atom with four single bondsCd carbon atom with one double bond (to carbon) and two single bondsCdd carbon atom with two double bondsCt carbon atom with one triple bond and one single bondCO carbon atom with one double bond (to oxygen) and two single bondsCb carbon atom with two benzene bonds and one single bondCbf carbon atom with three benzene bondsHydrogen atom typesH hydrogen atom with one single bondOxygen atom typesO oxygen atom with any local bond structureOs oxygen atom with two single bondsOd oxygen atom with one double bondOa oxygen atom with no bondsSilicon atom typesSi silicon atom with any local bond structureSis silicon atom with four single bondsSid silicon atom with one double bond (to carbon) and two single bondsSidd silicon atom with two double bondsSit silicon atom with one triple bond and one single bondSiO silicon atom with one double bond (to oxygen) and two single bondsSib silicon atom with two benzene bonds and one single bondSibf silicon atom with three benzene bondsSulfur atom typesS sulfur atom with any local bond structureSs sulfur atom with two single bondsSd sulfur atom with one double bondSa sulfur atom with no bonds

Reaction recipes

A reaction recipe is a procedure for applying a reaction to a set of chemical species. Each reaction recipe is made upof a set of actions that, when applied sequentially, a set of chemical reactants to chemical products via that reaction’scharacteristic chemical process. Each action requires a small set of parameters in order to be fully defined.

We define the following reaction recipe actions:



Actionname

Arguments Action

CHANGE_BONDcenter1, order,center2

change the bond order of the bond between center1 and center2 byorder; do not break or form bonds

FORM_BONDcenter1, order,center2

form a new bond between center1 and center2 of type order

BREAK_BONDcenter1, order,center2

break the bond between center1 and center2, which should be oftype order

GAIN_RADICALcenter, radical increase the number of free electrons on center by radicalLOSE_RADICALcenter, radical decrease the number of free electrons on center by radical

rmgpy.molecule.Atom

class rmgpy.molecule.AtomAn atom. The attributes are:

Attribute Type DescriptionatomType AtomType The atom typeelement Element The chemical element the atom representsradicalElectrons short The number of radical electronscharge short The formal charge of the atomlabel str A string label that can be used to tag individual atomscoords numpy array The (x,y,z) coordinates in AngstromlonePairs short The number of lone electron pairs

Additionally, the mass, number, and symbol attributes of the atom’s element can be read (but not written)directly from the atom object, e.g. atom.symbol instead of atom.element.symbol.

applyAction()Update the atom pattern as a result of applying action, a tuple containing the name of the reaction recipeaction along with any required parameters. The available actions can be found here.

copy()Generate a deep copy of the current atom. Modifying the attributes of the copy will not affect the original.

decrementLonePairs()Update the lone electron pairs pattern as a result of applying a LOSE_PAIR action.

decrementRadical()Update the atom pattern as a result of applying a LOSE_RADICAL action, where radical specifies thenumber of radical electrons to remove.

equivalent()Return True if other is indistinguishable from this atom, or False otherwise. If other is an Atom object,then all attributes except label must match exactly. If other is an GroupAtom object, then the atom mustmatch any of the combinations in the atom pattern.

getBondOrdersForAtom()This helper function is to help calculate total bond orders for an input atom.

Some special consideration for the order B bond. For atoms having three B bonds, the order for each is4/3.0, while for atoms having other than three B bonds, the order for each is 3/2.0

incrementLonePairs()Update the lone electron pairs pattern as a result of applying a GAIN_PAIR action.

incrementRadical()Update the atom pattern as a result of applying a GAIN_RADICAL action, where radical specifies thenumber of radical electrons to add.



isCarbon()Return True if the atom represents a carbon atom or False if not.

isHydrogen()Return True if the atom represents a hydrogen atom or False if not.

isNitrogen()Return True if the atom represents a nitrogen atom or False if not.

isNonHydrogen()Return True if the atom does not represent a hydrogen atom or False if not.

isOxygen()Return True if the atom represents an oxygen atom or False if not.

isSilicon()Return True if the atom represents an silicon atom or False if not.

isSpecificCaseOf()Return True if self is a specific case of other, or False otherwise. If other is an Atom object, then this isthe same as the equivalent() method. If other is an GroupAtom object, then the atom must match orbe more specific than any of the combinations in the atom pattern.

isSulfur()Return True if the atom represents an sulfur atom or False if not.


setLonePairs()Set the number of lone electron pairs.

setSpinMultiplicity()Set the spin multiplicity.

updateCharge()Update self.charge, according to the valence, and the number and types of bonds, radicals, and lone pairs.

rmgpy.molecule.Bond

class rmgpy.molecule.BondA chemical bond. The attributes are:

Attribute Type Descriptionorder str The bond type

applyAction()Update the bond as a result of applying action, a tuple containing the name of the reaction recipe actionalong with any required parameters. The available actions can be found here.

copy()Generate a deep copy of the current bond. Modifying the attributes of the copy will not affect the original.

decrementOrder()Update the bond as a result of applying a CHANGE_BOND action to decrease the order by one.

equivalent()Return True if other is indistinguishable from this bond, or False otherwise. other can be either a Bondor a GroupBond object.




incrementOrder()Update the bond as a result of applying a CHANGE_BOND action to increase the order by one.

isBenzene()Return True if the bond represents a benzene bond or False if not.

isDouble()Return True if the bond represents a double bond or False if not.

isSingle()Return True if the bond represents a single bond or False if not.

isSpecificCaseOf()Return True if self is a specific case of other, or False otherwise. other can be either a Bond or aGroupBond object.

isTriple()Return True if the bond represents a triple bond or False if not.

Bond types

The bond type simply indicates the order of a chemical bond. We define the following bond types:

Bond type DescriptionS a single bondD a double bondT a triple bondB a benzene bond

rmgpy.molecule.Molecule

class rmgpy.molecule.MoleculeA representation of a molecular structure using a graph data type, extending the Graph class. The atoms andbonds attributes are aliases for the vertices and edges attributes. Other attributes are:

Attribute Type DescriptionsymmetryNumber int The (estimated) external + internal symmetry number of the moleculemultiplicity int The multiplicity of this species, multiplicity = 2*total_spin+1

A new molecule object can be easily instantiated by passing the SMILES or InChI string representing the molec-ular structure.

addAtom()Add an atom to the graph. The atom is initialized with no bonds.

addBond()Add a bond to the graph as an edge connecting the two atoms atom1 and atom2.





calculateCp0()Return the value of the heat capacity at zero temperature in J/mol*K.

calculateCpInf()Return the value of the heat capacity at infinite temperature in J/mol*K.

calculateSymmetryNumber()Return the symmetry number for the structure. The symmetry number includes both external and internalmodes.

clearLabeledAtoms()Remove the labels from all atoms in the molecule.

connectTheDots()Delete all bonds, and set them again based on the Atoms’ coords. Does not detect bond type.

containsLabeledAtom()Return True if the molecule contains an atom with the label label and False otherwise.


countInternalRotors()Determine the number of internal rotors in the structure. Any single bond not in a cycle and between twoatoms that also have other bonds are considered to be internal rotors.

deleteHydrogens()Irreversibly delete all non-labeled hydrogens without updating connectivity values. If there’s nothing buthydrogens, it does nothing. It destroys information; be careful with it.

draw()Generate a pictorial representation of the chemical graph using the draw module. Use path to specifythe file to save the generated image to; the image type is automatically determined by extension. Validextensions are .png, .svg, .pdf, and .ps; of these, the first is a raster format and the remainder arevector formats.

findIsomorphism()Returns True if other is isomorphic and False otherwise, and the matching mapping. The initialMapattribute can be used to specify a required mapping from self to other (i.e. the atoms of self are the keys,while the atoms of other are the values). The returned mapping also uses the atoms of self for the keysand the atoms of other for the values. The other parameter must be a Molecule object, or a TypeErroris raised.

findSubgraphIsomorphisms()Returns True if other is subgraph isomorphic and False otherwise. Also returns the lists all of validmappings. The initialMap attribute can be used to specify a required mapping from self to other (i.e. theatoms of self are the keys, while the atoms of other are the values). The returned mappings also use theatoms of self for the keys and the atoms of other for the values. The other parameter must be a Groupobject, or a TypeError is raised.

fromAdjacencyList()Convert a string adjacency list adjlist to a molecular structure. Skips the first line (assuming it’s a label)unless withLabel is False.

fromAugmentedInChI()Convert an Augmented InChI string aug_inchi to a molecular structure.

fromInChI()Convert an InChI string inchistr to a molecular structure.



fromSMARTS()Convert a SMARTS string smartsstr to a molecular structure. Uses RDKit to perform the conversion. ThisKekulizes everything, removing all aromatic atom types.

fromSMILES()Convert a SMILES string smilesstr to a molecular structure.

fromXYZ()Create an RMG molecule from a list of coordinates and a corresponding list of atomic numbers. Theseare typically received from CCLib and the molecule is sent to ConnectTheDots so will only contain singlebonds.




getBond()Returns the bond connecting atoms atom1 and atom2.

getBonds()Return a list of the bonds involving the specified atom.





getFingerprint()Return a string containing the “fingerprint” used to accelerate graph isomorphism comparisons with othermolecules. The fingerprint is a short string containing a summary of selected information about themolecule. Two fingerprint strings matching is a necessary (but not sufficient) condition for the associ-ated molecules to be isomorphic.

getFormula()Return the molecular formula for the molecule.

getLabeledAtom()Return the atoms in the molecule that are labeled.

getLabeledAtoms()Return the labeled atoms as a dict with the keys being the labels and the values the atoms themselves. Iftwo or more atoms have the same label, the value is converted to a list of these atoms.

getMolecularWeight()Return the molecular weight of the molecule in kg/mol.


getNetCharge()Iterate through the atoms in the structure and calculate the net charge on the overall molecule.


http://rdkit.org/


getNumAtoms()Return the number of atoms in molecule. If element is given, ie. “H” or “C”, the number of atoms of thatelement is returned.

getNumberOfRadicalElectrons()Return the total number of radical electrons on all atoms in the molecule. In this function, monoradicalatoms count as one, biradicals count as two, etc.


getRadicalAtoms()Return the atoms in the molecule that have unpaired electrons.

getRadicalCount()Return the number of unpaired electrons.



getSymmetryNumber()Returns the symmetry number of Molecule. First checks whether the value is stored as an attribute ofMolecule. If not, it calls the calculateSymmetryNumber method.

getURL()Get a URL to the molecule’s info page on the RMG website.

hasAtom()Returns True if atom is an atom in the graph, or False if not.

hasBond()Returns True if atoms atom1 and atom2 are connected by an bond, or False if not.



isAromatic()Returns True if the molecule is aromatic, or False if not. Iterates over the SSSR’s and searches forrings that consist solely of Cb atoms. Assumes that aromatic rings always consist of 6 atoms. In cases ofnaphthalene, where a 6 + 4 aromatic system exists, there will be at least one 6 membered aromatic ring sothis algorithm will not fail for fused aromatic rings.

isAtomInCycle()Return True if atom is in one or more cycles in the structure, and False if not.

isBondInCycle()Return True if the bond between atoms atom1 and atom2 is in one or more cycles in the graph, or Falseif not.





isIsomorphic()Returns True if two graphs are isomorphic and False otherwise. The initialMap attribute can be used tospecify a required mapping from self to other (i.e. the atoms of self are the keys, while the atoms of otherare the values). The other parameter must be a Molecule object, or a TypeError is raised. Also ensuresmultiplicities are also equal.

isLinear()Return True if the structure is linear and False otherwise.


isRadical()Return True if the molecule contains at least one radical electron, or False otherwise.

isSubgraphIsomorphic()Returns True if other is subgraph isomorphic and False otherwise. The initialMap attribute can be usedto specify a required mapping from self to other (i.e. the atoms of self are the keys, while the atoms ofother are the values). The other parameter must be a Group object, or a TypeError is raised.


is_equal()Method to test equality of two Molecule objects.

merge()Merge two molecules so as to store them in a single Molecule object. The merged Molecule object isreturned.

removeAtom()Remove atom and all bonds associated with it from the graph. Does not remove atoms that no longer haveany bonds as a result of this removal.

removeBond()Remove the bond between atoms atom1 and atom2 from the graph. Does not remove atoms that no longerhave any bonds as a result of this removal.




saturate()Saturate the molecule by replacing all radicals with bonds to hydrogen atoms. Changes self moleculeobject.

sortAtoms()Sort the atoms in the graph. This can make certain operations, e.g. the isomorphism functions, much moreefficient.




split()Convert a single Molecule object containing two or more unconnected molecules into separateclass:Molecule objects.

toAdjacencyList()Convert the molecular structure to a string adjacency list.

toAugmentedInChI()Adds an extra layer to the InChI denoting the multiplicity of the molecule.

Separate layer with a forward slash character.

toAugmentedInChIKey()Adds an extra layer to the InChIKey denoting the multiplicity of the molecule.

Simply append the multiplicity string, do not separate by a character like forward slash.

toGroup()This method converts a list of atoms in a Molecule to a Group object.

toInChI()Convert a molecular structure to an InChI string. Uses RDKit to perform the conversion. Perceives aro-maticity.

or

Convert a molecular structure to an InChI string. Uses OpenBabel to perform the conversion.

toInChIKey()Convert a molecular structure to an InChI Key string. Uses OpenBabel to perform the conversion.

or

Convert a molecular structure to an InChI Key string. Uses RDKit to perform the conversion.

Removes check-sum dash (-) and character so that only the 14 + 9 characters remain.

toRDKitMol()Convert a molecular structure to a RDKit rdmol object.

toSMARTS()Convert a molecular structure to an SMARTS string. Uses RDKit to perform the conversion. Perceivesaromaticity and removes Hydrogen atoms.

toSMILES()Convert a molecular structure to an SMILES string.

If there is a Nitrogen atom present it uses OpenBabel to perform the conversion, and the SMILES may ormay not be canonical.

Otherwise, it uses RDKit to perform the conversion, so it will be canonical SMILES. While converting toan RDMolecule it will perceive aromaticity and removes Hydrogen atoms.

toSingleBonds()Returns a copy of the current molecule, consisting of only single bonds.

This is useful for isomorphism comparison against something that was made via fromXYZ, which doesnot attempt to perceive bond orders


http://rdkit.org/

http://openbabel.org/


http://rdkit.org/

http://rdkit.org/


http://rdkit.org/


update()Update connectivity values, atom types of atoms. Update multiplicity, and sort atoms using the newconnectivity values.

updateAtomTypes()Iterate through the atoms in the structure, checking their atom types to ensure they are correct (i.e. accu-rately describe their local bond environment) and complete (i.e. are as detailed as possible).


updateLonePairs()Iterate through the atoms in the structure and calculate the number of lone electron pairs, assuming aneutral molecule.

updateMultiplicity()Update the multiplicity of a newly formed molecule.

rmgpy.molecule.GroupAtom

class rmgpy.molecule.GroupAtomAn atom group. This class is based on the Atom class, except that it uses atom types instead of elements, and allattributes are lists rather than individual values. The attributes are:

Attribute Type DescriptionatomType list The allowed atom types (as AtomType objects)radicalElectrons list The allowed numbers of radical electrons (as short integers)charge list The allowed formal charges (as short integers)label str A string label that can be used to tag individual atomslonePairs list The number of lone electron pairs

Each list represents a logical OR construct, i.e. an atom will match the group if it matches any item in the list.However, the radicalElectrons, and charge attributes are linked such that an atom must match values from thesame index in each of these in order to match.

applyAction()Update the atom group as a result of applying action, a tuple containing the name of the reaction recipeaction along with any required parameters. The available actions can be found here.

copy()Return a deep copy of the GroupAtom object. Modifying the attributes of the copy will not affect theoriginal.

equivalent()Returns True if other is equivalent to self or False if not, where other can be either an Atom or anGroupAtom object. When comparing two GroupAtom objects, this function respects wildcards, e.g. R!His equivalent to C.

isOxygen()Return True if the atom represents an oxygen atom or False if not.

isSpecificCaseOf()Returns True if other is the same as self or is a more specific case of self. Returns False if some of selfis not included in other or they are mutually exclusive.

isSulfur()Return True if the atom represents an sulfur atom or False if not.




rmgpy.molecule.GroupBond

class rmgpy.molecule.GroupBondA bond group. This class is based on the Bond class, except that all attributes are lists rather than individualvalues. The allowed bond types are given here. The attributes are:

Attribute Type Descriptionorder list The allowed bond orders (as character strings)

Each list represents a logical OR construct, i.e. a bond will match the group if it matches any item in the list.

applyAction()Update the bond group as a result of applying action, a tuple containing the name of the reaction recipeaction along with any required parameters. The available actions can be found here.

copy()Return a deep copy of the GroupBond object. Modifying the attributes of the copy will not affect theoriginal.

equivalent()Returns True if other is equivalent to self or False if not, where other can be either an Bond or anGroupBond object.


isBenzene()Return True if the bond represents a benzene bond or False if not. Bonds with any wildcards will returnFalse.

isDouble()Return True if the bond represents a double bond or False if not. Bonds with any wildcards will returnFalse.

isSingle()Return True if the bond represents a single bond or False if not. Bonds with any wildcards will returnFalse.

isSpecificCaseOf()Returns True if other is the same as self or is a more specific case of self. Returns False if some of selfis not included in other or they are mutually exclusive.

isTriple()Return True if the bond represents a triple bond or False if not. Bonds with any wildcards will returnFalse.

rmgpy.molecule.Group

class rmgpy.molecule.GroupA representation of a molecular substructure group using a graph data type, extending the Graph class.The atoms and bonds attributes are aliases for the vertices and edges attributes, and store GroupAtom andGroupBond objects, respectively. Corresponding alias methods have also been provided.

addAtom()Add an atom to the graph. The atom is initialized with no bonds.



addBond()Add a bond to the graph as an edge connecting the two atoms atom1 and atom2.


addExplicitLigands()This function Od/Sd ligand to CO or CS atomtypes if they are not already there.

Returns a ‘True’ if the group was modified otherwise returns ‘False’


clearLabeledAtoms()Remove the labels from all atoms in the molecular group.

containsLabeledAtom()Return True if the group contains an atom with the label label and False otherwise.


findIsomorphism()Returns True if other is isomorphic and False otherwise, and the matching mapping. The initialMapattribute can be used to specify a required mapping from self to other (i.e. the atoms of self are the keys,while the atoms of other are the values). The returned mapping also uses the atoms of self for the keys andthe atoms of other for the values. The other parameter must be a Group object, or a TypeError is raised.

findSubgraphIsomorphisms()Returns True if other is subgraph isomorphic and False otherwise. In other words, return True is self ismore specific than other. Also returns the lists all of valid mappings. The initialMap attribute can be usedto specify a required mapping from self to other (i.e. the atoms of self are the keys, while the atoms ofother are the values). The returned mappings also use the atoms of self for the keys and the atoms of otherfor the values. The other parameter must be a Group object, or a TypeError is raised.

fromAdjacencyList()Convert a string adjacency list adjlist to a molecular structure. Skips the first line (assuming it’s a label)unless withLabel is False.




getBond()Returns the bond connecting atoms atom1 and atom2.

getBonds()Return a list of the bonds involving the specified atom.







getLabeledAtom()Return the atom in the group that is labeled with the given label. Raises ValueError if no atom in thegroup has that label.

getLabeledAtoms()Return the labeled atoms as a dict with the keys being the labels and the values the atoms themselves. Iftwo or more atoms have the same label, the value is converted to a list of these atoms.





hasAtom()Returns True if atom is an atom in the graph, or False if not.

hasBond()Returns True if atoms atom1 and atom2 are connected by an bond, or False if not.





isIdentical()Returns True if other is identical and False otherwise. The function isIsomorphic respects wildcards,while this function does not, make it more useful for checking groups to groups (as opposed to moleculesto groups)

isIsomorphic()Returns True if two graphs are isomorphic and False otherwise. The initialMap attribute can be used tospecify a required mapping from self to other (i.e. the atoms of self are the keys, while the atoms of otherare the values). The other parameter must be a Group object, or a TypeError is raised.




isSubgraphIsomorphic()Returns True if other is subgraph isomorphic and False otherwise. In other words, return True if selfis more specific than other. The initialMap attribute can be used to specify a required mapping from selfto other (i.e. the atoms of self are the keys, while the atoms of other are the values). The other parametermust be a Group object, or a TypeError is raised.


merge()Merge two groups so as to store them in a single Group object. The merged Group object is returned.

removeAtom()Remove atom and all bonds associated with it from the graph. Does not remove atoms that no longer haveany bonds as a result of this removal.

removeBond()Remove the bond between atoms atom1 and atom2 from the graph. Does not remove atoms that no longerhave any bonds as a result of this removal.




sortAtoms()Sort the atoms in the graph. This can make certain operations, e.g. the isomorphism functions, much moreefficient.


split()Convert a single Group object containing two or more unconnected groups into separate class:Groupobjects.

standardizeAtomType()This function changes the atomTypes in a group if the atom must be a specific atomType based on its bondsand valency.

Currently only standardizes oxygen, carbon and sulfur atomTypes

We also only check when there is exactly one atomType, one bondType, one radical setting. For any groupwhere there are wildcards or multiple attributes, we cannot apply this check.

In the case where the atomType is ambigious based on bonds and valency, this function will not changethe type.




standardizeGroup()This function modifies groups to make them have a standard AdjList form.

Currently it makes atomtypes as specific as possible and makes CO/CS atomtypes have explicit Od/Sdligands. Other functions can be added as necessary

We also only check when there is exactly one atomType, one bondType, one radical setting. For any groupwhere there are wildcards or multiple attributes, we do not apply this check.


toAdjacencyList()Convert the molecular structure to a string adjacency list.


updateFingerprint()Update the molecular fingerprint used to accelerate the subgraph isomorphism checks.

Adjacency Lists

Note: The adjacency list syntax changed in July 2014. The minimal requirement for most translations is to prefix thenumber of unpaired electrons with the letter u. The new syntax, however, allows much greater flexibility, includingdefinition of lone pairs, partial charges, wildcards, and molecule multiplicities.

Note: To quickly visualize any adjacency list, or to generate an adjacency list from other types of molecular rep-resentations such as SMILES, InChI, or even common species names, use the Molecule Search tool found here:http://rmg.mit.edu/molecule_search

An adjacency list is the most general way of specifying a chemical molecule or molecular pattern in RMG. It is basedon the adjacency list representation of the graph data type – the underlying data type for molecules and patterns inRMG – but extended to allow for specification of extra semantic information.

The first line of most adjacency lists is a unique identifier for the molecule or pattern the adjacency list represents.This is not strictly required, but is recommended in most cases. Generally the identifier should only use alphanumericcharacters and the underscore, as if an identifier in many popular programming languages. However, strictly speakingany non-space ASCII character is allowed.

The subsequent lines may contain keyword-value pairs. Currently there is only one keyword, multiplicity.

For species or molecule declarations, the value after multiplicity defines the spin multiplicity of the molecule.E.g. multiplicity 1 for most ground state closed shell species, multiplicity 2 for most radical species, andmultiplicity 3 for a triplet biradical. If the multiplicity line is not present then a value of (1 + number ofunpaired electrons) is assumed. Thus, it can usually be omitted, but if present can be used to distinguish, for example,singlet CH2 from triplet CH2.

If defining a Functional Group, then the value must be a list, which defines the multiplicities that will be matched bythe group, eg. multiplicity [1,2,3] or, for a single value, multiplicity [1]. If a wildcard is desired, theline ’multiplicity x can be used instead to accept all multiplicities. If the multiplicity line is omitted altogether,then a wildcard is assumed.

e.g. the following two group adjlists represent identical groups.


http://rmg.mit.edu/molecule_search


group1multiplicity x1 R!H u0

group21 R!H u0

After the identifier line and keyword-value lines, each subsequent line describes a single atom and its local bondstructure. The format of these lines is a whitespace-delimited list with tokens

<number> [<label>] <element> u<unpaired> [p<pairs>] [c<charge>] <bondlist>

The first item is the number used to identify that atom. Any number may be used, though it is recommended to numberthe atoms sequentially starting from one. Next is an optional label used to tag that atom; this should be an asteriskfollowed by a unique number for the label, e.g. *1. In some cases (e.g. thermodynamics groups) there is only onelabeled atom, and the label is just an asterisk with no number: *.

After that is the atom’s element or atom type, indicated by its atomic symbol, followed by a sequence of tokensdescribing the electronic state of the atom:

• u0 number of unpaired electrons (eg. radicals)

• p0 number of lone pairs of electrons, common on oxygen and nitrogen.

• c0 formal charge on the atom, e.g. c-1 (negatively charged), c0, c+1 (positively charged)

For Molecule definitions: The value must be a single integer (and for charge must have a + or - sign if not equal to0) The number of unpaired electrons (i.e. radical electrons) is required, even if zero. The number of lone pairs and theformal charge are assumed to be zero if omitted.

For Group definitions: The value can be an integer or a list of integers (with signs, for charges), eg. u[0,1,2] orc[0,+1,+2,+3,+4], or may be a wildcard x which matches any valid value, eg. px is the same as p[0,1,2,3,4,...] and cx is the same as c[...,-4,-3,-2,-1,0,+1,+2,+3,+4,...]. Lists must be enclosed is square brack-ets, and separated by commas, without spaces. If lone pairs or formal charges are omitted from a group definition, thewildcard is assumed.

The last set of tokens is the list of bonds. To indicate a bond, place the number of the atom at the other end of the bondand the bond type within curly braces and separated by a comma, e.g. {2,S}. Multiple bonds from the same atomshould be separated by whitespace.

Note: You must take care to make sure each bond is listed on the lines of both atoms in the bond, and that theseentries have the same bond type. RMG will raise an exception if it encounters such an invalid adjacency list.

When writing a molecular substructure pattern, you may specify multiple elements, radical counts, and bond types asa comma-separated list inside square brackets. For example, to specify any carbon or oxygen atom, use the syntax[C,O]. For a single or double bond to atom 2, write {2,[S,D]}.

Atom types such as R!H or Cdd may also be used as a shorthand. (Atom types like Cdd can also be used in fullmolecules, but this use is discouraged, as RMG can compute them automatically for full molecules.)

Below is an example adjacency list, for 1,3-hexadiene, with the weakest bond in the molecule labeled with *1 and*2. Note that hydrogen atoms can be omitted if desired, as their presence is inferred, provided that unpaired electrons,lone pairs, and charges are all correctly defined:

HXD13multiplicity 11 C u0 {2,D}2 C u0 {1,D} {3,S}3 C u0 {2,S} {4,D}



4 C u0 {3,D} {5,S}5 *1 C u0 {4,S} {6,S}6 *2 C u0 {5,S}

The allowed element types, radicals, and bonds are listed in the following table:

Notation Explanation

Chemical Element

C Carbon atomO Oxygen atomH Hydrogen atomS Sulfur atomN Nitrogen atom

Nonreactive Elements

Si Silicon atomCl Chlorine atomHe Helium atomAr Argon atom

Chemical Bond

S Single BondD Double BondT Triple bondB Benzene bond

rmgpy.molecule.adjlist.fromAdjacencyList(adjlist, group=False, saturateH=False)Convert a string adjacency list adjlist into a set of Atom and Bond objects.

rmgpy.molecule.adjlist.toAdjacencyList(atoms, multiplicity, label=None, group=False, re-moveH=False, removeLonePairs=False, oldStyle=False)

Convert a chemical graph defined by a list of atoms into a string adjacency list.

rmgpy.molecule.symmetry

rmgpy.molecule.symmetry.calculateAtomSymmetryNumber()Return the symmetry number centered at atom in the structure. The atom of interest must not be in a cycle.

rmgpy.molecule.symmetry.calculateBondSymmetryNumber()Return the symmetry number centered at bond in the structure.

rmgpy.molecule.symmetry.calculateAxisSymmetryNumber()Get the axis symmetry number correction. The “axis” refers to a series of two or more cumulated double bonds(e.g. C=C=C, etc.). Corrections for single C=C bonds are handled in getBondSymmetryNumber().

Each axis (C=C=C) has the potential to double the symmetry number. If an end has 0 or 1 groups (eg. =C=CJJor =C=C-R) then it cannot alter the axis symmetry and is disregarded:

A=C=C=C.. A-C=C=C=C-A

s=1 s=1

If an end has 2 groups that are different then it breaks the symmetry and the symmetry for that axis is 1, nomatter what’s at the other end:

A\ A\ /AT=C=C=C=C-A T=C=C=C=T

B/ A/ \Bs=1 s=1

If you have one or more ends with 2 groups, and neither end breaks the symmetry, then you have an axissymmetry number of 2:



A\ /B A\C=C=C=C=C C=C=C=C-B

A/ \B A/s=2 s=2

rmgpy.molecule.symmetry.calculateCyclicSymmetryNumber()Get the symmetry number correction for cyclic regions of a molecule. For complicated fused rings the smallestset of smallest rings is used.

rmgpy.molecule.symmetry.calculateSymmetryNumber()Return the symmetry number for the structure. The symmetry number includes both external and internal modes.

rmgpy.molecule.draw.MoleculeDrawer

class rmgpy.molecule.draw.MoleculeDrawer(options=None)This class provides functionality for drawing the skeletal formula of molecules using the Cairo 2D graphicsengine. The most common use case is simply:

MoleculeDrawer().draw(molecule, format='png', path='molecule.png')

where molecule is the Molecule object to draw. You can also pass a dict of options to the constructor to affecthow the molecules are drawn.

draw(molecule, format, path=None)Draw the given molecule using the given image format - pdf, svg, ps, or png. If path is given, the drawingis saved to that location on disk. The options dict is an optional set of key-value pairs that can be used tocontrol the generated drawing.

This function returns the Cairo surface and context used to create the drawing, as well as a bounding boxfor the molecule being drawn as the tuple (left, top, width, height).

render(cr, offset=None)Uses the Cairo graphics library to create a skeletal formula drawing of a molecule containing the list ofatoms and dict of bonds to be drawn. The 2D position of each atom in atoms is given in the coordinatesarray. The symbols to use at each atomic position are given by the list symbols. You must specify the Cairocontext cr to render to.

rmgpy.molecule.draw.ReactionDrawer

class rmgpy.molecule.draw.ReactionDrawer(options=None)This class provides functionality for drawing chemical reactions using the skeletal formula of each reactant andproduct molecule via the Cairo 2D graphics engine. The most common use case is simply:

ReactionDrawer().draw(reaction, format='png', path='reaction.png')

where reaction is the Reaction object to draw. You can also pass a dict of options to the constructor to affecthow the molecules are drawn.

draw(reaction, format, path=None)Draw the given reaction using the given image format - pdf, svg, ps, or png. If path is given, the drawingis saved to that location on disk.

This function returns the Cairo surface and context used to create the drawing, as well as a bounding boxfor the molecule being drawn as the tuple (left, top, width, height).



1.7 Pressure dependence (rmgpy.pdep)

The rmgpy.pdep subpackage provides functionality for calcuating the pressure-dependent rate coefficients k(T, P )for unimolecular reaction networks.

A unimolecular reaction network is defined by a set of chemically reactive molecular configurations - local minima ona potential energy surface - divided into unimolecular isomers and bimolecular reactants or products. In our vernacular,reactants can associate to form an isomer, while such association is neglected for products. These configurations areconnected by chemical reactions to form a network; these are referred to as path reactions. The system also consists ofan excess of inert gas M, representing a thermal bath; this allows for neglecting all collisions other than those betweenan isomer and the bath gas.

An isomer molecule at sufficiently high internal energy can be transformed by a number of possible events:

• The isomer molecule can collide with any other molecule, resulting in an increase or decrease in energy

• The isomer molecule can isomerize to an adjacent isomer at the same energy

• The isomer molecule can dissociate into any directly connected bimolecular reactant or product channel

It is this competition between collision and reaction events that gives rise to pressure-dependent kinetics.

1.7.1 Collision events

Class DescriptionSingleExponentialDown A collisional energy transfer model based on the single exponential down model

1.7.2 Reaction events

Function DescriptioncalculateMicrocanonicalRateCoefficient()Return the microcanonical rate coefficient k(E) for a reactionapplyRRKMTheory() Use RRKM theory to compute k(E) for a reactionapplyInverseLaplaceTransformMethod() Use the inverse Laplace transform method to compute k(E) for

a reaction

1.7.3 Pressure-dependent reaction networks

Class DescriptionConfiguration A molecular configuration on a potential energy surfaceNetwork A collisional energy transfer model based on the single exponential down model

1.7.4 The master equation

Function DescriptiongenerateFullMEMatrix() Return the full master equation matrix for a network



1.7.5 Master equation reduction methods

Function Descriptionmsc.applyModifiedStrongCollisionMethod()Reduce the master equation to phenomenological rate coefficients

k(T, P ) using the modified strong collision methodrs.applyReservoirStateMethod() Reduce the master equation to phenomenological rate coefficients

k(T, P ) using the reservoir state methodcse.applyChemicallySignificantEigenvaluesMethod()Reduce the master equation to phenomenological rate coefficients

k(T, P ) using the chemically-significant eigenvalues method

1.7.6 Exceptions

Exception DescriptionNetworkError Raised when an error occurs while working with a pressure-dependent

reaction networkInvalidMicrocanonicalRateErrorRaised when the k(E) is not consistent with the high pressure-limit kinetics

or thermodynamics

rmgpy.pdep.SingleExponentialDown

class rmgpy.pdep.SingleExponentialDown(alpha0=None, T0=None, n=0.0)A representation of a single exponential down model of collisional energy transfer. The attributes are:

Attribute Descriptionalpha0 The average energy transferred in a deactivating collision at the reference temperatureT0 The reference temperaturen The temperature exponent

Based around the collisional energy transfer probability function

P (E,E′) = C(E′) exp

(−E

′ − Eα

)E < E′

where the parameter α = 〈∆Ed〉 represents the average energy transferred in a deactivating collision. This is themost commonly-used collision model, simply because it only has one parameter to determine. The parameter αis specified using the equation

α = α0

(T

T0

)nwhere α0 is the value of α at temperature T0 in K. Set the exponent n to zero to obtain a temperature-independentvalue for α.

T0The reference temperature.

alpha0The average energy transferred in a deactivating collision at the reference temperature.

calculateCollisionEfficiency(self, double T, ndarray Elist, ndarray Jlist, ndarray densStates,double E0, double Ereac)

Calculate an efficiency factor for collisions, particularly useful for the modified strong collision method.The collisions involve the given species with density of states densStates corresponding to energies Elist‘ inJ/mol, ground-state energy E0 in kJ/mol, and first reactive energy Ereac in kJ/mol. The collisions occur attemperature T in K and are described by the average energy transferred in a deactivating collision dEdownin kJ/mol. The algorithm here is implemented as described by Chang, Bozzelli, and Dean [Chang2000].

1.7. Pressure dependence (rmgpy.pdep) 109


generateCollisionMatrix(self, double T, ndarray densStates, ndarray Elist, ndarray Jlist=None)Generate and return the collision matrix Mcoll/ω = P − I corresponding to this collision model for agiven set of energies Elist in J/mol, temperature T in K, and isomer density of states densStates.

getAlpha(self, double T)→ doubleReturn the value of the α parameter - the average energy transferred in a deactivating collision - in J/molat temperature T in K.

nn: ‘double’

Reaction events

Microcanonical rate coefficients

rmgpy.pdep.calculateMicrocanonicalRateCoefficient(reaction, ndarray Elist, ndarray Jlist,ndarray reacDensStates, ndarray prod-DensStates=None, double T=0.0)

Calculate the microcanonical rate coefficient k(E) for the reaction reaction at the energies Elist in J/mol. reac-DensStates and prodDensStates are the densities of states of the reactant and product configurations for thisreaction. If the reaction is irreversible, only the reactant density of states is required; if the reaction is reversible,then both are required. This function will try to use the best method that it can based on the input data available:

•If detailed information has been provided for the transition state (i.e. the molecular degrees of freedom),then RRKM theory will be used.

•If the above is not possible but high-pressure limit kinetics k∞(T ) have been provided, then the inverseLaplace transform method will be used.

The density of states for the product prodDensStates and the temperature of interest T in K can also be provided.For isomerization and association reactions prodDensStates is required; for dissociation reactions it is optional.The temperature is used if provided in the detailed balance expression to determine the reverse kinetics, and incertain cases in the inverse Laplace transform method.

RRKM theory

rmgpy.pdep.applyRRKMTheory(transitionState, ndarray Elist, ndarray Jlist, ndarray densStates)Calculate the microcanonical rate coefficient for a reaction using RRKM theory, where transitionState is thetransition state of the reaction, Elist is the array of energies in J/mol at which to evaluate the microcanonial rate,and densStates is the density of states of the reactant.

RRKM (Rice-Ramsperger-Kassel-Marcus) theory is the microcanonical analogue of transition state theory. Themicrocanonical rate coefficient as a function of total energy E and total angular momentum quantum number Jis given by

k(E, J) =N‡(E, J)

hρ(E, J)

where N‡(E, J) is the sum of states of the transition state and ρ(E, J) is the density of states of the reactant. Ifthe J-rotor is treated as active, the J-dependence can be averaged in the above expression to give

k(E) =N‡(E)

hρ(E)

as a function of total energy alone. This is reasonable at high temperatures, but less accurate at low temperatures.

Use of RRKM theory requires detailed information about the statistical mechanics of the reactant and transitionstate. However, it is generally more accurate than the inverse Laplace transform method.



Inverse Laplace transform method

rmgpy.pdep.applyInverseLaplaceTransformMethod(transitionState, Arrhenius kinetics, ndarray Elist,ndarray Jlist, ndarray densStates, double T=0.0)

Calculate the microcanonical rate coefficient for a reaction using the inverse Laplace transform method, wherekinetics is the high pressure limit rate coefficient, E0 is the ground-state energy of the transition state, Elist is thearray of energies in kJ/mol at which to evaluate the microcanonial rate, and densStates is the density of statesof the reactant. The temperature T in K is not required, and is only used when the temperature exponent of theArrhenius expression is negative (for which the inverse transform is undefined).

The inverse Laplace transform method exploits the following relationship to determine the microcanonical ratecoefficient:

L [k(E)ρ(E)] =

∫ ∞0

k(E)ρ(E)e−E/kBT dE = k∞(T )Q(T )

Given a high-pressure limit rate coefficient k∞(T ) represented as an Arrhenius expression with positive n andEa, the microcanonical rate coefficient k(E) can be determined via an inverse Laplace transform. For n = 0the transform can be defined analytically:

k(E) = Aρ(E − Ea)

ρ(E)(n = 0)

For n > 0 the transform is defined numerically. For n < 0 or Ea < 0 the transform is not defined; in this casewe approximate by simply lumping the Tn or e−Ea/RT terms into the preexponential factor, and use a differentk(E) at each temperature.

The ILT method does not required detailed transition state information, but only the high-pressure limit kinet-ics. However, it assumes that (1) k∞(T ) is valid over the temperature range from zero to infinity and (2) theactivation energy Ea is physically identical to the reaction barrier E‡0 − E0.

rmgpy.pdep.Configuration

class rmgpy.pdep.ConfigurationA representation of a molecular configuration on a potential energy surface.

E0The ground-state energy of the configuration in J/mol.

calculateCollisionFrequency()Return the value of the collision frequency in Hz at the given temperature T in K and pressure P in Pa. If adictionary bathGas of bath gas species and corresponding mole fractions is given, the collision parametersof the bas gas species will be averaged with those of the species before computing the collision frequency.

Only the Lennard-Jones collision model is currently supported.

calculateDensityOfStates()Calculate the density (and sum) of states for the configuration at the given energies above the ground stateElist in J/mol. The activeJRotor and activeKRotor flags control whether the J-rotor and/or K-rotor aretreated as active (and therefore included in the density and sum of states). The computed density and sumof states arrays are stored on the object for future use.

cleanup()Delete intermediate arrays used in computing k(T,P) values.

generateCollisionMatrix()Return the collisional energy transfer probabilities matrix for the configuration at the given temperatureT in K using the given energies Elist in kJ/mol and total angular momentum quantum numbers Jlist. Thedensity of states of the configuration densStates in mol/kJ is also required.



getEnthalpy()Return the enthalpy in kJ/mol at the specified temperature T in K.

getEntropy()Return the entropy in J/mol*K at the specified temperature T in K.

getFreeEnergy()Return the Gibbs free energy in kJ/mol at the specified temperature T in K.

getHeatCapacity()Return the constant-pressure heat capacity in J/mol*K at the specified temperature T in K.

hasStatMech()Return True if all species in the configuration have statistical mechanics parameters, or False otherwise.

hasThermo()Return True if all species in the configuration have thermodynamics parameters, or False otherwise.

isBimolecular()Return True if the configuration represents a bimolecular reactant or product channel, or False otherwise.

isTransitionState()Return True if the configuration represents a transition state, or False otherwise.

isUnimolecular()Return True if the configuration represents a unimolecular isomer, or False otherwise.

mapDensityOfStates()Return a mapping of the density of states for the configuration to the given energies Elist in J/mol and, ifthe J-rotor is not active, the total angular momentum quantum numbers Jlist.

mapSumOfStates()Return a mapping of the density of states for the configuration to the given energies Elist in J/mol and, ifthe J-rotor is not active, the total angular momentum quantum numbers Jlist.

rmgpy.pdep.Network

class rmgpy.pdep.Network(label=’‘, isomers=None, reactants=None, products=None, pathReac-tions=None, bathGas=None)

A representation of a unimolecular reaction network. The attributes are:



Attribute Descriptionisomers A list of the unimolecular isomers in the networkreactants A list of the bimolecular reactant channels in the networkproducts A list of the bimolecular product channels in the networkpathReactions A list of “path” reaction objects that connect adjacent isomers (the high-pressure-limit)bathGas A dictionary of the bath gas species (keys) and their mole fractions (values)netReactions A list of “net” reaction objects that connect any pair of isomersT The current temperature in KP The current pressure in barElist The current array of energy grains in kJ/molJlist The current array of total angular momentum quantum numbersNisom The number of unimolecular isomers in the networkNreac The number of bimolecular reactant channels in the networkNprod The number of bimolecular product channels in the networkNgrains The number of energy grainsNJ The number of angular momentum grainsactiveKRotor True if the K-rotor is treated as active, False if treated as adiabaticactiveJRotor True if the J-rotor is treated as active, False if treated as adiabaticrmgmode True if in RMG mode, False otherwise

applyChemicallySignificantEigenvaluesMethod(lumpingOrder=None)Compute the phenomenological rate coefficients k(T, P ) at the current conditions using the chemically-significant eigenvalues method. If a lumpingOrder is provided, the algorithm will attempt to lump theconfigurations (given by index) in the order provided, and return a reduced set of k(T, P ) values.

applyModifiedStrongCollisionMethod(efficiencyModel=’default’)Compute the phenomenological rate coefficients k(T, P ) at the current conditions using the modifiedstrong collision method.

applyReservoirStateMethod()Compute the phenomenological rate coefficients k(T, P ) at the current conditions using the reservoir statemethod.

calculateCollisionModel()Calculate the matrix of first-order rate coefficients for collisional population transfer between grains foreach isomer, including the corresponding collision frequencies.

calculateDensitiesOfStates()Calculate the densities of states of each configuration that has states data. The densities of states arecomputed such that they can be applied to each temperature in the range of interest by interpolation.

calculateEquilibriumRatios()Return an array containing the fraction of each isomer and reactant channel present at equilibrium, asdetermined from the Gibbs free energy and using the concentration equilibrium constant Kc. These valuesare ratios, and the absolute magnitude is not guaranteed; however, the implementation scales the elementsof the array so that they sum to unity.

calculateMicrocanonicalRates()Calculate and return arrays containing the microcanonical rate coefficients k(E) for the isomerization,dissociation, and association path reactions in the network.

getAllSpecies()Return a list of all unique species in the network, including all isomers, reactant and product channels, andbath gas species.

initialize(Tmin, Tmax, Pmin, Pmax, maximumGrainSize=0.0, minimumGrainCount=0, activeJRo-tor=True, activeKRotor=True, rmgmode=False)

Initialize a pressure dependence calculation by computing several quantities that are independent of the



conditions. You must specify the temperature and pressure ranges of interesting using Tmin and Tmax inK and Pmin and Pmax in Pa. You must also specify the maximum energy grain size grainSize in J/moland/or the minimum number of grains grainCount.

invalidate()Mark the network as in need of a new calculation to determine the pressure-dependent rate coefficients

mapDensitiesOfStates()Map the overall densities of states to the current energy grains. Semi-logarithmic interpolation will beused if the grain sizes of Elist0 and Elist do not match; this should not be a significant source of error aslong as the grain sizes are sufficiently small.

printSummary(level=20)Print a formatted list of information about the current network. Each molecular configuration - unimolec-ular isomers, bimolecular reactant channels, and bimolecular product channels - is given along with itsenergy on the potential energy surface. The path reactions connecting adjacent molecular configurationsare also given, along with their energies on the potential energy surface. The level parameter controls thelevel of logging to which the summary is written, and is DEBUG by default.

selectEnergyGrains(T, grainSize=0.0, grainCount=0)Select a suitable list of energies to use for subsequent calculations. This is done by finding the minimumand maximum energies on the potential energy surface, then adding a multiple of kBT onto the maximumenergy.

You must specify either the desired grain spacing grainSize in J/mol or the desired number of grainsNgrains, as well as a temperature T in K to use for the equilibrium calculation. You can specify bothgrainSize and grainCount, in which case the one that gives the more accurate result will be used (i.e. theyrepresent a maximum grain size and a minimum number of grains). An array containing the energy grainsin J/mol is returned.

setConditions(T, P, ymB=None)Set the current network conditions to the temperature T in K and pressure P in Pa. All of the internalvariables are updated accordingly if they are out of date. For example, those variables that depend only ontemperature will not be recomputed if the temperature is the same.

solveFullME(tlist, x0)Directly solve the full master equation using a stiff ODE solver. Pass the reaction network to solve, thetemperature T in K and pressure P in Pa to solve at, the energies Elist in J/mol to use, the output time pointstlist in s, the initial total populations x0, the full master equation matrix M, the accounting matrix indicesrelating isomer and energy grain indices to indices of the master equation matrix, and the densities of statesdensStates in mol/J of each isomer. Returns the times in s, population distributions for each isomer, andtotal population profiles for each configuration.

solveReducedME(tlist, x0)Directly solve the reduced master equation using a stiff ODE solver. Pass the output time points tlist in sand the initial total populations x0. Be sure to run one of the methods for generating k(T, P ) values beforecalling this method. Returns the times in s, population distributions for each isomer, and total populationprofiles for each configuration.

The master equation

rmgpy.pdep.me.generateFullMEMatrix()Generate the full master equation matrix for the network.

Throughout this document we will utilize the following terminology:

• An isomer is a unimolecular configuration on the potential energy surface.



• A reactant channel is a bimolecular configuration that associates to form an isomer. Dissociation from theisomer back to reactants is allowed.

• A product channel is a bimolecular configuration that is formed by dissociation of an isomer. Reassociation ofproducts to the isomer is not allowed.

The isomers are the configurations for which we must model the energy states. We designate pi(E, J, t) as the pop-ulation of isomer i having total energy E and total angular momentum quantum number J at time t. At long times,statistical mechanics requires that the population of each isomer approach a Boltzmann distribution bi(E, J):

limt→∞

pi(E, J, t) ∝ bi(E, J)

We can simplify by eliminating the angular momentum quantum number to get

pi(E, t) =∑J

pi(E, J, t)

Let us also denote the (time-dependent) total population of isomer i by xi(t):

xi(t) ≡∑J

∫ ∞0

pi(E, J, t) dE

The two molecules of a reactant or product channel are free to move apart from one another and interact independentlywith other molecules in the system. Accordingly, we treat these channels as fully thermalized, leaving as the onlyvariable the total concentrations ynA(t) and ynB(t) of the molecules An and Bn of reactant channel n. (Since theproduct channels act as infinite sinks, their populations do not need to be considered explicitly.)

Finally, we will use Nisom, Nreac, and Nprod as the numbers of isomers, reactant channels, and product channels,respectively, in the system.

The governing equation for the population distributions pi(E, J, t) of each isomer i and the reactant concentrationsynA(t) and ynB(t) combines the collision and reaction models to give a linear integro-differential equation:

d

dtpi(E, J, t) = ωi(T, P )

∑J′

∫ ∞0

Pi(E, J,E′, J ′)pi(E

′, J ′, t) dE′ − ωi(T, P )pi(E, J, t)

+

Nisom∑j 6=i

kij(E, J)pj(E, J, t)−Nisom∑j 6=i

kji(E, J)pi(E, J, t)

+

Nreac∑n=1

ynA(t)ynB(t)fin(E, J)bn(E, J, t)−Nreac+Nprod∑

n=1

gni(E, J)pi(E, J, t)

d

dtynA(t) =

d

dtynB(t) =

Nisom∑i=1

∫ ∞0

gni(E, J)pi(E, J, t) dE

−Nisom∑i=1

ynA(t)ynB(t)

∫ ∞0

fin(E, J)bn(E, J, t) dE

A summary of the variables is given below:



Variable Meaningpi(E, J, t) Population distribution of isomer iynA(t) Total population of species An in reactant channel nωi(T, P ) Collision frequency of isomer iPi(E, J,E

′, J ′) Collisional transfer probability from (E′, J ′) to (E, J) for isomer ikij(E, J) Microcanonical rate coefficient for isomerization from isomer j to isomer ifim(E, J) Microcanonical rate coefficient for association from reactant channel m to isomer ignj(E, J) Microcanonical rate coefficient for dissociation from isomer j to reactant or product channel nbn(E, J, t) Boltzmann distribution for reactant channel nNisom Total number of isomersNreac Total number of reactant channelsNprod Total number of product channels

The above is called the two-dimensional master equation because it contains two dimensions: total energy E andtotal angular momentum quantum number J . In the first equation (for isomers), the first pair of terms correspondto collision, the second pair to isomerization, and the final pair to association/dissociation. Similarly, in the secondequation above (for reactant channels), the pair of terms refer to dissociation/association.

We can also simplify the above to the one-dimensional form, which only has E as a dimension:

d

dtpi(E, t) = ωi(T, P )

∫ ∞0

Pi(E,E′)pi(E

′, t) dE′ − ωi(T, P )pi(E, t)

+

Nisom∑j 6=i

kij(E)pj(E, t)−Nisom∑j 6=i

kji(E)pi(E, t)

+

Nreac∑n=1

ynA(t)ynB(t)fin(E)bn(E, t)−Nreac+Nprod∑

n=1

gni(E)pi(E, t)

d

dtynA(t) =

d

dtynB(t) =

Nisom∑i=1

∫ ∞0

gni(E)pi(E, t) dE

−Nisom∑i=1

ynA(t)ynB(t)

∫ ∞0

fin(E)bn(E, t) dE

The equations as given are nonlinear, both due to the presence of the bimolecular reactants and because both ωiand Pi(E,E′) depend on the composition, which is changing with time. The rate coefficients can be derived fromconsidering the pseudo-first-order situation where ynA(t) � ynB(t), and all y(t) are negligible compared to the bathgas M. From these assumptions the changes in ωi, Pi(E,E′), and all ynB can be neglected, which yields a linearequation system.

Except for the simplest of unimolecular reaction networks, both the one-dimensional and two-dimensional masterequation must be solved numerically. To do this we must discretize and truncate the energy domain into a finitenumber of discrete bins called grains. This converts the linear integro-differential equation into a system of first-orderordinary differential equations:

d

dt

p1

p2

...y1Ay2A

...

=

M1 K12 . . . F11b1y1B F12b2y2B . . .K21 M2 . . . F21b1y1B F22b2y2B . . .

......

. . ....

.... . .

(g11)T (g12)T . . . h1 0 . . .(g21)T (g22)T . . . 0 h2 . . .

......

. . ....

.... . .

p1

p2

...y1Ay2A

...

The diagonal matrices Kij and Fin and the vector gni contain the microcanonical rate coefficients for isomerization,



association, and dissociation, respectively:

(Kij)rs =

{1

ΔEr

∫ Er+ΔEr/2

Er−ΔEr/2kij(E) dE r = s

0 r 6= s

(Fin)rs =

{1

ΔEr

∫ Er+ΔEr/2

Er−ΔEr/2fin(E) dE r = s

0 r 6= s

(gni)r =1

∆Er

∫ Er+ΔEr/2

Er−ΔEr/2

gni(E) dE

The matrices Mi represent the collisional transfer probabilities minus the rates of reactive loss to other isomers and toreactants and products:

(Mi)rs =

{ωi [Pi(Er, Er)− 1]−

∑Nisom

j 6=i kij(Er)−∑Nreac+Nprod

n=1 gni(Er) r = s

ωiPi(Er, Es) r 6= s

The scalars hn are simply the total rate coefficient for loss of reactant channel n due to chemical reactions:

hn = −Nisom∑i=1

Ngrains∑r=1

ynBfin(Er)bn(Er)

The interested reader is referred to any of a variety of other sources for alternative presentations, of which an illustrativesampling is given here [Gilbert1990] [Baer1996] [Holbrook1996] [Forst2003] [Pilling2003].

Methods for estimating k(T,P) values

The objective of each of the methods described in this section is to reduce the master equation into a small number ofphenomenological rate coefficients k(T, P ). All of the methods share a common formalism in that they seek to expressthe population distribution vector pi for each unimolecular isomer i as a linear combination of the total populations ofall unimolecular isomers and bimolecular reactant channels.

The modified strong collision method

rmgpy.pdep.msc.applyModifiedStrongCollisionMethod()The modified strong collision method utilizes a greatly simplified collision model that allows for a decouplingof the energy grains. In the simplified collision model, collisional stabilization of a reactive isomer is treated as asingle-step process, ignoring the effects of collisional energy redistribution within the reactive energy space. Anattempt to correct for the effect of collisional energy redistribution is made by modifying the collision frequencyωi(T, P ) with a collision efficiency βi(T ) estimated from the low-pressure limit fall-off of a single isomer.

By approximating the reactive populations as existing in pseudo-steady state, the master equation is convertedto a matrix equation is at each energy. Solving these small matrix equations gives the pseudo-steady statepopulations of each isomer as a function of the total population of each isomer and reactant channel, which arethen applied to determine the k(T, P ) values.

In practice, the modified strong collision method is the fastest and most robust of the methods, and is reasonablyaccurate over a wide range of temperatures and pressures.

The reservoir state method

rmgpy.pdep.rs.applyReservoirStateMethod()In the reservoir state method, the population distribution of each isomer is partitioned into the low-energy grains



(called the reservoir) and the high-energy grains (called the active space). The partition generally occurs at ornear the lowest transition state energy for each isomer. The reservoir population is assumed to be thermalized,while the active-space population is assumed to be in pseudo-steady state. Applying these approximationsconverts the master equation into a single large matrix equation. Solving this matrix equation gives the pseudo-steady state populations of each isomer as a function of the total population of each isomer and reactant channel,which are then applied to determine the k(T, P ) values.

The reservoir state method is only slightly more expensive than the modified strong collision method. At lowtemperatures the approximations used are very good, and the resulting k(T, P ) values are more accurate than themodified strong collision values. However, at high temperatures the thermalized reservoir approximation breaksdown, resulting in very inaccurate k(T, P ) values. Thus, the reservoir state method is not robustly applicableover a wide range of temperatures and pressures.

The chemically-significant eigenvalues method

rmgpy.pdep.cse.applyChemicallySignificantEigenvaluesMethod()In the chemically-significant eigenvalues method, the master equation matrix is diagonized to determine itseigenmodes. Only the slowest of these modes are relevant to the chemistry; the rest involve internal energyrelaxation due to collisions. Keeping only these “chemically-significant” eigenmodes allows for reduction tok(T, P ) values.

The chemically-significant eigenvalues method is the most accurate method, and is considered to be exact aslong as the chemically-significant eigenmodes are separable and distinct from the internal energy relaxationeigenmodes. However, this is often only the case near the high-pressure limit, even for networks of only modestsize. The chemically-significant eigenvalues method is also substantially more expensive to apply than the othermethods.

1.8 QMTP (rmgpy.qm)

The rmgpy.qm subpackage contains classes and functions for working with molecular geometries, and interfacingwith quantum chemistry software.

1.8.1 Main

Class DescriptionQMSettings A class to store settings related to quantum mechanics calculationsQMCalculator An object to store settings and previous calculations

1.8.2 Molecule

Class DescriptionGeometry A geometry, used for quantum calculationsQMMolecule A base class for QM Molecule calculations

1.8.3 QM Data

Class/Function DescriptionQMData General class for data extracted from a QM calculation



1.8.4 QM Verifier

Class/Function DescriptionQMVerifier Verifies whether a QM job was succesfully completed

1.8.5 Symmetry

Class/Function DescriptionPointGroup A symmetry Point GroupPointGroupCalculator Wrapper type to determine molecular symmetry point groups based on 3D

coordinatesSymmetryJob Determine the point group using the SYMMETRY program

1.8.6 Gaussian

Class/Function DescriptionGaussian A base class for all QM calculations that use GaussianGaussianMol A base Class for calculations of molecules using Gaussian.GaussianMolPM3 A base Class for calculations of molecules using Gaussian at PM3.GaussianMolPM6 A base Class for calculations of molecules using Gaussian at PM6.

1.8.7 Mopac

Class/Function DescriptionMopac A base class for all QM calculations that use MopacMopacMol A base Class for calculations of molecules using Mopac.MopacMolPM3 A base Class for calculations of molecules using Mopac at PM3.MopacMolPM6 A base Class for calculations of molecules using Mopac at PM6.MopacMolPM7 A base Class for calculations of molecules using Mopac at PM7.

rmgpy.qm.main

class rmgpy.qm.main.QMSettings(software=None, method=’pm3’, fileStore=None, scratchDirec-tory=None, onlyCyclics=True, maxRadicalNumber=0)

A minimal class to store settings related to quantum mechanics calculations.

Attribute Type Descriptionsoftware str Quantum chemical package name in common lettersmethod str Semi-empirical methodfileStore str The path to the QMfiles directoryscratchDirectory str The path to the scratch directoryonlyCyclics bool True if to run QM only on ringed speciesmaxRadicalNumber int Radicals larger than this are saturated before applying HBI

checkAllSet()Check that all the required settings are set.

class rmgpy.qm.main.QMCalculator(software=None, method=’pm3’, fileStore=None, scratchDirec-tory=None, onlyCyclics=True, maxRadicalNumber=0)

A Quantum Mechanics calculator object, to store settings.

1.8. QMTP (rmgpy.qm) 119


The attributes are:

Attribute Type Descriptionsettings QMSettings Settings for QM calculationsdatabase ThermoLibrary Database containing QM calculations

checkPaths()Check the paths in the settings are OK. Make folders as necessary.

checkReady()Check that it’s ready to run calculations.

getThermoData(molecule)Generate thermo data for the given Molecule via a quantum mechanics calculation.

Ignores the settings onlyCyclics and maxRadicalNumber and does the calculation anyway if asked. (I.e.the code that chooses whether to call this method should consider those settings).

initialize()Do any startup tasks.

setDefaultOutputDirectory(outputDirectory)IF the fileStore or scratchDirectory are not already set, put them in here.

rmgpy.qm.molecule

class rmgpy.qm.molecule.Geometry(settings, uniqueID, molecule, uniqueIDlong=None)A geometry, used for quantum calculations.

Created from a molecule. Geometry estimated by RDKit.

The attributes are:

Attribute Type Descriptionsettings QMSettings Settings for QM calculationsuniqueID str A short ID such as an augmented InChI Keymolecule Molecule RMG Molecule objectuniqueIDlong str A long, truly unique ID such as an augmented InChI

generateRDKitGeometries()Use RDKit to guess geometry.

Save mol files of both crude and refined. Saves coordinates on atoms.

getCrudeMolFilePath()Returns the path of the crude mol file.

getFilePath(extension, scratch=True)Returns the path to the file with the given extension.

The provided extension should include the leading dot. If called with scratch=False then it will be in thefileStore directory, else scratch=True is assumed and it will be in the scratchDirectory directory.

getRefinedMolFilePath()Returns the path the the refined mol file.

rd_build()Import rmg molecule and create rdkit molecule with the same atom labeling.

rd_embed(rdmol, numConfAttempts)Embed the RDKit molecule and create the crude molecule file.



saveCoordinatesFromQMData(qmdata)Save geometry info from QMData (eg CCLibData)

uniqueID = NoneA short unique ID such as an augmented InChI Key.

uniqueIDlong = NoneLong, truly unique, ID, such as the augmented InChI.

class rmgpy.qm.molecule.QMMolecule(molecule, settings)A base class for QM Molecule calculations.

Specific programs and methods should inherit from this and define some extra attributes and methods:

•outputFileExtension

•inputFileExtension

•generateQMData() ...and whatever else is needed to make this method work.

The attributes are:

Attribute Type Descriptionmolecule Molecule RMG Molecule objectsettings QMSettings Settings for QM calculationsuniqueID str A short ID such as an augmented InChI KeyuniqueIDlong str A long, truly unique ID such as an augmented InChI

calculateChiralityCorrection()Returns the chirality correction to entropy (R*ln(2) if chiral) in J/mol/K.

calculateThermoData()Calculate the thermodynamic properties.

Stores and returns a ThermoData object as self.thermo. self.qmData and self.pointGroup need to be gen-erated before this method is called.



createGeometry()Creates self.geometry with RDKit geometries

determinePointGroup()Determine point group using the SYMMETRY Program

Stores the resulting PointGroup in self.pointGroup

generateQMData()Calculate the QM data somehow and return a CCLibData object, or None if it fails.

generateThermoData()Generate Thermo Data via a QM calc.

Returns None if it fails.





getInChiKeyAug()Returns the augmented InChI from self.molecule

getMolFilePathForCalculation(attempt)Get the path to the MOL file of the geometry to use for calculation attempt.

If attempt <= self.scriptAttempts then we use the refined coordinates, then we start to use the crude coor-dinates.

getThermoFilePath()Returns the path the thermo data file.


inputFilePathGet the input file name.

loadThermoData()Try loading a thermo data from a previous run.

maxAttemptsThe total number of attempts to try

outputFilePathGet the output file name.

parse()Parses the results of the Mopac calculation, and returns a QMData object.

saveThermoData()Save the generated thermo data.

scriptAttemptsThe number of attempts with different script keywords

rmgpy.qm.qmdata

class rmgpy.qm.qmdata.QMData(groundStateDegeneracy=-1, numberOfAtoms=None, stericEnergy=None,molecularMass=None, energy=0, atomicNumbers=None, rotationalCon-stants=None, atomCoords=None, frequencies=None, source=None)

General class for data extracted from a QM calculation

groundStateDegeneracy = NoneElectronic ground state degeneracy in RMG taken as number of radicals +1

numberOfAtoms = NoneNumber of atoms.

rmgpy.qm.qmverifier

class rmgpy.qm.qmverifier.QMVerifier(molfile)

Verifies whether a QM job (externalized) was succesfully completed by

• searching for specific keywords in the output files,

• located in a specific directory (e.g. “QMFiles”)



checkForInChiKeyCollision(logFileInChI)This method is designed in the case a MOPAC output file was found but the InChI found in the file did notcorrespond to the InChI of the given molecule.

This could mean two things: 1) that the InChI Key hash does not correspond to the InChI it is hashed from.This is the rarest case of them all 2) the complete InChI did not fit onto just one line in the MOPAC outputfile. Therefore it was continued on the second line and only a part of the InChI was actually taken as the‘whole’ InChI.

This method reads in the MOPAC input file and compares the found InChI in there to the InChI of thegiven molecule.

succesfulJobExists()checks whether one of the flags is true. If so, it returns true.

rmgpy.qm.symmetry

class rmgpy.qm.symmetry.PointGroup(pointGroup, symmetryNumber, chiral)A symmetry Point Group.

Attributes are:

•pointGroup

•symmetryNumber

•chiral

•linear

class rmgpy.qm.symmetry.PointGroupCalculator(settings, uniqueID, qmData)Wrapper type to determine molecular symmetry point groups based on 3D coords information.

Will point to a specific algorithm, like SYMMETRY that is able to do this.

class rmgpy.qm.symmetry.SymmetryJob(settings, uniqueID, qmData)Determine the point group using the SYMMETRY program

(http://www.cobalt.chem.ucalgary.ca/ps/symmetry/).

Required input is a line with number of atoms followed by lines for each atom including: 1) atom number 2)x,y,z coordinates

finalTol determines how loose the point group criteria are; values are comparable to those specified in theGaussView point group interface

calculate()Do the entire point group calculation.

This writes the input file, then tries several times to run ‘symmetry’ with different parameters, until a pointgroup is found and returned.

inputFilePathThe input file’s path

parse(output)Check the output string and extract the resulting point group, which is returned.

run(command)Run the command, wait for it to finish, and return the stdout.

uniqueID = NoneThe object that holds information from a previous QM Job on 3D coords, molecule etc...


http://www.cobalt.chem.ucalgary.ca/ps/symmetry/


writeInputFile()Write the input file for the SYMMETRY program.

rmgpy.qm.gaussian

class rmgpy.qm.gaussian.GaussianA base class for all QM calculations that use Gaussian.

Classes such as GaussianMol will inherit from this class.

failureKeys = [’ERROR TERMINATION’, ‘IMAGINARY FREQUENCIES’]List of phrases that indicate failure NONE of these must be present in a succesful job.

parse()Parses the results of the Gaussian calculation, and returns a QMData object.

successKeys = [’Normal termination of Gaussian’]List of phrases to indicate success. ALL of these must be present in a successful job.

verifyOutputFile()Check’s that an output file exists and was successful.

Returns a boolean flag that states whether a successful GAUSSIAN simulation already exists for themolecule with the given (augmented) InChI Key.

The definition of finding a successful simulation is based on these criteria: 1) finding an output file withthe file name equal to the InChI Key 2) NOT finding any of the keywords that are denote a calculationfailure 3) finding all the keywords that denote a calculation success. 4) finding a match between the InChIof the given molecule and the InchI found in the calculation files 5) checking that the optimized geometry,when connected by single bonds, is isomorphic with self.molecule (converted to single bonds)

If any of the above criteria is not matched, False will be returned. If all are satisfied, it will return True.

class rmgpy.qm.gaussian.GaussianMol(molecule, settings)A base Class for calculations of molecules using Gaussian.

Inherits from both QMMolecule and Gaussian.









generateQMData()Calculate the QM data and return a QMData object.










getParser(outputFile)Returns the appropriate cclib parser.



inputFileKeywords(attempt)Return the top keywords for attempt number attempt.

NB. attempt begins at 1, not 0.










The definition of finding a successful simulation is based on these criteria: 1) finding an output file withthe file name equal to the InChI Key 2) NOT finding any of the keywords that are denote a calculationfailure 3) finding all the keywords that denote a calculation success. 4) finding a match between the InChI



of the given molecule and the InchI found in the calculation files 5) checking that the optimized geometry,when connected by single bonds, is isomorphic with self.molecule (converted to single bonds)


writeInputFile(attempt)Using the Geometry object, write the input file for the attempt.

class rmgpy.qm.gaussian.GaussianMolPM3(molecule, settings)Gaussian PM3 calculations for molecules

This is a class of its own in case you wish to do anything differently, but for now it’s only the ‘pm3’ in thekeywords that differs.

























keywords = [’# pm3 opt=(verytight,gdiis) freq IOP(2/16=3)’, ‘# pm3 opt=(verytight,gdiis) freq IOP(2/16=3) IOP(4/21=2)’, ‘# pm3 opt=(verytight,calcfc,maxcyc=200) freq IOP(2/16=3) nosymm’, ‘# pm3 opt=(verytight,calcfc,maxcyc=200) freq=numerical IOP(2/16=3) nosymm’, ‘# pm3 opt=(verytight,gdiis,small) freq IOP(2/16=3)’, ‘# pm3 opt=(verytight,nolinear,calcfc,small) freq IOP(2/16=3)’, ‘# pm3 opt=(verytight,gdiis,maxcyc=200) freq=numerical IOP(2/16=3)’, ‘# pm3 opt=tight freq IOP(2/16=3)’, ‘# pm3 opt=tight freq=numerical IOP(2/16=3)’, ‘# pm3 opt=(tight,nolinear,calcfc,small,maxcyc=200) freq IOP(2/16=3)’, ‘# pm3 opt freq IOP(2/16=3)’, ‘# pm3 opt=(verytight,gdiis) freq=numerical IOP(2/16=3) IOP(4/21=200)’, ‘# pm3 opt=(calcfc,verytight,newton,notrustupdate,small,maxcyc=100,maxstep=100) freq=(numerical,step=10) IOP(2/16=3) nosymm’, ‘# pm3 opt=(tight,gdiis,small,maxcyc=200,maxstep=100) freq=numerical IOP(2/16=3) nosymm’, ‘# pm3 opt=(verytight,gdiis,calcall) IOP(2/16=3)’, ‘# pm3 opt=(verytight,gdiis,calcall,small,maxcyc=200) IOP(2/16=3) IOP(4/21=2) nosymm’, ‘# pm3 opt=(verytight,gdiis,calcall,small) IOP(2/16=3) nosymm’, ‘# pm3 opt=(calcall,small,maxcyc=100) IOP(2/16=3)’]Keywords that will be added at the top of the qm input file












class rmgpy.qm.gaussian.GaussianMolPM6(molecule, settings)Gaussian PM6 calculations for molecules

This is a class of its own in case you wish to do anything differently, but for now it’s only the ‘pm6’ in thekeywords that differs.

























keywords = [’# pm6 opt=(verytight,gdiis) freq IOP(2/16=3)’, ‘# pm6 opt=(verytight,gdiis) freq IOP(2/16=3) IOP(4/21=2)’, ‘# pm6 opt=(verytight,calcfc,maxcyc=200) freq IOP(2/16=3) nosymm’, ‘# pm6 opt=(verytight,calcfc,maxcyc=200) freq=numerical IOP(2/16=3) nosymm’, ‘# pm6 opt=(verytight,gdiis,small) freq IOP(2/16=3)’, ‘# pm6 opt=(verytight,nolinear,calcfc,small) freq IOP(2/16=3)’, ‘# pm6 opt=(verytight,gdiis,maxcyc=200) freq=numerical IOP(2/16=3)’, ‘# pm6 opt=tight freq IOP(2/16=3)’, ‘# pm6 opt=tight freq=numerical IOP(2/16=3)’, ‘# pm6 opt=(tight,nolinear,calcfc,small,maxcyc=200) freq IOP(2/16=3)’, ‘# pm6 opt freq IOP(2/16=3)’, ‘# pm6 opt=(verytight,gdiis) freq=numerical IOP(2/16=3) IOP(4/21=200)’, ‘# pm6 opt=(calcfc,verytight,newton,notrustupdate,small,maxcyc=100,maxstep=100) freq=(numerical,step=10) IOP(2/16=3) nosymm’, ‘# pm6 opt=(tight,gdiis,small,maxcyc=200,maxstep=100) freq=numerical IOP(2/16=3) nosymm’, ‘# pm6 opt=(verytight,gdiis,calcall) IOP(2/16=3)’, ‘# pm6 opt=(verytight,gdiis,calcall,small,maxcyc=200) IOP(2/16=3) IOP(4/21=2) nosymm’, ‘# pm6 opt=(verytight,gdiis,calcall,small) IOP(2/16=3) nosymm’, ‘# pm6 opt=(calcall,small,maxcyc=100) IOP(2/16=3)’]Keywords that will be added at the top of the qm input file














rmgpy.qm.mopac

class rmgpy.qm.mopac.MopacA base class for all QM calculations that use MOPAC.

Classes such as MopacMol will inherit from this class.

failureKeys = [’IMAGINARY FREQUENCIES’, ‘EXCESS NUMBER OF OPTIMIZATION CYCLES’, ‘NOT ENOUGH TIME FOR ANOTHER CYCLE’]List of phrases that indicate failure NONE of these must be present in a succesful job.


successKeys = [’DESCRIPTION OF VIBRATIONS’, ‘MOPAC DONE’]List of phrases to indicate success. ALL of these must be present in a successful job.

usePolar = FalseKeywords for the multiplicity


Returns a boolean flag that states whether a successful MOPAC simulation already exists for the moleculewith the given (augmented) InChI Key.


If any of the above criteria is not matched, False will be returned. If all succeed, then it will return True.

class rmgpy.qm.mopac.MopacMol(molecule, settings)A base Class for calculations of molecules using MOPAC.



Inherits from both QMMolecule and Mopac.









generateQMData()Calculate the QM data and return a QMData object, or None if it fails.











inputFileKeywords(attempt)Return the top, bottom, and polar keywords.


keywords = [{‘top’: ‘precise nosym THREADS=1’, ‘bottom’: ‘oldgeo thermo nosym precise THREADS=1 ‘}, {‘top’: ‘precise nosym gnorm=0.0 nonr THREADS=1’, ‘bottom’: ‘oldgeo thermo nosym precise THREADS=1 ‘}, {‘top’: ‘precise nosym gnorm=0.0 THREADS=1’, ‘bottom’: ‘oldgeo thermo nosym precise THREADS=1 ‘}, {‘top’: ‘precise nosym gnorm=0.0 bfgs THREADS=1’, ‘bottom’: ‘oldgeo thermo nosym precise THREADS=1 ‘}, {‘top’: ‘precise nosym recalc=10 dmax=0.10 nonr cycles=2000 t=2000 THREADS=1’, ‘bottom’: ‘oldgeo thermo nosym precise THREADS=1 ‘}]Keywords that will be added at the top and bottom of the qm input file














class rmgpy.qm.mopac.MopacMolPM3(molecule, settings)Mopac PM3 calculations for molecules

This is a class of its own in case you wish to do anything differently, but for now it’s the same as all the MOPACPMn calculations, only pm3






















inputFileKeywords(attempt)Return the top, bottom, and polar keywords for attempt number attempt.





















1.9 Physical quantities (rmgpy.quantity)

A physical quantity is defined by a numerical value and a unit of measurement.

The rmgpy.quantity module contains classes and methods for working with physical quantities. Physical quantitiesare represented by either the ScalarQuantity or ArrayQuantity class depending on whether a scalar or vector (ortensor) value is used. The Quantity function automatically chooses the appropriate class based on the input value.In both cases, the value of a physical quantity is available from the value attribute, and the units from the unitsattribute.

For efficient computation, the value is stored internally in the SI equivalent units. The SI value can be accessed directlyusing the value_si attribute. Usually it is good practice to read the value_si attribute into a local variable and thenuse it for computations, especially if it is referred to multiple times in the calculation.

Physical quantities also allow for storing of uncertainty values for both scalars and arrays. The uncertaintyType at-tribute indicates whether the given uncertainties are additive ("+|-") or multiplicative ("*|/"), and the uncertaintyattribute contains the stored uncertainties. For additive uncertainties these are stored in the given units (not the SI equiv-alent), since they are generally not needed for efficient computations. For multiplicative uncertainties, the uncertaintyvalues are by definition dimensionless.

1.9.1 Quantity objects

Class DescriptionScalarQuantity A scalar physical quantity, with units and uncertaintyArrayQuantity An array physical quantity, with units and uncertaintyQuantity() Return a scalar or array physical quantity



1.9.2 Unit types

Units can be classified into categories based on the associated dimensionality. For example, miles and kilometersare both units of length; seconds and hours are both units of time, etc. Clearly, quantities of different unit types arefundamentally different.

RMG provides functions that create physical quantities (scalar or array) and validate the units for a variety of unittypes. This prevents the user from inadvertently mixing up their units - e.g. by setting an enthalpy with entropy units- which should reduce errors. RMG recognizes the following unit types:

Function Unit type SI unitAcceleration() acceleration m/s2

Area() area m2

Concentration() concentration mol/cm3

Dimensionless() dimensionlessEnergy() energy J/molEntropy() entropy J/mol ·KFlux() flux mol/cm2 · sFrequency() frequency cm−1

Force() force NInertia() inertia kg ·m2

Length() length mMass() mass kgMomentum() momentum kg ·m/s2Power() power WPressure() pressure PaRateCoefficient() rate coefficient s−1, m3/mol · s, m6/mol2 · s, m9/mol3 · sTemperature() temperature KTime() time sVelocity() velocity m/sVolume() volume m3

In RMG, all energies, heat capacities, concentrations, fluxes, and rate coefficients are treated as intensive; this meansthat these quantities are always expressed “per mole” or “per molecule”. All other unit types are extensive. A specialexception is added for mass so as to allow for coercion of g/mol to amu.

RMG also handles rate coefficient units as a special case, as there are multiple allowed dimensionalities based on thereaction order. Note that RMG generally does not attempt to verify that the rate coefficient units match the reactionorder, but only that it matches one of the possibilities.

The table above gives the SI unit that RMG uses internally to work with physical quantities. This does not necessarilycorrespond with the units used when outputting values. For example, pressures are often output in units of bar insteadof Pa, and moments of inertia in amu ∗ angstrom2 instead of kg ∗m2. The recommended rule of thumb is to useprefixed SI units (or aliases thereof) in the output; for example, use kJ/mol instead of kcal/mol for energy values.

rmgpy.quantity.ScalarQuantity

class rmgpy.quantity.ScalarQuantityThe ScalarQuantity class provides a representation of a scalar physical quantity, with optional units anduncertainty information. The attributes are:

1.9. Physical quantities (rmgpy.quantity) 137


Attribute Descriptionvalue The numeric value of the quantity in the given unitsunits The units the value was specified inuncertainty The numeric uncertainty in the value in the given units (unitless if multiplicative)uncertainty-Type

The type of uncertainty: ’+|-’ for additive, ’*|/’ for multiplicative

value_si The numeric value of the quantity in the corresponding SI unitsuncertainty_si The numeric value of the uncertainty in the corresponding SI units (unitless if

multiplicative)

It is often more convenient to perform computations using SI units instead of the given units of the quantity. Forthis reason, the SI equivalent of the value attribute can be directly accessed using the value_si attribute. Thisvalue is cached on the ScalarQuantity object for speed.

copy()Return a copy of the quantity.

equals()Return True if the everything in a quantity object matches the parameters in this object. If there are listsof values or uncertainties, each item in the list must be matching and in the same order. Otherwise, returnFalse (Originally intended to return warning if units capitalization was different, however, Quantity objectonly parses units matching in case, so this will not be a problem.)

getConversionFactorFromSI()Return the conversion factor for converting a quantity to a given set of units from the SI equivalent units.

getConversionFactorToSI()Return the conversion factor for converting a quantity in a given set of‘units‘ to the SI equivalent units.

getUncertainty()The numeric value of the uncertainty, in the given units if additive, or no units if multiplicative.

getUncertaintyType()The type of uncertainty: ’+|-’ for additive, ’*|/’ for multiplicative

getValue()The numeric value of the quantity, in the given units

isUncertaintyAdditive()Return True if the uncertainty is specified in additive format and False otherwise.

isUncertaintyMultiplicative()Return True if the uncertainty is specified in multiplicative format and False otherwise.

setUncertaintyType()Check the uncertainty type is valid, then set it.

uncertaintyThe numeric value of the uncertainty, in the given units if additive, or no units if multiplicative.

uncertaintyTypeThe type of uncertainty: ’+|-’ for additive, ’*|/’ for multiplicative

valueThe numeric value of the quantity, in the given units

rmgpy.quantity.ArrayQuantity

class rmgpy.quantity.ArrayQuantityThe ArrayQuantity class provides a representation of an array of physical quantity values, with optional units



and uncertainty information. The attributes are:

Attribute Descriptionvalue The numeric value of the quantity in the given unitsunits The units the value was specified inuncertainty The numeric uncertainty in the value (unitless if multiplicative)uncertainty-Type

The type of uncertainty: ’+|-’ for additive, ’*|/’ for multiplicative

value_si The numeric value of the quantity in the corresponding SI unitsuncertainty_si The numeric value of the uncertainty in the corresponding SI units (unitless if

multiplicative)

It is often more convenient to perform computations using SI units instead of the given units of the quantity. Forthis reason, the SI equivalent of the value attribute can be directly accessed using the value_si attribute. Thisvalue is cached on the ArrayQuantity object for speed.

copy()Return a copy of the quantity.

equals()Return True if the everything in a quantity object matches the parameters in this object. If there are listsof values or uncertainties, each item in the list must be matching and in the same order. Otherwise, returnFalse (Originally intended to return warning if units capitalization was different, however, Quantity objectonly parses units matching in case, so this will not be a problem.)

getConversionFactorFromSI()Return the conversion factor for converting a quantity to a given set of units from the SI equivalent units.

getConversionFactorToSI()Return the conversion factor for converting a quantity in a given set of‘units‘ to the SI equivalent units.

getUncertainty()The numeric value of the uncertainty, in the given units if additive, or no units if multiplicative.

getUncertaintyType()The type of uncertainty: ’+|-’ for additive, ’*|/’ for multiplicative

getValue()The numeric value of the array quantity, in the given units.

isUncertaintyAdditive()Return True if the uncertainty is specified in additive format and False otherwise.

isUncertaintyMultiplicative()Return True if the uncertainty is specified in multiplicative format and False otherwise.

setUncertaintyType()Check the uncertainty type is valid, then set it.

If you set the uncertainty then change the type, we have no idea what to do with the units. This ensuresyou set the type first.

uncertaintyThe numeric value of the uncertainty, in the given units if additive, or no units if multiplicative.

uncertaintyTypeThe type of uncertainty: ’+|-’ for additive, ’*|/’ for multiplicative

valueThe numeric value of the array quantity, in the given units.

1.9. Physical quantities (rmgpy.quantity) 139


rmgpy.quantity.Quantity

rmgpy.quantity.Quantity()Create a ScalarQuantity or ArrayQuantity object for a given physical quantity. The physical quantity canbe specified in several ways:

•A scalar-like or array-like value (for a dimensionless quantity)

•An array of arguments (including keyword arguments) giving some or all of the value, units, uncertainty,and/or uncertaintyType.

•A tuple of the form (value,), (value,units), (value,units,uncertainty), or(value,units,uncertaintyType,uncertainty)

•An existing ScalarQuantity or ArrayQuantity object, for which a copy is made

1.10 Reactions (rmgpy.reaction)

The rmgpy.reaction subpackage contains classes and functions for working with chemical reaction.

1.10.1 Reaction

Class DescriptionReaction A chemical reaction

1.10.2 Exceptions

Class DescriptionReactionError Raised when an error occurs while working with reactions

rmgpy.reaction.Reaction

class rmgpy.reaction.ReactionA chemical reaction. The attributes are:

Attribute Type Descriptionindex int A unique nonnegative integer indexlabel str A descriptive string labelreactants list The reactant species (as Species objects)products list The product species (as Species objects)kinetics KineticsModel The kinetics model to use for the reactionreversible bool True if the reaction is reversible, False if nottransition-State

TransitionState The transition state

duplicate bool True if the reaction is known to be a duplicate, False if notdegeneracy double The reaction path degeneracy for the reactionpairs list Reactant-product pairings to use in converting reaction flux to

species flux

calculateMicrocanonicalRateCoefficient()Calculate the microcanonical rate coefficient k(E) for the reaction reaction at the energies Elist in J/mol.reacDensStates and prodDensStates are the densities of states of the reactant and product configurations



for this reaction. If the reaction is irreversible, only the reactant density of states is required; if the reactionis reversible, then both are required. This function will try to use the best method that it can based on theinput data available:





k(T ) = κ(T )kBT

h

Q‡(T )

QA(T )QB(T )exp

(− E0

kBT










1.10. Reactions (rmgpy.reaction) 141













1.11 Reaction mechanism generation (rmgpy.rmg)

The rmgpy.rmg subpackage contains the main functionality for using RMG-Py to automatically generate detailedreaction mechanisms.

1.11.1 Reaction models

Class DescriptionSpecies A chemical species, with RMG-specific functionalityCoreEdgeReactionModel A reaction model comprised of core and edge species and reactions

1.11.2 Input

Function DescriptionreadInputFile() Load an RMG job input filesaveInputFile() Save an RMG job input file

1.11. Reaction mechanism generation (rmgpy.rmg) 143


1.11.3 Output

Function DescriptionsaveOutputHTML() Save the results of an RMG job to an HTML filesaveDiffHTML() Save a comparison of two reaction mechanisms to an HTML file

1.11.4 Job classes

Class DescriptionRMG Main class for RMG jobs

1.11.5 Pressure dependence

Class DescriptionPDepReaction A pressure-dependent “net” reactionPDepNetwork A pressure-dependent unimolecular reaction network, with RMG-specific functionality

1.11.6 Exceptions

Exception DescriptionInputError Raised when an error occurs while working with an RMG input fileOutputError Raised when an error occurs while saving an RMG output filePressureDependenceError Raised when an error occurs while computing pressure-dependent rate

coefficients

rmgpy.rmg.model.CoreEdgeReactionModel

class rmgpy.rmg.model.CoreEdgeReactionModel(core=None, edge=None)Represent a reaction model constructed using a rate-based screening algorithm. The species and reactions in themodel itself are called the core; the species and reactions identified as candidates for inclusion in the model arecalled the edge. The attributes are:

Attribute Descriptioncore The species and reactions of the current model coreedge The species and reactions of the current model edgenetworkDict A dictionary of pressure-dependent reaction networks (Network objects) indexed by

source.networkList A list of pressure-dependent reaction networks (Network objects)networkCount A counter for the number of pressure-dependent networks createdindexSpecies-Dict

A dictionary with a unique index pointing to the species objects

addReactionLibraryToEdge(reactionLibrary)Add all species and reactions from reactionLibrary, a KineticsPrimaryDatabase object, to the modeledge.

addReactionLibraryToOutput(reactionLib)Add all species and reactions from reactionLibrary, a KineticsPrimaryDatabase object, to the output.This does not bring any of the reactions or species into the core itself.



addReactionToCore(rxn)Add a reaction rxn to the reaction model core (and remove from edge if necessary). This function assumesrxn has already been checked to ensure it is supposed to be a core reaction (i.e. all of its reactants AND allof its products are in the list of core species).

addReactionToEdge(rxn)Add a reaction rxn to the reaction model edge. This function assumes rxn has already been checked toensure it is supposed to be an edge reaction (i.e. all of its reactants OR all of its products are in the list ofcore species, and the others are in either the core or the edge).

addReactionToUnimolecularNetworks(newReaction, newSpecies, network=None)Given a newly-created Reaction object newReaction, update the corresponding unimolecular reactionnetwork. If no network exists, a new one is created. If the new reaction is an isomerization that connectstwo existing networks, the two networks are merged. This function is called whenever a new high-pressurelimit edge reaction is created. Returns the network containing the new reaction.

addSeedMechanismToCore(seedMechanism, react=False)Add all species and reactions from seedMechanism, a KineticsPrimaryDatabase object, to the modelcore. If react is True, then reactions will also be generated between the seed species. For large seedmechanisms this can be prohibitively expensive, so it is not done by default.

addSpeciesToCore(spec)Add a species spec to the reaction model core (and remove from edge if necessary). This function alsomoves any reactions in the edge that gain core status as a result of this change in status to the core. If thisare any such reactions, they are returned in a list.

addSpeciesToEdge(spec)Add a species spec to the reaction model edge.

checkForExistingReaction(rxn)Check to see if an existing reaction has the same reactants, products, and family as rxn. Returns True orFalse and the matched reaction (if found).

First, a shortlist of reaction is retrieved that have the same reaction keys as the parameter reaction.

Next, the reaction ID containing an identifier (e.g. label) of the reactants and products is compared betweenthe parameter reaction and the each of the reactions in the shortlist. If a match is found, the discoveredreaction is returned.

If a match is not yet found, the Library (seed mechs, reaction libs) in the reaction database are iterated overto check if a reaction was overlooked (a reaction with a different “family” key as the parameter reaction).

checkForExistingSpecies(molecule)Check to see if an existing species contains the same molecule.Molecule as molecule. Returns Trueand the matched species (if found) or False and None (if not found).

enlarge(newObject=None, reactEdge=False, unimolecularReact=None, bimolecularReact=None)Enlarge a reaction model by processing the objects in the list newObject. If newObject is armg.species.Species object, then the species is moved from the edge to the core and reactions gen-erated for that species, reacting with itself and with all other species in the model core. If newObject is armg.unirxn.network.Network object, then reactions are generated for the species in the network withthe largest leak flux.

If the reactEdge flag is True, then no newObject is needed, and instead the algorithm proceeds to react thecore species together to form edge reactions.

generateKinetics(reaction)Generate best possible kinetics for the given reaction using the kinetics database.

getLists()Return lists of all of the species and reactions in the core and the edge.



getModelSize()Return the numbers of species and reactions in the model core and edge. Note that this is not necessarilyequal to the lengths of the corresponding species and reaction lists.

getSpecies(obj)Retrieve species object, by polling the index species dictionary.

getStoichiometryMatrix()Return the stoichiometry matrix for all generated species and reactions. The id of each species and reactionis the corresponding row and column, respectively, in the matrix.

inflate(rxn)Convert reactions from reactants/products that are referring to the core species index, to the respectiveSpecies objects.

initializeIndexSpeciesDict()Populates the core species dictionary

integer -> core Species

with the species that are currently in the core.

makeNewPDepReaction(forward)Make a new pressure-dependent reaction based on a list of reactants and a list of products. The reactionbelongs to the specified network and has pressure-dependent kinetics given by kinetics.

No checking for existing reactions is made here. The returned PDepReaction object is not added to theglobal list of reactions, as that is intended to represent only the high-pressure-limit set. The reaction-Counter is incremented, however, since the returned reaction can and will exist in the model edge and/orcore.

makeNewReaction(forward, checkExisting=True)Make a new reaction given a Reaction object forward. The reaction is added to the global list of reactions.Returns the reaction in the direction that corresponds to the estimated kinetics, along with whether or notthe reaction is new to the global reaction list.

The forward direction is determined using the “is_reverse” attribute of the reaction’s family. If the reactionfamily is its own reverse, then it is made such that the forward reaction is exothermic at 298K.

The forward reaction is appended to self.newReactionList if it is new.

makeNewSpecies(object, label=’‘, reactive=True, checkForExisting=True)Formally create a new species from the specified object, which can be either a Molecule object or anrmgpy.species.Species object.

markChemkinDuplicates()Check that all reactions that will appear the chemkin output have been checked as duplicates.

Call this if you’ve done something that may have introduced undetected duplicate reactions, like add areaction library or seed mechanism. Anything added via the expand() method should already be detected.

printEnlargeSummary(newCoreSpecies, newCoreReactions, newEdgeSpecies, newEdgeReactions, re-actionsMovedFromEdge=None, reactEdge=False)

Output a summary of a model enlargement step to the log. The details of the enlargement are passed in thenewCoreSpecies, newCoreReactions, newEdgeSpecies, and newEdgeReactions objects.

processNewReactions(newReactions, newSpecies, pdepNetwork=None)Process a list of newly-generated reactions involving the new core species or explored isomer newSpeciesin network pdepNetwork.

Makes a reaction and decides where to put it: core, edge, or PDepNetwork.



prune(reactionSystems, toleranceKeepInEdge, maximumEdgeSpecies, minSpeciesExistIterationsFor-Prune)

Remove species from the model edge based on the simulation results from the list of reactionSystems.

registerReaction(rxn)Adds the reaction to the reaction database.

The reaction database is structured as a multi-level dictionary, for efficient search and retrieval of existingreactions.

The database has two types of dictionary keys: - reaction family - reactant(s) keys

First, the keys are generated for the parameter reaction.

Next, it is checked whether the reaction database already contains similar keys. If not, a new container iscreated, either a dictionary for the family key and first reactant key, or a list for the second reactant key.

Finally, the reaction is inserted as the first element in the list.

removeSpeciesFromEdge(spec)Remove species spec from the reaction model edge.

retrieve(family_label, key1, key2)Returns a list of reactions from the reaction database with the same keys as the parameters.

Returns an empty list when one of the keys could not be found.

retrieveNewSpecies(deflatedRxn)Searches for the first reactant or product in the deflated reaction that is represented by an integer.

Such an object refers to a core species that was used to generate the reaction in the first place. Reactantsor products represented by an object that is not an integer will be a newly-generated structure.

searchRetrieveReactions(rxn)Searches through the reaction database for reactions with an identical reaction key as the key of the pa-rameter reaction.

Both the reaction key based on the reactants as well as on the products is used to search for possiblecandidate reactions.

updateUnimolecularReactionNetworks()Iterate through all of the currently-existing unimolecular reaction networks, updating those that have beenmarked as invalid. In each update, the phenomonological rate coefficients k(T, P ) are computed for eachnet reaction in the network, and the resulting reactions added or updated.

class rmgpy.rmg.model.ReactionModel(species=None, reactions=None)Represent a generic reaction model. A reaction model consists of species, a list of species, and reactions, a listof reactions.

merge(other)Return a new ReactionModel object that is the union of this model and other.

RMG input files

rmgpy.rmg.input.readInputFile(path, rmg0)Read an RMG input file at path on disk into the RMG object rmg.

rmgpy.rmg.input.saveInputFile(path, rmg)Save an RMG input file at path on disk from the RMG object rmg.



rmgpy.rmg.main.RMG

class rmgpy.rmg.main.RMG(inputFile=None, outputDirectory=None)A representation of a Reaction Mechanism Generator (RMG) job. The attributes are:

Attribute DescriptioninputFile The path to the input filedatabaseDirectory The directory containing the RMG databasethermoLibraries The thermodynamics libraries to loadreactionLibraries The kinetics libraries to loadstatmechLibraries The statistical mechanics libraries to loadseedMechanisms The seed mechanisms included in the modelkineticsFamilies The kinetics families to use for reaction generationkineticsDepositories The kinetics depositories to use for looking up kinetics in each familykineticsEstimator The method to use to estimate kinetics: ‘group additivity’ or ‘rate rules’solvent If solvation estimates are required, the name of the solvent.reactionModel The core-edge reaction model generated by this jobreactionSystems A list of the reaction systems used in this jobdatabase The RMG database used in this jobabsoluteTolerance The absolute tolerance used in the ODE/DAE solverrelativeTolerance The relative tolerance used in the ODE/DAE solversensitivityAbsoluteTolerance The absolute tolerance used in the ODE/DAE solver for the sensitivitiessensitivityRelativeTolerance The relative tolerance used in the ODE/DAE solver for the sensitivitiesfluxToleranceKeepInEdge The relative species flux below which species are discarded from the edgefluxToleranceMoveToCore The relative species flux above which species are moved from the edge to the corefluxToleranceInterrupt The relative species flux above which the simulation will haltmaximumEdgeSpecies The maximum number of edge species allowed at any timeminCoreSizeForPrune Minimum number of core species before pruning is allowedminSpeciesExistIterationsForPrune Minimum number of iterations a species must exist before it can be prunedfilterReactions Specify whether to filter reactions during model enlarging stepunimolecularThreshold Array of flags indicating whether a species is above the unimolecular reaction thresholdbimolecularaThreshold Array of flags indicating whether two species are above the bimolecular reaction thresholdunimolecularReact Array of flags indicating whether a species should react unimolecularly in the enlarge stepbimolecularReact Array of flags indicating whether two species should react in the enlarge steptermination A list of termination targets (i.e TerminationTime and TerminationConversion objects)speciesConstraints Dictates the maximum number of atoms, carbons, electrons, etc. generated by RMGoutputDirectory The directory used to save output filesverbosity The level of logging verbosity for console outputloadRestart True if restarting a previous job, False otherwisesaveRestartPeriod The time period to periodically save a restart file (Quantity), or None for never.units The unit system to use to save output files (currently must be ‘si’)generateOutputHTML True to draw pictures of the species and reactions, saving a visualized model in an output HTML file. False otherwisegeneratePlots True to generate plots of the job execution statistics after each iteration, False otherwiseverboseComments True to keep the verbose comments for database estimates, False otherwisesaveEdgeSpecies True to save chemkin and HTML files of the edge species, False otherwisekeepIrreversible True to keep ireversibility of library reactions as is (‘<=>’ or ‘=>’). False (default) to force all library reactions to be reversible (‘<=>’)pressureDependence Whether to process unimolecular (pressure-dependent) reaction networksquantumMechanics Whether to apply quantum mechanical calculations instead of group additivity to certain molecular types.wallTime The maximum amount of CPU time in the form DD:HH:MM:SS to expend on this job; used to stop gracefully so we can still get profiling informationinitializationTime The time at which the job was initiated, in seconds since the epoch (i.e. from time.time())done Whether the job has completed (there is nothing new to add)



checkInput()Check for a few common mistakes in the input file.

checkLibraries()Check unwanted use of libraries: Liquid phase libraries in Gas phase simulation. Loading a Liquid phaselibrary obtained in another solvent than the one defined in the input file. Other checks can be added here.

clear()Clear all loaded information about the job (except the file paths).

execute(**kwargs)Execute an RMG job using the command-line arguments args as returned by the argparse package.

finish()Complete the model generation.

initialize(**kwargs)Initialize an RMG job using the command-line arguments args as returned by the argparse package.

loadInput(path=None)Load an RMG job from the input file located at inputFile, or from the inputFile attribute if not given as aparameter.

loadRMGJavaInput(path)Load an RMG-Java job from the input file located at inputFile, or from the inputFile attribute if not givenas a parameter.

loadRestartFile(path)Load a restart file at path on disk.

loadThermoInput(path=None)Load an Thermo Estimation job from a thermo input file located at inputFile, or from the inputFile attributeif not given as a parameter.

logHeader(level=20)Output a header containing identifying information about RMG to the log.

readMeaningfulLineJava(f)Read a meaningful line from an RMG-Java condition file object f, returning the line with any commentsremoved.

register_listeners()Attaches listener classes depending on the options found in the RMG input file.

saveEverything()Saves the output HTML, the Chemkin file, and the Restart file (if appropriate).

The restart file is only saved if self.saveRestartPeriod or self.done.

saveInput(path=None)Save an RMG job to the input file located at path, or from the outputFile attribute if not given as a param-eter.

rmgpy.rmg.main.initializeLog(verbose, log_file_name)Set up a logger for RMG to use to print output to stdout. The verbose parameter is an integer specifying theamount of log text seen at the console; the levels correspond to those of the logging module.

rmgpy.rmg.main.makeProfileGraph(stats_file)Uses gprof2dot to create a graphviz dot file of the profiling information.

This requires the gprof2dot package available via pip install gprof2dot. Render the result using the program‘dot’ via a command like dot -Tps2 input.dot -o output.ps2.



Rendering the ps2 file to pdf requires an external pdf converter ps2pdf output.ps2 which produces a out-put.ps2.pdf file.

rmgpy.rmg.main.processProfileStats(stats_file, log_file)

Saving RMG output

rmgpy.rmg.output.saveOutputHTML(path, reactionModel, partCoreEdge=’core’)Save the current set of species and reactions of reactionModel to an HTML file path on disk. As part ofthis process, drawings of all species are created in the species folder (if they don’t already exist) using thermgpy.molecule.draw module. The jinja package is used to generate the HTML; if this package is notfound, no HTML will be generated (but the program will carry on).

rmgpy.rmg.output.saveDiffHTML(path, commonSpeciesList, speciesList1, speciesList2, commonReac-tions, uniqueReactions1, uniqueReactions2)

This function outputs the species and reactions on an HTML page for the comparison of two RMG models.

rmgpy.rmg.pdep.PDepNetwork

class rmgpy.rmg.pdep.PDepNetwork(index=-1, source=None)A representation of a partial unimolecular reaction network. Each partial network has a single source isomeror reactant channel, and is responsible only for k(T, P ) values for net reactions with source as the reactant.Multiple partial networks can have the same source, but networks with the same source and any explored isomersmust be combined.

Attribute Type Descriptionsource list The isomer or reactant channel that acts as the sourceexplored list A list of the unimolecular isomers whose reactions have been fully explored

addPathReaction(newReaction)Add a path reaction to the network. If the path reaction already exists, no action is taken.

applyChemicallySignificantEigenvaluesMethod(lumpingOrder=None)Compute the phenomenological rate coefficients k(T, P ) at the current conditions using the chemically-significant eigenvalues method. If a lumpingOrder is provided, the algorithm will attempt to lump theconfigurations (given by index) in the order provided, and return a reduced set of k(T, P ) values.

applyModifiedStrongCollisionMethod(efficiencyModel=’default’)Compute the phenomenological rate coefficients k(T, P ) at the current conditions using the modifiedstrong collision method.

applyReservoirStateMethod()Compute the phenomenological rate coefficients k(T, P ) at the current conditions using the reservoir statemethod.

calculateCollisionModel()Calculate the matrix of first-order rate coefficients for collisional population transfer between grains foreach isomer, including the corresponding collision frequencies.

calculateDensitiesOfStates()Calculate the densities of states of each configuration that has states data. The densities of states arecomputed such that they can be applied to each temperature in the range of interest by interpolation.

calculateEquilibriumRatios()Return an array containing the fraction of each isomer and reactant channel present at equilibrium, asdetermined from the Gibbs free energy and using the concentration equilibrium constant Kc. These valuesare ratios, and the absolute magnitude is not guaranteed; however, the implementation scales the elementsof the array so that they sum to unity.



calculateMicrocanonicalRates()Calculate and return arrays containing the microcanonical rate coefficients k(E) for the isomerization,dissociation, and association path reactions in the network.

cleanup()Delete intermedate arrays used to compute k(T,P) values.

exploreIsomer(isomer)Explore a previously-unexplored unimolecular isomer in this partial network using the provided core-edgereaction model reactionModel, returning the new reactions and new species.

getAllSpecies()Return a list of all unique species in the network, including all isomers, reactant and product channels, andbath gas species.

getLeakBranchingRatios(T, P)Return a dict with the unexplored isomers in the partial network as the keys and the fraction of the totalleak coefficient as the values.

getLeakCoefficient(T, P)Return the pressure-dependent rate coefficient k(T, P ) describing the total rate of “leak” from this network.This is defined as the sum of the k(T, P ) values for all net reactions to nonexplored unimolecular isomers.

getMaximumLeakSpecies(T, P)Get the unexplored (unimolecular) isomer with the maximum leak flux. Note that the leak rate coefficientsvary with temperature and pressure, so you must provide these in order to get a meaningful result.

initialize(Tmin, Tmax, Pmin, Pmax, maximumGrainSize=0.0, minimumGrainCount=0, activeJRo-tor=True, activeKRotor=True, rmgmode=False)

Initialize a pressure dependence calculation by computing several quantities that are independent of theconditions. You must specify the temperature and pressure ranges of interesting using Tmin and Tmax inK and Pmin and Pmax in Pa. You must also specify the maximum energy grain size grainSize in J/moland/or the minimum number of grains grainCount.

invalidate()Mark the network as in need of a new calculation to determine the pressure-dependent rate coefficients

labelGet the label for this network (analogous to reaction families as a reaction’s source)

mapDensitiesOfStates()Map the overall densities of states to the current energy grains. Semi-logarithmic interpolation will beused if the grain sizes of Elist0 and Elist do not match; this should not be a significant source of error aslong as the grain sizes are sufficiently small.

merge(other)Merge the partial network other into this network.

printSummary(level=20)Print a formatted list of information about the current network. Each molecular configuration - unimolec-ular isomers, bimolecular reactant channels, and bimolecular product channels - is given along with itsenergy on the potential energy surface. The path reactions connecting adjacent molecular configurationsare also given, along with their energies on the potential energy surface. The level parameter controls thelevel of logging to which the summary is written, and is DEBUG by default.

selectEnergyGrains(T, grainSize=0.0, grainCount=0)Select a suitable list of energies to use for subsequent calculations. This is done by finding the minimumand maximum energies on the potential energy surface, then adding a multiple of kBT onto the maximumenergy.



You must specify either the desired grain spacing grainSize in J/mol or the desired number of grainsNgrains, as well as a temperature T in K to use for the equilibrium calculation. You can specify bothgrainSize and grainCount, in which case the one that gives the more accurate result will be used (i.e. theyrepresent a maximum grain size and a minimum number of grains). An array containing the energy grainsin J/mol is returned.

setConditions(T, P, ymB=None)Set the current network conditions to the temperature T in K and pressure P in Pa. All of the internalvariables are updated accordingly if they are out of date. For example, those variables that depend only ontemperature will not be recomputed if the temperature is the same.

solveFullME(tlist, x0)Directly solve the full master equation using a stiff ODE solver. Pass the reaction network to solve, thetemperature T in K and pressure P in Pa to solve at, the energies Elist in J/mol to use, the output time pointstlist in s, the initial total populations x0, the full master equation matrix M, the accounting matrix indicesrelating isomer and energy grain indices to indices of the master equation matrix, and the densities of statesdensStates in mol/J of each isomer. Returns the times in s, population distributions for each isomer, andtotal population profiles for each configuration.

solveReducedME(tlist, x0)Directly solve the reduced master equation using a stiff ODE solver. Pass the output time points tlist in sand the initial total populations x0. Be sure to run one of the methods for generating k(T, P ) values beforecalling this method. Returns the times in s, population distributions for each isomer, and total populationprofiles for each configuration.

update(reactionModel, pdepSettings)Regenerate the k(T, P ) values for this partial network if the network is marked as invalid.

updateConfigurations(reactionModel)Sort the reactants and products of each of the network’s path reactions into isomers, reactant channels, andproduct channels. You must pass the current reactionModel because some decisions on sorting are madebased on which species are in the model core.

rmgpy.rmg.pdep.PDepReaction

class rmgpy.rmg.pdep.PDepReaction(index=-1, label=’‘, reactants=None, products=None, net-work=None, kinetics=None, reversible=True, transition-State=None, duplicate=False, degeneracy=1, pairs=None)

calculateMicrocanonicalRateCoefficient()Calculate the microcanonical rate coefficient k(E) for the reaction reaction at the energies Elist in J/mol.reacDensStates and prodDensStates are the densities of states of the reactant and product configurationsfor this reaction. If the reaction is irreversible, only the reactant density of states is required; if the reactionis reversible, then both are required. This function will try to use the best method that it can based on theinput data available:







k(T ) = κ(T )kBT

h

Q‡(T )

QA(T )QB(T )exp

(− E0

kBT

























getSource()Get the source of this PDepReaction

















rmgpy.rmg.model.Species

class rmgpy.rmg.model.Species(index=-1, label=’‘, thermo=None, conformer=None, molecule=None,transportData=None, molecularWeight=None, energyTransfer-Model=None, reactive=True, props=None, coreSizeAtCreation=0)



copy()Create a copy of the current species. If the kw argument ‘deep’ is True, then a deep copy will be made ofthe Molecule objects in self.molecule.

For other complex attributes, a deep copy will always be made.

fromAdjacencyList()Load the structure of a species as a Molecule object from the given adjacency list adjlist and store it as thefirst entry of a list in the molecule attribute. Does not generate resonance isomers of the loaded molecule.

fromSMILES()Load the structure of a species as a Molecule object from the given SMILES string smiles and store itas the first entry of a list in the molecule attribute. Does not generate resonance isomers of the loadedmolecule.

generateEnergyTransferModel()Generate the collisional energy transfer model parameters for the species. This “algorithm” is very muchin need of improvement.

generateResonanceIsomers()Generate all of the resonance isomers of this species. The isomers are stored as a list in the moleculeattribute. If the length of molecule is already greater than one, it is assumed that all of the resonanceisomers have already been generated.



generateStatMech()Generate molecular degree of freedom data for the species. You must have already provided a thermody-namics model using e.g. generateThermoData().

generateTransportData()Generate the transportData parameters for the species.

getDensityOfStates()Return the density of states ρ(E) dE at the specified energies Elist in J/mol above the ground state.

getEnthalpy()Return the enthalpy in J/mol for the species at the specified temperature T in K.

getEntropy()Return the entropy in J/mol*K for the species at the specified temperature T in K.

getFreeEnergy()Return the Gibbs free energy in J/mol for the species at the specified temperature T in K.

getHeatCapacity()Return the heat capacity in J/mol*K for the species at the specified temperature T in K.

getPartitionFunction()Return the partition function for the species at the specified temperature T in K.

getSumOfStates()Return the sum of states N(E) at the specified energies Elist in J/mol.

getSymmetryNumber()Get the symmetry number for the species, which is the highest symmetry number amongst its resonanceisomers. This function is currently used for website purposes and testing only as it requires additionalcalculateSymmetryNumber calls.

getThermoData()Returns a thermoData object of the current Species object.

If the thermo object already exists, it is either of the (Wilhoit, ThermoData) type, or it is a Future.

If the type of the thermo attribute is Wilhoit, or ThermoData, then it is converted into a NASA format.

If it is a Future, then a blocking call is made to retrieve the NASA object. If the thermo object did not existyet, the thermo object is generated.

getTransportData()Returns the transport data associated with this species, and calculates it if it is not yet available.

hasStatMech()Return True if the species has statistical mechanical parameters, or False otherwise.

hasThermo()Return True if the species has thermodynamic parameters, or False otherwise.

isIsomorphic()Return True if the species is isomorphic to other, which can be either a Molecule object or a Speciesobject.

toAdjacencyList()Return a string containing each of the molecules’ adjacency lists.

toCantera()Converts the RMG Species object to a Cantera Species object with the appropriate thermo data.

toChemkin()Return the chemkin-formatted string for this species.



1.12 Reaction system simulation (rmgpy.solver)

The rmgpy.solver module contains classes used to represent and simulate reaction systems.

1.12.1 Reaction systems

Class DescriptionReactionSystem Base class for all reaction systemsSimpleReactor A simple isothermal, isobaric, well-mixed batch reactor

1.12.2 Termination criteria

Class DescriptionTerminationTime Represent a time at which the simulation should be terminatedTerminationConversion Represent a species conversion at which the simulation should be terminated

rmgpy.solver.ReactionSystem

class rmgpy.solver.ReactionSystemA base class for all RMG reaction systems.

advance()Simulate from the current value of the independent variable to a specified value tout, taking as many stepsas necessary. The resulting values of t, y, and dy

dt can then be accessed via the t, y, and dydt attributes.

computeRateDerivative()Returns derivative vector df/dk_j where dy/dt = f(y, t, k) and k_j is the rate parameter for the jth corereaction.

compute_network_variables()Initialize the arrays containing network information:

•NetworkLeakCoefficients is a n x 1 array with n the number of pressure-dependent networks.

•NetworkIndices is a n x 3 matrix with n the number of pressure-dependent networks and 3 themaximum number of molecules allowed in either the reactant or product side of a reaction.

generate_reactant_product_indices()Creates a matrix for the reactants and products.

generate_reaction_indices()Assign an index to each reaction (core first, then edge) and store the (reaction, index) pair in a dictionary.

generate_species_indices()Assign an index to each species (core first, then edge) and store the (species, index) pair in a dictionary.

get_species_index()Retrieves the index that is associated with the parameter species from the species index dictionary.

initialize()Initialize the DASPK solver by setting the initial values of the independent variable t0, dependent variablesy0, and first derivatives dydt0. If provided, the derivatives must be consistent with the other initial condi-tions; if not provided, DASPK will attempt to estimate a consistent set of initial values for the derivatives.You can also set the absolute and relative tolerances atol and rtol, respectively, either as single values forall dependent variables or individual values for each dependent variable.

1.12. Reaction system simulation (rmgpy.solver) 157


initializeModel()Initialize a simulation of the reaction system using the provided kinetic model. You will probably want tocreate your own version of this method in the derived class; don’t forget to also call the base class version,too.

initiate_tolerances()Computes the number of differential equations and initializes the tolerance arrays.

logConversions()Log information about the current conversion values.

logRates()Log information about the current maximum species and network rates.

residual()Evaluate the residual function for this model, given the current value of the independent variable t, depen-dent variables y, and first derivatives dydt. Return a numpy array with the values of the residual functionand an integer with status information (0 if okay, -2 to terminate).

set_initial_conditions()Sets the common initial conditions of the rate equations that represent the reaction system.

•Sets the initial time of the reaction system to 0

•Initializes the species moles to a n x 1 array with zeros

set_initial_derivative()Sets the derivative of the species moles with respect to the independent variable (time) equal to the residual.

simulate()Simulate the reaction system with the provided reaction model, consisting of lists of core species, core re-actions, edge species, and edge reactions. As the simulation proceeds the system is monitored for validity.If the model becomes invalid (e.g. due to an excessively large edge flux), the simulation is interrupted andthe object causing the model to be invalid is returned. If the simulation completes to the desired terminationcriteria and the model remains valid throughout, None is returned.

step()Perform one simulation step from the current value of the independent variable toward (but not past) aspecified value tout. The resulting values of t, y, and dy

dt can then be accessed via the t, y, and dydtattributes.

rmgpy.solver.SimpleReactor

class rmgpy.solver.SimpleReactorA reaction system consisting of a homogeneous, isothermal, isobaric batch reactor. These assumptions allowfor a number of optimizations that enable this solver to complete very rapidly, even for large kinetic models.

advance()Simulate from the current value of the independent variable to a specified value tout, taking as many stepsas necessary. The resulting values of t, y, and dy

dt can then be accessed via the t, y, and dydt attributes.

calculate_effective_pressure()

Computes the effective pressure for a reaction as: Peff = P * sum(yi * effi / sum(y))

with:

• P the pressure of the reactor,

• y the array of initial moles of the core species



computeRateDerivative()Returns derivative vector df/dk_j where dy/dt = f(y, t, k) and k_j is the rate parameter for the jth corereaction.

compute_network_variables()Initialize the arrays containing network information:

•NetworkLeakCoefficients is a n x 1 array with n the number of pressure-dependent networks.

•NetworkIndices is a n x 3 matrix with n the number of pressure-dependent networks and 3 themaximum number of molecules allowed in either the reactant or product side of a reaction.

convertInitialKeysToSpeciesObjects()Convert the initialMoleFractions dictionary from species names into species objects, using the given dic-tionary of species.

generate_rate_coefficients()Populates the forward rate coefficients (kf), reverse rate coefficients (kb) and equilibrium constants (Keq)arrays with the values computed at the temperature and (effective) pressure of the reacion system.

generate_reactant_product_indices()Creates a matrix for the reactants and products.

generate_reaction_indices()Assign an index to each reaction (core first, then edge) and store the (reaction, index) pair in a dictionary.

generate_species_indices()Assign an index to each species (core first, then edge) and store the (species, index) pair in a dictionary.

get_species_index()Retrieves the index that is associated with the parameter species from the species index dictionary.

initialize()Initialize the DASPK solver by setting the initial values of the independent variable t0, dependent variablesy0, and first derivatives dydt0. If provided, the derivatives must be consistent with the other initial condi-tions; if not provided, DASPK will attempt to estimate a consistent set of initial values for the derivatives.You can also set the absolute and relative tolerances atol and rtol, respectively, either as single values forall dependent variables or individual values for each dependent variable.

initializeModel()Initialize a simulation of the simple reactor using the provided kinetic model.

initiate_tolerances()Computes the number of differential equations and initializes the tolerance arrays.

jacobian()Return the analytical Jacobian for the reaction system.

logConversions()Log information about the current conversion values.

logRates()Log information about the current maximum species and network rates.

residual()Return the residual function for the governing DAE system for the simple reaction system.

set_colliders()Store collider efficiencies and reaction indices for pdep reactions that have specific collider efficiencies.

set_initial_conditions()Sets the initial conditions of the rate equations that represent the current reactor model.

1.12. Reaction system simulation (rmgpy.solver) 159


The volume is set to the value derived from the ideal gas law, using the user-defined pressure, temperature,and the number of moles of initial species.

The species moles array (y0) is set to the values stored in the initial mole fractions dictionary.

The initial species concentration is computed and stored in the coreSpeciesConcentrations array.

set_initial_derivative()Sets the derivative of the species moles with respect to the independent variable (time) equal to the residual.

simulate()Simulate the reaction system with the provided reaction model, consisting of lists of core species, core re-actions, edge species, and edge reactions. As the simulation proceeds the system is monitored for validity.If the model becomes invalid (e.g. due to an excessively large edge flux), the simulation is interrupted andthe object causing the model to be invalid is returned. If the simulation completes to the desired terminationcriteria and the model remains valid throughout, None is returned.

step()Perform one simulation step from the current value of the independent variable toward (but not past) aspecified value tout. The resulting values of t, y, and dy

dt can then be accessed via the t, y, and dydtattributes.

Termination criteria

class rmgpy.solver.TerminationTimeRepresent a time at which the simulation should be terminated. This class has one attribute: the terminationtime in seconds.

class rmgpy.solver.TerminationConversionRepresent a conversion at which the simulation should be terminated. This class has two attributes: the speciesto monitor and the fractional conversion at which to terminate.

1.13 Species (rmgpy.species)

The rmgpy.species subpackage contains classes and functions for working with chemical species.

1.13.1 Species

Class DescriptionSpecies A chemical species

1.13.2 Transition state

Class DescriptionTransitionState A transition state

1.13.3 Exceptions

Class DescriptionSpeciesError Raised when an error occurs while working with species



rmgpy.species.Species

class rmgpy.species.SpeciesA chemical species, representing a local minimum on a potential energy surface. The attributes are:

Attribute Descriptionindex A unique nonnegative integer indexlabel A descriptive string labelthermo The heat capacity model for the speciesconformer The molecular conformer for the speciesmolecule A list of the Molecule objects describing the molec-

ular structuretransportData A set of transport collision parametersmolecularWeight The molecular weight of the speciesenergyTransferModel The collisional energy transfer model to usereactive

True if the species participates in reaction families, False if notReaction libraries and seed mechanisms thatinclude the species are always consideredregardless of this variable

props A generic ‘properties’ dictionary to store user-defined flags

aug_inchi Unique augmented inchi

note: rmg.model.Species inherits from this class, and adds some extra methods.



copy()Create a copy of the current species. If the kw argument ‘deep’ is True, then a deep copy will be made ofthe Molecule objects in self.molecule.

For other complex attributes, a deep copy will always be made.

fromAdjacencyList()Load the structure of a species as a Molecule object from the given adjacency list adjlist and store it as thefirst entry of a list in the molecule attribute. Does not generate resonance isomers of the loaded molecule.

fromSMILES()Load the structure of a species as a Molecule object from the given SMILES string smiles and store itas the first entry of a list in the molecule attribute. Does not generate resonance isomers of the loadedmolecule.

generateEnergyTransferModel()Generate the collisional energy transfer model parameters for the species. This “algorithm” is very muchin need of improvement.

generateResonanceIsomers()Generate all of the resonance isomers of this species. The isomers are stored as a list in the moleculeattribute. If the length of molecule is already greater than one, it is assumed that all of the resonanceisomers have already been generated.

generateStatMech()

1.13. Species (rmgpy.species) 161


Generate molecular degree of freedom data for the species. You must have already provided a thermody-namics model using e.g. generateThermoData().

generateTransportData()Generate the transportData parameters for the species.


getEnthalpy()Return the enthalpy in J/mol for the species at the specified temperature T in K.

getEntropy()Return the entropy in J/mol*K for the species at the specified temperature T in K.

getFreeEnergy()Return the Gibbs free energy in J/mol for the species at the specified temperature T in K.

getHeatCapacity()Return the heat capacity in J/mol*K for the species at the specified temperature T in K.

getPartitionFunction()Return the partition function for the species at the specified temperature T in K.


getSymmetryNumber()Get the symmetry number for the species, which is the highest symmetry number amongst its resonanceisomers. This function is currently used for website purposes and testing only as it requires additionalcalculateSymmetryNumber calls.

getThermoData()Returns a thermoData object of the current Species object.

If the thermo object already exists, it is either of the (Wilhoit, ThermoData) type, or it is a Future.

If the type of the thermo attribute is Wilhoit, or ThermoData, then it is converted into a NASA format.

If it is a Future, then a blocking call is made to retrieve the NASA object. If the thermo object did not existyet, the thermo object is generated.

getTransportData()Returns the transport data associated with this species, and calculates it if it is not yet available.

hasStatMech()Return True if the species has statistical mechanical parameters, or False otherwise.

hasThermo()Return True if the species has thermodynamic parameters, or False otherwise.

isIsomorphic()Return True if the species is isomorphic to other, which can be either a Molecule object or a Speciesobject.

toAdjacencyList()Return a string containing each of the molecules’ adjacency lists.

toCantera()Converts the RMG Species object to a Cantera Species object with the appropriate thermo data.

toChemkin()Return the chemkin-formatted string for this species.



rmgpy.species.TransitionState

class rmgpy.species.TransitionStateA chemical transition state, representing a first-order saddle point on a potential energy surface. The attributesare:

Attribute TDescriptionlabel A descriptive string labelconformer The molecular degrees of freedom model for the speciesfrequency The negative frequency of the first-order saddle pointtunneling The type of tunneling model to use for tunneling through the reaction barrierdegeneracy The reaction path degeneracy

calculateTunnelingFactor()Calculate and return the value of the canonical tunneling correction factor for the reaction at the giventemperature T in K.

calculateTunnelingFunction()Calculate and return the value of the microcanonical tunneling correction for the reaction at the givenenergies Elist in J/mol.


getEnthalpy()Return the enthalpy in J/mol for the transition state at the specified temperature T in K.

getEntropy()Return the entropy in J/mol*K for the transition state at the specified temperature T in K.

getFreeEnergy()Return the Gibbs free energy in J/mol for the transition state at the specified temperature T in K.

getHeatCapacity()Return the heat capacity in J/mol*K for the transition state at the specified temperature T in K.

getPartitionFunction()Return the partition function for the transition state at the specified temperature T in K.


1.14 Statistical mechanics (rmgpy.statmech)

The rmgpy.statmech subpackage contains classes that represent various statistical mechanical models of moleculardegrees of freedom. These models enable the computation of macroscopic parameters (e.g. thermodynamics, kinetics,etc.) from microscopic parameters.

A molecular system consisting of N atoms is described by 3N molecular degrees of freedom. Three of these modesinvolve translation of the system as a whole. Another three of these modes involve rotation of the system as a whole,unless the system is linear (e.g. diatomics), for which there are only two rotational modes. The remaining 3N − 6(or 3N − 5 if linear) modes involve internal motion of the atoms within the system. Many of these modes are well-described as harmonic oscillations, while others are better modeled as torsional rotations around a bond within thesystem.

Molecular degrees of freedom are mathematically represented using the Schrodinger equation HΨ = EΨ. By solvingthe Schrodinger equation, we can determine the available energy states of the molecular system, which enables com-

1.14. Statistical mechanics (rmgpy.statmech) 163


putation of macroscopic parameters. Depending on the temperature of interest, some modes (e.g. vibrations) requirea quantum mechanical treatment, while others (e.g. translation, rotation) can be described using a classical solution.

1.14.1 Translational degrees of freedom

Class DescriptionIdealGasTranslation A model of three-dimensional translation of an ideal gas

1.14.2 Rotational degrees of freedom

Class DescriptionLinearRotor A model of two-dimensional rigid rotation of a linear moleculeNonlinearRotor A model of three-dimensional rigid rotation of a nonlinear moleculeKRotor A model of one-dimensional rigid rotation of a K-rotorSphericalTopRotor A model of three-dimensional rigid rotation of a spherical top molecule

1.14.3 Vibrational degrees of freedom

Class DescriptionHarmonicOscillator A model of a set of one-dimensional harmonic oscillators

1.14.4 Torsional degrees of freedom

Class DescriptionHinderedRotor A model of a one-dimensional hindered rotation

1.14.5 The Schrodinger equation

Class DescriptiongetPartitionFunction()Calculate the partition function at a given temperature from energy levels and

degeneraciesgetHeatCapacity() Calculate the dimensionless heat capacity at a given temperature from energy levels

and degeneraciesgetEnthalpy() Calculate the enthalpy at a given temperature from energy levels and degeneraciesgetEntropy() Calculate the entropy at a given temperature from energy levels and degeneraciesgetSumOfStates() Calculate the sum of states for a given energy domain from energy levels and

degeneraciesgetDensityOfStates() Calculate the density of states for a given energy domain from energy levels and

degeneracies



1.14.6 Convolution

Class Descriptionconvolve() Return the convolution of two arraysconvolveBS()Convolve a degree of freedom into a density or sum of states using the Beyer-Swinehart (BS)

direct count algorithmconvolveBSSR()Convolve a degree of freedom into a density or sum of states using the

Beyer-Swinehart-Stein-Rabinovitch (BSSR) direct count algorithm

1.14.7 Molecular conformers

Class DescriptionConformer A model of a molecular conformation

Translational degrees of freedom

class rmgpy.statmech.IdealGasTranslation(mass=None, quantum=False)A statistical mechanical model of translation in an 3-dimensional infinite square well by an ideal gas. Theattributes are:

Attribute Descriptionmass The mass of the translating objectquantum True to use the quantum mechanical model, False to use the classical model

Translational energies are much smaller than kBT except for temperatures approaching absolute zero, so aclassical treatment of translation is more than adequate.

The translation of an ideal gas – a gas composed of randomly-moving, noninteracting particles of negligiblesize – in three dimensions can be modeled using the particle-in-a-box model. In this model, a gas particle isconfined to a three-dimensional box of size LxLyLz = V with the following potential:

V (x, y, z) =

{0 0 ≤ x ≤ Lx, 0 ≤ y ≤ Ly, 0 ≤ z ≤ Lz∞ otherwise

The time-independent Schrodinger equation for this system (within the box) is given by

− ~2

2M

(∂2

∂x2+

∂2

∂y2+

∂2

∂z2

)Ψ(x, y, z) = EΨ(x, y, z)

where M is the total mass of the particle. Because the box is finite in all dimensions, the solution of the aboveis quantized with the following energy levels:

Enx,ny,nz =~2

2M

[(nxπ

Lx

)2

+

(nyπ

Ly

)2

+

(nzπ

Lz

)2]

nx, ny, nz = 1, 2, . . .

Above we have introduced nx, ny , and nz as quantum numbers. The quantum mechanical partition function isobtained by summing over the above energy levels:

Qtrans(T ) =

∞∑nx=1

∞∑ny=1

∞∑nz=1

exp

(−Enx,ny,nz

kBT

)In almost all cases the temperature of interest is large relative to the energy spacing; in this limit we can obtaina closed-form analytical expression for the translational partition function in the classical limit:

Qcltrans(T ) =

(2πMkBT

h2

)3/2

V



For a constant-pressure problem we can use the ideal gas law to replace V with kBT/P . This gives the partitionfunction a temperature dependence of T 5/2.

getDensityOfStates(self, ndarray Elist, ndarray densStates0=None)→ ndarrayReturn the density of states ρ(E) dE at the specified energies Elist in J/mol above the ground state. If aninitial density of states densStates0 is given, the rotor density of states will be convoluted into these states.

getEnthalpy(self, double T)→ doubleReturn the enthalpy in J/mol for the degree of freedom at the specified temperature T in K.

getEntropy(self, double T)→ doubleReturn the entropy in J/mol*K for the degree of freedom at the specified temperature T in K.

getHeatCapacity(self, double T)→ doubleReturn the heat capacity in J/mol*K for the degree of freedom at the specified temperature T in K.

getPartitionFunction(self, double T)→ doubleReturn the value of the partition function Q(T ) at the specified temperature T in K.

getSumOfStates(self, ndarray Elist, ndarray sumStates0=None)→ ndarrayReturn the sum of states N(E) at the specified energies Elist in J/mol above the ground state. If an initialsum of states sumStates0 is given, the rotor sum of states will be convoluted into these states.

massThe mass of the translating object.

quantumquantum: ‘bool’

rmgpy.statmech.LinearRotor

class rmgpy.statmech.LinearRotor(inertia=None, symmetry=1, quantum=False, rotationalCon-stant=None)

A statistical mechanical model of a two-dimensional (linear) rigid rotor. The attributes are:

Attribute Descriptioninertia The moment of inertia of the rotorrotationalConstant The rotational constant of the rotorsymmetry The symmetry number of the rotorquantum True to use the quantum mechanical model, False to use the classical model

Note that the moment of inertia and the rotational constant are simply two ways of representing the samequantity; only one of these can be specified independently.

In the majority of chemical applications, the energies involved in the rigid rotor place it very nearly in theclassical limit at all relevant temperatures; therefore, the classical model is used by default.

A linear rigid rotor is modeled as a pair of point masses m1 and m2 separated by a distance R. Since weare modeling the rotation of this system, we choose to work in spherical coordinates. Following the physicsconvention – where 0 ≤ θ ≤ π is the zenith angle and 0 ≤ φ ≤ 2π is the azimuth – the Schrodinger equationfor the rotor is given by

−~2

2I

[1

sin θ

∂

∂θ

(sin θ

∂

∂θ

)+

1

sin2 θ

∂2

∂φ2

]Ψ(θ, φ) = EΨ(θ, φ)

where I ≡ µR2 is the moment of inertia of the rotating body, and µ ≡ m1m2/(m1 +m2) is the reduced mass.Note that there is no potential term in the above expression; for this reason, a rigid rotor is often referred to as afree rotor. Solving the Schrodinger equation gives the energy levels EJ and corresponding degeneracies gJ for



the linear rigid rotor as

EJ = BJ(J + 1) J = 0, 1, 2, . . .

gJ = 2J + 1

where J is the quantum number for the rotor – sometimes called the total angular momentum quantum number– and B ≡ ~2/2I is the rotational constant.

Using these expressions for the energy levels and corresponding degeneracies, we can evaluate the partitionfunction for the linear rigid rotor:

Qrot(T ) =1

σ

∞∑J=0

(2J + 1)e−BJ(J+1)/kBT

In many cases the temperature of interest is large relative to the energy spacing; in this limit we can obtain aclosed-form analytical expression for the linear rotor partition function in the classical limit:

Qclrot(T ) =

1

σ

8π2IkBT

h2

Above we have also introduced σ as the symmetry number of the rigid rotor.





getLevelDegeneracy(self, int J)→ intReturn the degeneracy of level J.

getLevelEnergy(self, int J)→ doubleReturn the energy of level J in kJ/mol.



inertiaThe moment of inertia of the rotor.


rotationalConstantThe rotational constant of the rotor.

symmetrysymmetry: ‘int’



rmgpy.statmech.NonlinearRotor

class rmgpy.statmech.NonlinearRotor(inertia=None, symmetry=1, quantum=False, rotationalCon-stant=None)

A statistical mechanical model of an N-dimensional nonlinear rigid rotor. The attributes are:

Attribute Descriptioninertia The moments of inertia of the rotorrotationalConstant The rotational constants of the rotorsymmetry The symmetry number of the rotorquantum True to use the quantum mechanical model, False to use the classical model

Note that the moments of inertia and the rotational constants are simply two ways of representing the samequantity; only one set of these can be specified independently.

In the majority of chemical applications, the energies involved in the rigid rotor place it very nearly in theclassical limit at all relevant temperatures; therefore, the classical model is used by default. In the currentimplementation, the quantum mechanical model has not been implemented, and a NotImplementedErrorwill be raised if you try to use it.

A nonlinear rigid rotor is the generalization of the linear rotor to a nonlinear polyatomic system. Such a systemis characterized by three moments of inertia IA, IB, and IC instead of just one. The solution to the Schrodingerequation for the quantum nonlinear rotor is not well defined, so we will simply show the classical result instead:

Qclrot(T ) =

π1/2

σ

(8kBT

h2

)3/2√IAIBIC







inertiaThe moments of inertia of the rotor.






rmgpy.statmech.KRotor

class rmgpy.statmech.KRotor(inertia=None, symmetry=1, quantum=False, rotationalConstant=None)A statistical mechanical model of an active K-rotor (a one-dimensional rigid rotor). The attributes are:

Attribute Descriptioninertia The moment of inertia of the rotor in amu*angstrom^2rotationalConstant The rotational constant of the rotor in cm^-1symmetry The symmetry number of the rotorquantum True to use the quantum mechanical model, False to use the classical model


In the majority of chemical applications, the energies involved in the K-rotor place it very nearly in the classicallimit at all relevant temperatures; therefore, the classical model is used by default.

The energy levels EK of the K-rotor are given by

EK = BK2 K = 0,±1,±2, . . .

where K is the quantum number for the rotor and B ≡ ~2/2I is the rotational constant.

Using these expressions for the energy levels and corresponding degeneracies, we can evaluate the partitionfunction for the K-rotor:

Qrot(T ) =1

σ

(1 +

∞∑K=1

2e−BK2/kBT

)In many cases the temperature of interest is large relative to the energy spacing; in this limit we can obtain aclosed-form analytical expression for the linear rotor partition function in the classical limit:

Qclrot(T ) =

1

σ

(8π2IkBT

h2

)1/2

where σ is the symmetry number of the K-rotor.















rmgpy.statmech.SphericalTopRotor

class rmgpy.statmech.SphericalTopRotor(inertia=None, symmetry=1, quantum=False, rotationalCon-stant=None)

A statistical mechanical model of a three-dimensional rigid rotor with a single rotational constant: a sphericaltop. The attributes are:

Attribute Descriptioninertia The moment of inertia of the rotorrotationalConstant The rotational constant of the rotorsymmetry The symmetry number of the rotorquantum True to use the quantum mechanical model, False to use the classical model


In the majority of chemical applications, the energies involved in the rigid rotor place it very nearly in theclassical limit at all relevant temperatures; therefore, the classical model is used by default.

A spherical top rotor is simply the three-dimensional equivalent of a linear rigid rotor. Unlike the nonlinearrotor, all three moments of inertia of a spherical top are equal, i.e. IA = IB = IC = I . The energy levels EJand corresponding degeneracies gJ of the spherial top rotor are given by

EJ = BJ(J + 1) J = 0, 1, 2, . . .

gJ = (2J + 1)2

where J is the quantum number for the rotor and B ≡ ~2/2I is the rotational constant.

Using these expressions for the energy levels and corresponding degeneracies, we can evaluate the partitionfunction for the spherical top rotor:

Qrot(T ) =1

σ

∞∑J=0

(2J + 1)2e−BJ(J+1)/kBT

In many cases the temperature of interest is large relative to the energy spacing; in this limit we can obtain aclosed-form analytical expression for the linear rotor partition function in the classical limit:

Qclrot(T ) =

1

σ

(8π2IkBT

h2

)3/2

where σ is the symmetry number of the spherical top. Note that the above differs from the nonlinear rotorpartition function by a factor of π.















rmgpy.statmech.HarmonicOscillator

class rmgpy.statmech.HarmonicOscillator(frequencies=None, quantum=True)A statistical mechanical model of a set of one-dimensional independent harmonic oscillators. The attributes are:

Attribute Descriptionfrequencies The vibrational frequencies of the oscillatorsquantum True to use the quantum mechanical model, False to use the classical model

In the majority of chemical applications, the energy levels of the harmonic oscillator are of similar magnitude tokBT , requiring a quantum mechanical treatment. Fortunately, the harmonic oscillator has an analytical quantummechanical solution.

Many vibrational motions are well-described as one-dimensional quantum harmonic oscillators. The time-independent Schrodinger equation for such an oscillator is given by

− ~2

2m

∂2

∂x2Ψ(x) +

1

2mω2x2Ψ(x) = EΨ(x)

wherem is the total mass of the particle. The harmonic potential results in quantized solutions to the above withthe following energy levels:

En =

(n+

1

2

)~ω n = 0, 1, 2, . . .

Above we have introduced n as the quantum number. Note that, even in the ground state (n = 0), the harmonicoscillator has an energy that is not zero; this energy is called the zero-point energy.



The harmonic oscillator partition function is obtained by summing over the above energy levels:

Qvib(T ) =

∞∑n=0

exp

(−(n+ 1

2

)~ω

kBT

)

This summation can be evaluated explicitly to give a closed-form analytical expression for the vibrational parti-tion function of a quantum harmonic oscillator:

Qvib(T ) =e−~ω/2kBT

1− e−~ω/kBT

In RMG the convention is to place the zero-point energy in with the ground-state energy of the system insteadof the numerator of the vibrational partition function, which gives

Qvib(T ) =1

1− e−~ω/kBT

The energy levels of the harmonic oscillator in chemical systems are often significant compared to the tem-perature of interest, so we usually use the quantum result. However, the classical limit is provided here forcompleteness:

Qclvib(T ) =

kBT

~ω

frequenciesThe vibrational frequencies of the oscillators.








Torsional degrees of freedom

class rmgpy.statmech.HinderedRotor(inertia=None, symmetry=1, barrier=None, fourier=None, rota-tionalConstant=None, quantum=False, semiclassical=True)

A statistical mechanical model of a one-dimensional hindered rotor. The attributes are:



Attribute Descriptioninertia The moment of inertia of the rotorrotationalConstant The rotational constant of the rotorsymmetry The symmetry number of the rotorfourier The 2xN array of Fourier series coefficientsbarrier The barrier height of the cosine potentialquantum True to use the quantum mechanical model, False to use the classical modelsemiclassical True to use the semiclassical correction, False otherwise


The Schrodinger equation for a one-dimensional hindered rotor is given by

−~2

2I

d2

dφ2Ψ(φ) + V (φ)Ψ(φ) = EΨ(φ)

where I is the reduced moment of inertia of the torsion and V (φ) describes the potential of the torsion. Thereare two common forms for the potential: a simple cosine of the form

V (φ) =1

2V0 (1− cosσφ)

where V0 is the barrier height and σ is the symmetry number, or a more general Fourier series of the form

V (φ) = A+

C∑k=1

(ak cos kφ+ bk sin kφ)

where A, ak and bk are fitted coefficients. Both potentials are typically defined such that the minimum of thepotential is zero and is found at φ = 0.

For either the cosine or Fourier series potentials, the energy levels of the quantum hindered rotor must bedetermined numerically. The cosine potential does permit a closed-form representation of the classical partitionfunction, however:

Qclhind(T ) =

(2πIkBT

h2

)1/22π

σexp

(− V0

2kBT

)I0

(V0

2kBT

)A semiclassical correction to the above is usually required to provide a reasonable estiamate of the partitionfunction:

Qsemihind(T ) =

Qquantvib (T )

Qclvib(T )

Qclhind(T )

=hν

kBT

1

1− exp (−hν/kBT )

(2πIkBT

h2

)1/22π

σexp

(− V0

2kBT

)I0

(V0

2kBT

)Above we have defined ν as the vibrational frequency of the hindered rotor:

ν ≡ σ

2π

√V02I

barrierThe barrier height of the cosine potential.

energiesenergies: numpy.ndarray



fitCosinePotentialToData(self, ndarray angle, ndarray V)Fit the given angles in radians and corresponding potential energies in J/mol to the cosine potential. Forbest results, the angle should begin at zero and end at 2π, with the minimum energy conformation havinga potential of zero be placed at zero angle. The fit is attempted at several possible values of the symmetrynumber in order to determine which one is correct.

fitFourierPotentialToData(self, ndarray angle, ndarray V)Fit the given angles in radians and corresponding potential energies in J/mol to the Fourier series potential.For best results, the angle should begin at zero and end at 2π, with the minimum energy conformationhaving a potential of zero be placed at zero angle.

fourierThe 2xN array of Fourier series coefficients.

frequencyfrequency: ‘double’




getFrequency(self)→ doubleReturn the frequency of vibration in cm^-1 corresponding to the limit of harmonic oscillation.

getHamiltonian(self, int Nbasis)→ ndarrayReturn the to the Hamiltonian matrix for the hindered rotor for the given number of basis functions Nbasis.The Hamiltonian matrix is returned in banded lower triangular form and with units of J/mol.



getLevelEnergy(self, int J)→ doubleReturn the energy of level J in J.


getPotential(self, double phi)→ doubleReturn the value of the hindered rotor potential V (φ) in J/mol at the angle phi in radians.







semiclassicalsemiclassical: ‘bool’

solveSchrodingerEquation(self, int Nbasis=401)→ ndarraySolves the one-dimensional time-independent Schrodinger equation to determine the energy levels of aone-dimensional hindered rotor with a Fourier series potential using Nbasis basis functions. For the pur-poses of this function it is usually sufficient to use 401 basis functions (the default). Returns the energyeigenvalues of the Hamiltonian matrix in J/mol.


rmgpy.statmech.schrodinger

The rmgpy.statmech.schrodinger module contains functionality for working with the Schrodinger equation andits solution. In particular, it contains functions for using the energy levels and corresponding degeneracies obtainedfrom solving the Schrodinger equation to compute various thermodynamic and statistical mechanical properties, suchas heat capacity, enthalpy, entropy, partition function, and the sum and density of states.

rmgpy.statmech.schrodinger.convolve(ndarray rho1, ndarray rho2)Return the convolution of two arrays rho1 and rho2.

rmgpy.statmech.schrodinger.convolveBS(ndarray Elist, ndarray rho0, double energy, int degener-acy=1)

Convolve a molecular degree of freedom into a density or sum of states using the Beyer-Swinehart (BS) directcount algorithm. This algorithm is suitable for unevenly-spaced energy levels in the array of energy grains Elist(in J/mol), but assumes the solution of the Schrodinger equation gives evenly-spaced energy levels with spacingenergy in kJ/mol and degeneracy degeneracy.

rmgpy.statmech.schrodinger.convolveBSSR(ndarray Elist, ndarray rho0, energy, degener-acy=unitDegeneracy, int n0=0)

Convolve a molecular degree of freedom into a density or sum of states using the Beyer-Swinehart-Stein-Rabinovitch (BSSR) direct count algorithm. This algorithm is suitable for unevenly-spaced energy levels in boththe array of energy grains Elist (in J/mol) and the energy levels corresponding to the solution of the Schrodingerequation.

rmgpy.statmech.schrodinger.getDensityOfStates(ndarray Elist, energy, degener-acy=unitDegeneracy, int n0=0, ndarraydensStates0=None)→ ndarray

Return the values of the dimensionless density of states ρ(E) dE for a given set of energies Elist in J/mol abovethe ground state using an initial density of states densStates0. The solution to the Schrodinger equation is givenusing functions energy and degeneracy that accept as argument a quantum number and return the correspondingenergy in J/mol and degeneracy of that level. The quantum number always begins at n0 and increases by ones.

rmgpy.statmech.schrodinger.getEnthalpy(double T, energy, degeneracy=unitDegeneracy, int n0=0,int nmax=10000, double tol=1e-12)→ double

Return the value of the dimensionless enthalpy H(T )/RT at a given temperature T in K. The solution to theSchrodinger equation is given using functions energy and degeneracy that accept as argument a quantum numberand return the corresponding energy in J/mol and degeneracy of that level. The quantum number always beginsat n0 and increases by ones. You can also change the relative tolerance tol and the maximum allowed value ofthe quantum number nmax.

rmgpy.statmech.schrodinger.getEntropy(double T, energy, degeneracy=unitDegeneracy, int n0=0,int nmax=10000, double tol=1e-12)→ double

Return the value of the dimensionless entropy S(T )/R at a given temperature T in K. The solution to theSchrodinger equation is given using functions energy and degeneracy that accept as argument a quantum numberand return the corresponding energy in J/mol and degeneracy of that level. The quantum number always begins



at n0 and increases by ones. You can also change the relative tolerance tol and the maximum allowed value ofthe quantum number nmax.

rmgpy.statmech.schrodinger.getHeatCapacity(double T, energy, degeneracy=unitDegeneracy, intn0=0, int nmax=10000, double tol=1e-12) → dou-ble

Return the value of the dimensionless heat capacity Cv(T )/R at a given temperature T in K. The solution tothe Schrodinger equation is given using functions energy and degeneracy that accept as argument a quantumnumber and return the corresponding energy in J/mol and degeneracy of that level. The quantum number alwaysbegins at n0 and increases by ones. You can also change the relative tolerance tol and the maximum allowedvalue of the quantum number nmax.

rmgpy.statmech.schrodinger.getPartitionFunction(double T, energy, degener-acy=unitDegeneracy, int n0=0, intnmax=10000, double tol=1e-12)→ double

Return the value of the partition function Q(T ) at a given temperature T in K. The solution to the Schrodingerequation is given using functions energy and degeneracy that accept as argument a quantum number and returnthe corresponding energy in J/mol and degeneracy of that level. The quantum number always begins at n0 andincreases by ones. You can also change the relative tolerance tol and the maximum allowed value of the quantumnumber nmax.

rmgpy.statmech.schrodinger.getSumOfStates(ndarray Elist, energy, degeneracy=unitDegeneracy,int n0=0, ndarray sumStates0=None)→ ndarray

Return the values of the sum of states N(E) for a given set of energies Elist in J/mol above the ground stateusing an initial sum of states sumStates0. The solution to the Schrodinger equation is given using functionsenergy and degeneracy that accept as argument a quantum number and return the corresponding energy in J/moland degeneracy of that level. The quantum number always begins at n0 and increases by ones.

rmgpy.statmech.schrodinger.unitDegeneracy(n)

rmgpy.statmech.Conformer

class rmgpy.statmech.Conformer(E0=None, modes=None, spinMultiplicity=1, opticalIsomers=1, num-ber=None, mass=None, coordinates=None)

A representation of an individual molecular conformation. The attributes are:

Attribute DescriptionE0 The ground-state energy (including zero-point energy) of the conformermodes A list of the molecular degrees of freedomspinMultiplicity The degeneracy of the electronic ground stateopticalIsomers The number of optical isomersnumber An array of atomic numbers of each atom in the conformermass An array of masses of each atom in the conformercoordinates An array of 3D coordinates of each atom in the conformer

Note that the spinMultiplicity reflects the electronic mode of the molecular system.

E0The ground-state energy (including zero-point energy) of the conformer.

coordinatesAn array of 3D coordinates of each atom in the conformer.

getActiveModes(self, bool activeJRotor=False, bool activeKRotor=True)→ listReturn a list of the active molecular degrees of freedom of the molecular system.

getCenterOfMass(self, atoms=None)→ ndarrayCalculate and return the [three-dimensional] position of the center of mass of the conformer in m. If a list



atoms of atoms is specified, only those atoms will be used to calculate the center of mass. Otherwise, allatoms will be used.

getDensityOfStates(self, ndarray Elist)→ ndarrayReturn the density of states ρ(E) dE at the specified energies Elist above the ground state.

getEnthalpy(self, double T)→ doubleReturn the enthalpy in J/mol for the system at the specified temperature T in K.

getEntropy(self, double T)→ doubleReturn the entropy in J/mol*K for the system at the specified temperature T in K.

getFreeEnergy(self, double T)→ doubleReturn the Gibbs free energy in J/mol for the system at the specified temperature T in K.

getHeatCapacity(self, double T)→ doubleReturn the heat capacity in J/mol*K for the system at the specified temperature T in K.

getInternalReducedMomentOfInertia(self, pivots, top1)→ doubleCalculate and return the reduced moment of inertia for an internal torsional rotation around the axis definedby the two atoms in pivots. The list top1 contains the atoms that should be considered as part of the rotatingtop; this list should contain the pivot atom connecting the top to the rest of the molecule. The procedureused is that of Pitzer 1, which is described as I(2,3) by East and Radom 2. In this procedure, the moleculeis divided into two tops: those at either end of the hindered rotor bond. The moment of inertia of each topis evaluated using an axis passing through the center of mass of both tops. Finally, the reduced moment ofinertia is evaluated from the moment of inertia of each top via the formula

1

I(2,3)=

1

I1+

1

I2

getMomentOfInertiaTensor(self)→ ndarrayCalculate and return the moment of inertia tensor for the conformer in kg*m^2. If the coordinates are notat the center of mass, they are temporarily shifted there for the purposes of this calculation.

getNumberDegreesOfFreedom(self)Return the number of degrees of freedom in a species object, which should be 3N, and raises an exceptionif it is not.

getPartitionFunction(self, double T)→ doubleReturn the partition function Q(T ) for the system at the specified temperature T in K.

getPrincipalMomentsOfInertia(self)Calculate and return the principal moments of inertia and corresponding principal axes for the conformer.The moments of inertia are in kg*m^2, while the principal axes have unit length.

getSumOfStates(self, ndarray Elist)→ ndarrayReturn the sum of states N(E) at the specified energies Elist in kJ/mol above the ground state.

getSymmetricTopRotors(self)Return objects representing the external J-rotor and K-rotor under the symmetric top approximation. Fornonlinear molecules, the J-rotor is a 2D rigid rotor with a rotational constantB determined as the geometricmean of the two most similar rotational constants. The K-rotor is a 1D rigid rotor with a rotational constantA − B determined by the difference between the remaining molecular rotational constant and the J-rotorrotational constant.

getTotalMass(self, atoms=None)→ doubleCalculate and return the total mass of the atoms in the conformer in kg. If a list atoms of atoms is specified,only those atoms will be used to calculate the center of mass. Otherwise, all atoms will be used.

1 Pitzer, K. S. J. Chem. Phys. 14, p. 239-243 (1946).2 East, A. L. L. and Radom, L. J. Chem. Phys. 106, p. 6655-6674 (1997).



massAn array of masses of each atom in the conformer.

modesmodes: list

numberAn array of atomic numbers of each atom in the conformer.

opticalIsomersopticalIsomers: ‘int’

spinMultiplicityspinMultiplicity: ‘int’

1.15 Thermodynamics (rmgpy.thermo)

The rmgpy.thermo subpackage contains classes that represent various thermodynamic models of heat capacity.

1.15.1 Heat capacity models

Class DescriptionThermoData A heat capacity model based on a set of discrete heat capacity pointsWilhoit A heat capacity model based on the Wilhoit polynomialNASA A heat capacity model based on a set of NASA polynomialsNASAPolynomial A heat capacity model based on a single NASA polynomial

rmgpy.thermo.ThermoData

class rmgpy.thermo.ThermoData(Tdata=None, Cpdata=None, H298=None, S298=None, Cp0=None,CpInf=None, Tmin=None, Tmax=None, E0=None, comment=’‘)

A heat capacity model based on a set of discrete heat capacity data points. The attributes are:

Attribute DescriptionTdata An array of temperatures at which the heat capacity is knownCpdata An array of heat capacities at the given temperaturesH298 The standard enthalpy of formation at 298 KS298 The standard entropy at 298 KTmin The minimum temperature at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature at which the model is valid, or zero if unknown or undefinedE0 The energy at zero Kelvin (including zero point energy)comment Information about the model (e.g. its source)

Cp0The heat capacity at zero temperature.

CpInfThe heat capacity at infinite temperature.

CpdataAn array of heat capacities at the given temperatures.

E0The ground state energy (J/mol) at zero Kelvin, including zero point energy, or None if not yet specified.



H298The standard enthalpy of formation at 298 K.

S298The standard entropy of formation at 298 K.

TdataAn array of temperatures at which the heat capacity is known.



commentcomment: str

discrepancy(self, HeatCapacityModel other)→ doubleReturn some measure of how dissimilar self is from other.

The measure is arbitrary, but hopefully useful for sorting purposes. Discrepancy of 0 means they areidentical

getEnthalpy(self, double T)→ doubleReturn the enthalpy in J/mol at the specified temperature T in K.

getEntropy(self, double T)→ doubleReturn the entropy in J/mol*K at the specified temperature T in K.

getFreeEnergy(self, double T)→ doubleReturn the Gibbs free energy in J/mol at the specified temperature T in K.

getHeatCapacity(self, double T)→ doubleReturn the constant-pressure heat capacity in J/mol*K at the specified temperature T in K.

isIdenticalTo(self, HeatCapacityModel other)→ boolReturns True if self and other report very similar thermo values for heat capacity, enthalpy, entropy, andfree energy over a wide range of temperatures, or False otherwise.

isSimilarTo(self, HeatCapacityModel other)→ boolReturns True if self and other report similar thermo values for heat capacity, enthalpy, entropy, and freeenergy over a wide range of temperatures, or False otherwise.

isTemperatureValid(self, double T)→ boolReturn True if the temperature T in K is within the valid temperature range of the thermodynamic data,or False if not. If the minimum and maximum temperature are not defined, True is returned.

toNASA(self, double Tmin, double Tmax, double Tint, bool fixedTint=False, bool weighting=True, intcontinuity=3)→ NASA

Convert the object to a NASA object. You must specify the minimum and maximum temperatures of the fitTmin and Tmax in K, as well as the intermediate temperature Tint in K to use as the bridge between thetwo fitted polynomials. The remaining parameters can be used to modify the fitting algorithm used:

•fixedTint - False to allow Tint to vary in order to improve the fit, or True to keep it fixed

•weighting - True to weight the fit by T−1 to emphasize good fit at lower temperatures, or False tonot use weighting

•continuity - The number of continuity constraints to enforce at Tint:

–0: no constraints on continuity of Cp(T ) at Tint

–1: constrain Cp(T ) to be continous at Tint

1.15. Thermodynamics (rmgpy.thermo) 179


–2: constrain Cp(T ) and dCp

dT to be continuous at Tint

–3: constrain Cp(T ), dCp

dT , and d2Cp

dT 2 to be continuous at Tint


dT , d2Cp

dT 2 , and d3Cp



dT , d2Cp

dT 2 , d3Cp

dT 3 , and d4Cp


Note that values of continuity of 5 or higher effectively constrain all the coefficients to be equal and shouldbe equivalent to fitting only one polynomial (rather than two).

Returns the fitted NASA object containing the two fitted NASAPolynomial objects.

toWilhoit(self, B=None)→WilhoitConvert the Benson model to a Wilhoit model. For the conversion to succeed, you must have set the Cp0and CpInf attributes of the Benson model.

B: the characteristic temperature in Kelvin.

rmgpy.thermo.Wilhoit

class rmgpy.thermo.Wilhoit(Cp0=None, CpInf=None, a0=0.0, a1=0.0, a2=0.0, a3=0.0, H0=None,S0=None, B=None, Tmin=None, Tmax=None, comment=’‘)

A heat capacity model based on the Wilhoit equation. The attributes are:

Attribute Descriptiona0 The zeroth-order Wilhoit polynomial coefficienta1 The first-order Wilhoit polynomial coefficienta2 The second-order Wilhoit polynomial coefficienta3 The third-order Wilhoit polynomial coefficientH0 The integration constant for enthalpy (not H at T=0)S0 The integration constant for entropy (not S at T=0)E0 The energy at zero Kelvin (including zero point energy)B The Wilhoit scaled temperature coefficient in KTmin The minimum temperature in K at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature in K at which the model is valid, or zero if unknown or undefinedcomment Information about the model (e.g. its source)

The Wilhoit polynomial is an expression for heat capacity that is guaranteed to give the correct limits at zeroand infinite temperature, and gives a very reasonable shape to the heat capacity profile in between:

Cp(T ) = Cp(0) + [Cp(∞)− Cp(0)] y2

[1 + (y − 1)

3∑i=0

aiyi

]

Above, y ≡ T/(T +B) is a scaled temperature that ranges from zero to one based on the value of the coefficientB, and a0, a1, a2, and a3 are the Wilhoit polynomial coefficients.

The enthalpy is given by

H(T ) = H0 + Cp(0)T + [Cp(∞)− Cp(0)]T[

2 +

3∑i=0

ai

] [1

2y − 1 +

(1

y− 1

)lnT

y

]+ y2

3∑i=0

yi

(i+ 2)(i+ 3)

3∑j=0

fijaj

where fij = 3 + j if i = j, fij = 1 if i > j, and fij = 0 if i < j.



The entropy is given by

S(T ) = S0 + Cp(∞) lnT − [Cp(∞)− Cp(0)]

[ln y +

(1 + y

3∑i=0

aiyi

2 + i

)y

]

The low-temperature limit Cp(0) is 3.5R for linear molecules and 4R for nonlinear molecules.The high-temperature limit Cp(∞) is taken to be [3Natoms − 1.5]R for linear molecules and[3Natoms − (2 + 0.5Nrotors)]R for nonlinear molecules, for a molecule composed ofNatoms atoms andNrotors

internal rotors.

BThe Wilhoit scaled temperature coefficient.



E0The ground state energy (J/mol) at zero Kelvin, including zero point energy.

For the Wilhoit class, this is calculated as the Enthalpy at 0.001 Kelvin.

H0The integration constant for enthalpy.

NB. this is not equal to the enthlapy at 0 Kelvin, which you can access via E0

S0The integration constant for entropy.



a0a0: ‘double’

a1a1: ‘double’

a2a2: ‘double’

a3a3: ‘double’

commentcomment: str

copy(self)→WilhoitReturn a copy of the Wilhoit object.





fitToData(self, ndarray Tdata, ndarray Cpdata, double Cp0, double CpInf, double H298, double S298,double B0=500.0)

Fit a Wilhoit model to the data points provided, allowing the characteristic temperature B to vary soas to improve the fit. This procedure requires an optimization, using the fminbound function in thescipy.optimize module. The data consists of a set of heat capacity points Cpdata in J/mol*K at a givenset of temperatures Tdata in K, along with the enthalpy H298 in kJ/mol and entropy S298 in J/mol*K at298 K. The linearity of the molecule, number of vibrational frequencies, and number of internal rotors(linear, Nfreq, and Nrotors, respectively) is used to set the limits at zero and infinite temperature.

fitToDataForConstantB(self, ndarray Tdata, ndarray Cpdata, double Cp0, double CpInf, doubleH298, double S298, double B)

Fit a Wilhoit model to the data points provided using a specified value of the characteristic temperatureB. The data consists of a set of dimensionless heat capacity points Cpdata at a given set of temperaturesTdata in K, along with the dimensionless heat capacity at zero and infinite temperature, the dimensionlessenthalpy H298 at 298 K, and the dimensionless entropy S298 at 298 K.








toNASA(self, double Tmin, double Tmax, double Tint, bool fixedTint=False, bool weighting=True, intcontinuity=3)→ NASA

Convert the Wilhoit object to a NASA object. You must specify the minimum and maximum temperaturesof the fit Tmin and Tmax in K, as well as the intermediate temperature Tint in K to use as the bridgebetween the two fitted polynomials. The remaining parameters can be used to modify the fitting algorithmused:

•fixedTint - False to allow Tint to vary in order to improve the fit, or True to keep it fixed

•weighting - True to weight the fit by T−1 to emphasize good fit at lower temperatures, or False tonot use weighting

•continuity - The number of continuity constraints to enforce at Tint:

–0: no constraints on continuity of Cp(T ) at Tint

–1: constrain Cp(T ) to be continous at Tint

–2: constrain Cp(T ) and dCp

dT to be continuous at Tint


dT , and d2Cp





dT , d2Cp

dT 2 , and d3Cp



dT , d2Cp

dT 2 , d3Cp

dT 3 , and d4Cp


Note that values of continuity of 5 or higher effectively constrain all the coefficients to be equal and shouldbe equivalent to fitting only one polynomial (rather than two).

Returns the fitted NASA object containing the two fitted NASAPolynomial objects.

toThermoData(self)→ ThermoDataConvert the Wilhoit model to a ThermoData object.

rmgpy.thermo.NASA

class rmgpy.thermo.NASA(polynomials=None, Tmin=None, Tmax=None, E0=None, Cp0=None,CpInf=None, comment=’‘)

A heat capacity model based on a set of one, two, or three NASAPolynomial objects. The attributes are:

Attribute Descriptionpolynomials The list of NASA polynomials to use in this modelTmin The minimum temperature in K at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature in K at which the model is valid, or zero if unknown or undefinedE0 The energy at zero Kelvin (including zero point energy)comment Information about the model (e.g. its source)

The NASA polynomial is another representation of the heat capacity, enthalpy, and entropy using seven or ninecoefficients a = [a−2 a−1 a0 a1 a2 a3 a4 a5 a6]. The relevant thermodynamic parameters are evaluated via theexpressions

Cp(T )

R= a−2T

−2 + a−1T−1 + a0 + a1T + a2T

2 + a3T3 + a4T

4

H(T )

RT= −a−2T−2 + a−1T

−1 lnT + a0 +1

2a1T +

1

3a2T

2 +1

4a3T

3 +1

5a4T

4 +a5T

S(T )

R= −1

2a−2T

−2 − a−1T−1 + a0 lnT + a1T +1

2a2T

2 +1

3a3T

3 +1

4a4T

4 + a6

In the seven-coefficient version, a−2 = a−1 = 0.

As simple polynomial expressions, the NASA polynomial is faster to evaluate when compared to the Wilhoitmodel; however, it does not have the nice physical behavior of the Wilhoit representation. Often multiple NASApolynomials are used to accurately represent the thermodynamics of a system over a wide temperature range.








changeBaseEnthalpy(self, double deltaH)→ NASAAdd deltaH in J/mol to the base enthalpy of formation H298 and return the modified NASA object.

commentcomment: str



getEnthalpy(self, double T)→ doubleReturn the dimensionless enthalpy H(T )/RT at the specified temperature T in K.

getEntropy(self, double T)→ doubleReturn the dimensionless entropy S(T )/R at the specified temperature T in K.

getFreeEnergy(self, double T)→ doubleReturn the dimensionless Gibbs free energy G(T )/RT at the specified temperature T in K.

getHeatCapacity(self, double T)→ doubleReturn the dimensionless constant-pressure heat capacity Cp(T )/R at the specified temperature T in K.




poly1poly1: rmgpy.thermo.nasa.NASAPolynomial



polynomialsThe set of one, two, or three NASA polynomials.

selectPolynomial(self, double T)→ NASAPolynomial

toCantera(self)Return the cantera equivalent NasaPoly2 object from this NASA object.

toThermoData(self)→ ThermoDataConvert the Wilhoit model to a ThermoData object.

toWilhoit(self)→WilhoitConvert a MultiNASA object multiNASA to a Wilhoit object. You must specify the linearity of themolecule linear, the number of vibrational modes Nfreq, and the number of hindered rotor modes Nrotorsso the algorithm can determine the appropriate heat capacity limits at zero and infinite temperature.

Here is an example of a NASA entry:



entry(index = 2,label = "octane",molecule =

"""1 C 0 {2,S}2 C 0 {1,S} {3,S}3 C 0 {2,S} {4,S}4 C 0 {3,S} {5,S}5 C 0 {4,S} {6,S}6 C 0 {5,S} {7,S}7 C 0 {6,S} {8,S}8 C 0 {7,S}""",

thermo = NASA(polynomials = [

NASAPolynomial(coeffs=[1.25245480E+01,-1.01018826E-02,2.21992610E-04,-2.84863722E-07,1.12410138E-10,-2.98434398E+04,-1.97109989E+01], Tmin=(200,'K'), Tmax=(1000,'K')),NASAPolynomial(coeffs=[2.09430708E+01,4.41691018E-02,-1.53261633E-05,2.30544803E-09,-1.29765727E-13,-3.55755088E+04,-8.10637726E+01], Tmin=(1000,'K'), Tmax=(6000,'K')),

],Tmin = (200,'K'),Tmax = (6000,'K'),

),reference = Reference(authors=["check on burcat"], title='burcat', year="1999", url="http://www.me.berkeley.edu/gri-mech/version30/text30.html"),referenceType = "review",shortDesc = u"""""",longDesc =

u"""

""",)

rmgpy.thermo.NASAPolynomial

class rmgpy.thermo.NASAPolynomial(coeffs=None, Tmin=None, Tmax=None, E0=None, comment=’‘)A heat capacity model based on the NASA polynomial. Both the seven-coefficient and nine-coefficient varia-tions are supported. The attributes are:

Attribute Descriptioncoeffs The seven or nine NASA polynomial coefficientsTmin The minimum temperature in K at which the model is valid, or zero if unknown or undefinedTmax The maximum temperature in K at which the model is valid, or zero if unknown or undefinedE0 The energy at zero Kelvin (including zero point energy)comment Information about the model (e.g. its source)

The NASA polynomial is another representation of the heat capacity, enthalpy, and entropy using seven or ninecoefficients a = [a−2 a−1 a0 a1 a2 a3 a4 a5 a6]. The relevant thermodynamic parameters are evaluated via theexpressions

Cp(T )

R= a−2T

−2 + a−1T−1 + a0 + a1T + a2T

2 + a3T3 + a4T

4

H(T )

RT= −a−2T−2 + a−1T

−1 lnT + a0 +1

2a1T +

1

3a2T

2 +1

4a3T

3 +1

5a4T

4 +a5T

S(T )

R= −1

2a−2T

−2 − a−1T−1 + a0 lnT + a1T +1

2a2T

2 +1

3a3T

3 +1

4a4T

4 + a6



In the seven-coefficient version, a−2 = a−1 = 0.

As simple polynomial expressions, the NASA polynomial is faster to evaluate when compared to the Wilhoitmodel; however, it does not have the nice physical behavior of the Wilhoit representation. Often multiple NASApolynomials are used to accurately represent the thermodynamics of a system over a wide temperature range;the NASA class is available for this purpose.






c0c0: ‘double’

c1c1: ‘double’

c2c2: ‘double’

c3c3: ‘double’

c4c4: ‘double’

c5c5: ‘double’

c6c6: ‘double’

changeBaseEnthalpy(self, double deltaH)Add deltaH in J/mol to the base enthalpy of formation H298.

cm1cm1: ‘double’

cm2cm2: ‘double’

coeffsThe set of seven or nine NASA polynomial coefficients.

commentcomment: str




BIBLIOGRAPHY

[1932Wigner] E.Wigner. Phys. Rev. 40, p. 749-759 (1932). doi:10.1103/PhysRev.40.749

[1959Bell] R. P. Bell. Trans. Faraday Soc. 55, p. 1-4 (1959). doi:10.1039/TF9595500001

[Chang2000] A. Y. Chang, J. W. Bozzelli, and A. M. Dean. Z. Phys. Chem. 214, p. 1533-1568 (2000). doi:10.1524/zpch.2000.214.11.1533

[Gilbert1990] R. G. Gilbert and S. C. Smith. Theory of Unimolecular and Recombination Reactions. Blackwell Sci.(1990).

[Baer1996] T. Baer and W. L. Hase. Unimolecular Reaction Dynamics. Oxford University Press (1996).

[Holbrook1996] K. A. Holbrook, M. J. Pilling, and S. H. Robertson. Unimolecular Reactions. Second Edition. JohnWiley and Sons (1996).

[Forst2003] W. Forst. Unimolecular Reactions: A Concise Introduction. Cambridge University Press (2003).

[Pilling2003] M. J. Pilling and S. H. Robertson. Annu. Rev. Phys. Chem. 54, p. 245-275 (2003).doi:10.1146/annurev.physchem.54.011002.103822

189

http://dx.doi.org/10.1103/PhysRev.40.749

http://dx.doi.org/10.1039/TF9595500001

http://dx.doi.org/10.1524/zpch.2000.214.11.1533

http://dx.doi.org/10.1524/zpch.2000.214.11.1533

http://dx.doi.org/10.1146/annurev.physchem.54.011002.103822


190 Bibliography

PYTHON MODULE INDEX

rrmgpy.cantherm, 3rmgpy.chemkin, 10rmgpy.constants, 13rmgpy.data, 13rmgpy.kinetics, 64rmgpy.molecule, 84rmgpy.molecule.adjlist, 104rmgpy.pdep, 108rmgpy.qm, 118rmgpy.quantity, 136rmgpy.reaction, 140rmgpy.rmg, 143rmgpy.solver, 157rmgpy.species, 160rmgpy.statmech, 163rmgpy.statmech.schrodinger, 175rmgpy.thermo, 178

191


192 Python Module Index

INDEX

AA (rmgpy.kinetics.Arrhenius attribute), 66a0 (rmgpy.thermo.Wilhoit attribute), 181a1 (rmgpy.thermo.Wilhoit attribute), 181a2 (rmgpy.thermo.Wilhoit attribute), 181a3 (rmgpy.thermo.Wilhoit attribute), 181addAction() (rmgpy.data.kinetics.ReactionRecipe

method), 40addAtom() (rmgpy.molecule.Group method), 100addAtom() (rmgpy.molecule.Molecule method), 93addAtomLabelsForReaction()

(rmgpy.data.kinetics.KineticsFamily method),25

addBond() (rmgpy.molecule.Group method), 101addBond() (rmgpy.molecule.Molecule method), 93addEdge() (rmgpy.molecule.graph.Graph method), 86addEdge() (rmgpy.molecule.Group method), 101addEdge() (rmgpy.molecule.Molecule method), 93addExplicitLigands() (rmgpy.molecule.Group method),

101addKineticsRulesFromTrainingSet()


addPathReaction() (rmgpy.rmg.pdep.PDepNetworkmethod), 150

addReactionLibraryToEdge()(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 144

addReactionLibraryToOutput()(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 144

addReactionToCore() (rmgpy.rmg.model.CoreEdgeReactionModelmethod), 144

addReactionToEdge() (rmgpy.rmg.model.CoreEdgeReactionModelmethod), 145

addReactionToUnimolecularNetworks()(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 145

addSeedMechanismToCore()(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 145

addSpeciesToCore() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 145addSpeciesToEdge() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 145addVertex() (rmgpy.molecule.graph.Graph method), 86addVertex() (rmgpy.molecule.Group method), 101addVertex() (rmgpy.molecule.Molecule method), 93advance() (rmgpy.solver.ReactionSystem method), 157advance() (rmgpy.solver.SimpleReactor method), 158alpha (rmgpy.kinetics.Troe attribute), 80alpha0 (rmgpy.pdep.SingleExponentialDown attribute),

109ancestors() (rmgpy.data.base.Database method), 15ancestors() (rmgpy.data.kinetics.KineticsDepository

method), 22ancestors() (rmgpy.data.kinetics.KineticsFamily method),

25ancestors() (rmgpy.data.kinetics.KineticsGroups

method), 30ancestors() (rmgpy.data.kinetics.KineticsLibrary

method), 32ancestors() (rmgpy.data.kinetics.KineticsRules method),

34ancestors() (rmgpy.data.statmech.StatmechDepository

method), 42ancestors() (rmgpy.data.statmech.StatmechGroups

method), 48ancestors() (rmgpy.data.statmech.StatmechLibrary

method), 50ancestors() (rmgpy.data.thermo.ThermoDepository

method), 58ancestors() (rmgpy.data.thermo.ThermoGroups method),

60ancestors() (rmgpy.data.thermo.ThermoLibrary method),

62applyAction() (rmgpy.molecule.Atom method), 91applyAction() (rmgpy.molecule.Bond method), 92applyAction() (rmgpy.molecule.GroupAtom method), 99applyAction() (rmgpy.molecule.GroupBond method),

100applyChemicallySignificantEigenvaluesMethod() (in

module rmgpy.pdep.cse), 118applyChemicallySignificantEigenvaluesMethod()

193


(rmgpy.pdep.Network method), 113applyChemicallySignificantEigenvaluesMethod()

(rmgpy.rmg.pdep.PDepNetwork method),150

applyForward() (rmgpy.data.kinetics.ReactionRecipemethod), 40

applyInverseLaplaceTransformMethod() (in modulermgpy.pdep), 111

applyModifiedStrongCollisionMethod() (in modulermgpy.pdep.msc), 117

applyModifiedStrongCollisionMethod()(rmgpy.pdep.Network method), 113

applyModifiedStrongCollisionMethod()(rmgpy.rmg.pdep.PDepNetwork method),150

applyRecipe() (rmgpy.data.kinetics.KineticsFamilymethod), 25

applyReservoirStateMethod() (in module rmgpy.pdep.rs),117

applyReservoirStateMethod() (rmgpy.pdep.Networkmethod), 113

applyReservoirStateMethod()(rmgpy.rmg.pdep.PDepNetwork method),150

applyReverse() (rmgpy.data.kinetics.ReactionRecipemethod), 40

applyRRKMTheory() (in module rmgpy.pdep), 110areSiblings() (rmgpy.data.base.Database method), 15areSiblings() (rmgpy.data.kinetics.KineticsDepository

method), 22areSiblings() (rmgpy.data.kinetics.KineticsFamily

method), 25areSiblings() (rmgpy.data.kinetics.KineticsGroups

method), 30areSiblings() (rmgpy.data.kinetics.KineticsLibrary

method), 32areSiblings() (rmgpy.data.kinetics.KineticsRules

method), 34areSiblings() (rmgpy.data.statmech.StatmechDepository

method), 42areSiblings() (rmgpy.data.statmech.StatmechGroups

method), 48areSiblings() (rmgpy.data.statmech.StatmechLibrary

method), 50areSiblings() (rmgpy.data.thermo.ThermoDepository

method), 58areSiblings() (rmgpy.data.thermo.ThermoGroups

method), 60areSiblings() (rmgpy.data.thermo.ThermoLibrary

method), 62ArrayQuantity (class in rmgpy.quantity), 138Arrhenius (class in rmgpy.kinetics), 66arrhenius (rmgpy.kinetics.MultiArrhenius attribute), 68arrhenius (rmgpy.kinetics.MultiPDepArrhenius attribute),

72arrhenius (rmgpy.kinetics.PDepArrhenius attribute), 71arrheniusHigh (rmgpy.kinetics.Lindemann attribute), 78arrheniusHigh (rmgpy.kinetics.Troe attribute), 80arrheniusLow (rmgpy.kinetics.Lindemann attribute), 78arrheniusLow (rmgpy.kinetics.ThirdBody attribute), 76arrheniusLow (rmgpy.kinetics.Troe attribute), 80Atom (class in rmgpy.molecule), 91AtomType (class in rmgpy.molecule), 89

BB (rmgpy.thermo.Wilhoit attribute), 181barrier (rmgpy.statmech.HinderedRotor attribute), 173Bond (class in rmgpy.molecule), 92

Cc0 (rmgpy.thermo.NASAPolynomial attribute), 186c1 (rmgpy.thermo.NASAPolynomial attribute), 186c2 (rmgpy.thermo.NASAPolynomial attribute), 186c3 (rmgpy.thermo.NASAPolynomial attribute), 186c4 (rmgpy.thermo.NASAPolynomial attribute), 186c5 (rmgpy.thermo.NASAPolynomial attribute), 186c6 (rmgpy.thermo.NASAPolynomial attribute), 186calculate() (rmgpy.qm.symmetry.SymmetryJob method),

123calculate_effective_pressure()

(rmgpy.solver.SimpleReactor method), 158calculateAtomSymmetryNumber() (in module

rmgpy.molecule.symmetry), 106calculateAxisSymmetryNumber() (in module

rmgpy.molecule.symmetry), 106calculateBondSymmetryNumber() (in module

rmgpy.molecule.symmetry), 106calculateChiralityCorrection()

(rmgpy.qm.gaussian.GaussianMol method),124

calculateChiralityCorrection()(rmgpy.qm.gaussian.GaussianMolPM3method), 126

calculateChiralityCorrection()(rmgpy.qm.gaussian.GaussianMolPM6method), 127

calculateChiralityCorrection()(rmgpy.qm.molecule.QMMolecule method),121

calculateChiralityCorrection()(rmgpy.qm.mopac.MopacMol method), 130

calculateChiralityCorrection()(rmgpy.qm.mopac.MopacMolPM3 method),131


194 Index



calculateCollisionEfficiency()(rmgpy.pdep.SingleExponentialDown method),109

calculateCollisionFrequency()(rmgpy.pdep.Configuration method), 111

calculateCollisionModel() (rmgpy.pdep.Networkmethod), 113

calculateCollisionModel()(rmgpy.rmg.pdep.PDepNetwork method),150

calculateCp0() (rmgpy.molecule.Molecule method), 93calculateCp0() (rmgpy.rmg.model.Species method), 155calculateCp0() (rmgpy.species.Species method), 161calculateCpInf() (rmgpy.molecule.Molecule method), 94calculateCpInf() (rmgpy.rmg.model.Species method),

155calculateCpInf() (rmgpy.species.Species method), 161calculateCyclicSymmetryNumber() (in module

rmgpy.molecule.symmetry), 107calculateDegeneracy() (rmgpy.data.kinetics.KineticsFamily

method), 25calculateDensitiesOfStates() (rmgpy.pdep.Network

method), 113calculateDensitiesOfStates()


calculateDensityOfStates() (rmgpy.pdep.Configurationmethod), 111

calculateEquilibriumRatios() (rmgpy.pdep.Networkmethod), 113

calculateEquilibriumRatios()(rmgpy.rmg.pdep.PDepNetwork method),150

calculateMicrocanonicalRateCoefficient() (in modulermgpy.pdep), 110

calculateMicrocanonicalRateCoefficient()(rmgpy.data.kinetics.DepositoryReactionmethod), 17

calculateMicrocanonicalRateCoefficient()(rmgpy.data.kinetics.LibraryReaction method),36

calculateMicrocanonicalRateCoefficient()(rmgpy.data.kinetics.TemplateReactionmethod), 52

calculateMicrocanonicalRateCoefficient()(rmgpy.reaction.Reaction method), 140

calculateMicrocanonicalRateCoefficient()(rmgpy.rmg.pdep.PDepReaction method),152

calculateMicrocanonicalRates() (rmgpy.pdep.Networkmethod), 113

calculateMicrocanonicalRates()(rmgpy.rmg.pdep.PDepNetwork method),150

calculateNormDistance()(rmgpy.data.kinetics.KineticsRules method),34

calculateSymmetryNumber() (in modulermgpy.molecule.symmetry), 107

calculateSymmetryNumber() (rmgpy.molecule.Moleculemethod), 94

calculateThermoData() (rmgpy.qm.gaussian.GaussianMolmethod), 124

calculateThermoData() (rmgpy.qm.gaussian.GaussianMolPM3method), 126

calculateThermoData() (rmgpy.qm.gaussian.GaussianMolPM6method), 127

calculateThermoData() (rmgpy.qm.molecule.QMMoleculemethod), 121

calculateThermoData() (rmgpy.qm.mopac.MopacMolmethod), 130

calculateThermoData() (rmgpy.qm.mopac.MopacMolPM3method), 131



calculateTSTRateCoefficient()(rmgpy.data.kinetics.DepositoryReactionmethod), 17

calculateTSTRateCoefficient()(rmgpy.data.kinetics.LibraryReaction method),37

calculateTSTRateCoefficient()(rmgpy.data.kinetics.TemplateReactionmethod), 53

calculateTSTRateCoefficient() (rmgpy.reaction.Reactionmethod), 141

calculateTSTRateCoefficient()(rmgpy.rmg.pdep.PDepReaction method),152

calculateTunnelingFactor() (rmgpy.kinetics.Eckartmethod), 83

calculateTunnelingFactor() (rmgpy.kinetics.Wignermethod), 82

calculateTunnelingFactor()(rmgpy.species.TransitionState method),163

calculateTunnelingFunction() (rmgpy.kinetics.Eckartmethod), 83

calculateTunnelingFunction() (rmgpy.kinetics.Wignermethod), 82

calculateTunnelingFunction()(rmgpy.species.TransitionState method),163

Index 195


CanTherm (class in rmgpy.cantherm), 6canTST() (rmgpy.data.kinetics.DepositoryReaction

method), 18canTST() (rmgpy.data.kinetics.LibraryReaction method),

37canTST() (rmgpy.data.kinetics.TemplateReaction

method), 53canTST() (rmgpy.reaction.Reaction method), 141canTST() (rmgpy.rmg.pdep.PDepReaction method), 153changeBaseEnthalpy() (rmgpy.thermo.NASA method),

183changeBaseEnthalpy() (rmgpy.thermo.NASAPolynomial

method), 186changeRate() (rmgpy.kinetics.Arrhenius method), 66changeRate() (rmgpy.kinetics.Chebyshev method), 74changeRate() (rmgpy.kinetics.Lindemann method), 78changeRate() (rmgpy.kinetics.MultiArrhenius method),

68changeRate() (rmgpy.kinetics.MultiPDepArrhenius

method), 72changeRate() (rmgpy.kinetics.PDepArrhenius method),

71changeRate() (rmgpy.kinetics.ThirdBody method), 76changeRate() (rmgpy.kinetics.Troe method), 80changeT0() (rmgpy.kinetics.Arrhenius method), 66Chebyshev (class in rmgpy.kinetics), 73checkAllSet() (rmgpy.qm.main.QMSettings method), 119checkForDuplicates() (rmgpy.data.kinetics.KineticsLibrary

method), 32checkForExistingReaction()

(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 145

checkForExistingSpecies()(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 145

checkForInChiKeyCollision()(rmgpy.qm.qmverifier.QMVerifier method),122

checkInput() (rmgpy.rmg.main.RMG method), 148checkLibraries() (rmgpy.rmg.main.RMG method), 149checkPaths() (rmgpy.qm.gaussian.GaussianMol method),

124checkPaths() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126checkPaths() (rmgpy.qm.gaussian.GaussianMolPM6

method), 127checkPaths() (rmgpy.qm.main.QMCalculator method),

120checkPaths() (rmgpy.qm.molecule.QMMolecule

method), 121checkPaths() (rmgpy.qm.mopac.MopacMol method), 130checkPaths() (rmgpy.qm.mopac.MopacMolPM3

method), 131checkPaths() (rmgpy.qm.mopac.MopacMolPM6

method), 133checkPaths() (rmgpy.qm.mopac.MopacMolPM7

method), 135checkReady() (rmgpy.qm.gaussian.GaussianMol

method), 124checkReady() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126checkReady() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128checkReady() (rmgpy.qm.main.QMCalculator method),

120checkReady() (rmgpy.qm.molecule.QMMolecule

method), 121checkReady() (rmgpy.qm.mopac.MopacMol method),

130checkReady() (rmgpy.qm.mopac.MopacMolPM3

method), 131checkReady() (rmgpy.qm.mopac.MopacMolPM6

method), 133checkReady() (rmgpy.qm.mopac.MopacMolPM7

method), 135cleanup() (rmgpy.pdep.Configuration method), 111cleanup() (rmgpy.rmg.pdep.PDepNetwork method), 151clear() (rmgpy.rmg.main.RMG method), 149clearLabeledAtoms() (rmgpy.molecule.Group method),

101clearLabeledAtoms() (rmgpy.molecule.Molecule

method), 94cm1 (rmgpy.thermo.NASAPolynomial attribute), 186cm2 (rmgpy.thermo.NASAPolynomial attribute), 186coeffs (rmgpy.kinetics.Chebyshev attribute), 74coeffs (rmgpy.thermo.NASAPolynomial attribute), 186comment (rmgpy.kinetics.Arrhenius attribute), 67comment (rmgpy.kinetics.Chebyshev attribute), 74comment (rmgpy.kinetics.KineticsData attribute), 65comment (rmgpy.kinetics.Lindemann attribute), 78comment (rmgpy.kinetics.MultiArrhenius attribute), 68comment (rmgpy.kinetics.MultiPDepArrhenius attribute),

72comment (rmgpy.kinetics.PDepArrhenius attribute), 71comment (rmgpy.kinetics.PDepKineticsData attribute),

69comment (rmgpy.kinetics.ThirdBody attribute), 76comment (rmgpy.kinetics.Troe attribute), 80comment (rmgpy.thermo.NASA attribute), 184comment (rmgpy.thermo.NASAPolynomial attribute),

186comment (rmgpy.thermo.ThermoData attribute), 179comment (rmgpy.thermo.Wilhoit attribute), 181compute_network_variables()

(rmgpy.solver.ReactionSystem method),157

compute_network_variables()(rmgpy.solver.SimpleReactor method), 159

196 Index


computeGroupAdditivityThermo()(rmgpy.data.thermo.ThermoDatabase method),55

computeRateDerivative() (rmgpy.solver.ReactionSystemmethod), 157

computeRateDerivative() (rmgpy.solver.SimpleReactormethod), 158

Configuration (class in rmgpy.pdep), 111Conformer (class in rmgpy.statmech), 176connectTheDots() (rmgpy.molecule.Molecule method),

94containsLabeledAtom() (rmgpy.molecule.Group

method), 101containsLabeledAtom() (rmgpy.molecule.Molecule

method), 94convertDuplicatesToMulti()

(rmgpy.data.kinetics.KineticsLibrary method),32

convertInitialKeysToSpeciesObjects()(rmgpy.solver.SimpleReactor method), 159

convolve() (in module rmgpy.statmech.schrodinger), 175convolveBS() (in module rmgpy.statmech.schrodinger),

175convolveBSSR() (in module

rmgpy.statmech.schrodinger), 175coordinates (rmgpy.statmech.Conformer attribute), 176copy() (rmgpy.cantherm.PressureDependenceJob

method), 8copy() (rmgpy.data.kinetics.DepositoryReaction method),

18copy() (rmgpy.data.kinetics.LibraryReaction method), 37copy() (rmgpy.data.kinetics.TemplateReaction method),

53copy() (rmgpy.molecule.Atom method), 91copy() (rmgpy.molecule.Bond method), 92copy() (rmgpy.molecule.graph.Edge method), 86copy() (rmgpy.molecule.graph.Graph method), 86copy() (rmgpy.molecule.graph.Vertex method), 85copy() (rmgpy.molecule.Group method), 101copy() (rmgpy.molecule.GroupAtom method), 99copy() (rmgpy.molecule.GroupBond method), 100copy() (rmgpy.molecule.Molecule method), 94copy() (rmgpy.quantity.ArrayQuantity method), 139copy() (rmgpy.quantity.ScalarQuantity method), 138copy() (rmgpy.reaction.Reaction method), 141copy() (rmgpy.rmg.model.Species method), 155copy() (rmgpy.rmg.pdep.PDepReaction method), 153copy() (rmgpy.species.Species method), 161copy() (rmgpy.thermo.Wilhoit method), 181copyData() (rmgpy.data.thermo.ThermoGroups method),

60CoreEdgeReactionModel (class in rmgpy.rmg.model),

144countInternalRotors() (rmgpy.molecule.Molecule

method), 94Cp0 (rmgpy.thermo.NASA attribute), 183Cp0 (rmgpy.thermo.NASAPolynomial attribute), 186Cp0 (rmgpy.thermo.ThermoData attribute), 178Cp0 (rmgpy.thermo.Wilhoit attribute), 181Cpdata (rmgpy.thermo.ThermoData attribute), 178CpInf (rmgpy.thermo.NASA attribute), 183CpInf (rmgpy.thermo.NASAPolynomial attribute), 186CpInf (rmgpy.thermo.ThermoData attribute), 178CpInf (rmgpy.thermo.Wilhoit attribute), 181createGeometry() (rmgpy.qm.gaussian.GaussianMol

method), 124createGeometry() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126createGeometry() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128createGeometry() (rmgpy.qm.molecule.QMMolecule

method), 121createGeometry() (rmgpy.qm.mopac.MopacMol

method), 130createGeometry() (rmgpy.qm.mopac.MopacMolPM3



method), 135

DDatabase (class in rmgpy.data.base), 15decrementLonePairs() (rmgpy.molecule.Atom method),

91decrementOrder() (rmgpy.molecule.Bond method), 92decrementRadical() (rmgpy.molecule.Atom method), 91degreeP (rmgpy.kinetics.Chebyshev attribute), 74degreeT (rmgpy.kinetics.Chebyshev attribute), 74deleteHydrogens() (rmgpy.molecule.Molecule method),

94DepositoryReaction (class in rmgpy.data.kinetics), 17descendants() (rmgpy.data.base.Database method), 15descendants() (rmgpy.data.kinetics.KineticsDepository

method), 23descendants() (rmgpy.data.kinetics.KineticsFamily

method), 25descendants() (rmgpy.data.kinetics.KineticsGroups

method), 30descendants() (rmgpy.data.kinetics.KineticsLibrary

method), 32descendants() (rmgpy.data.kinetics.KineticsRules

method), 34descendants() (rmgpy.data.statmech.StatmechDepository

method), 42descendants() (rmgpy.data.statmech.StatmechGroups

method), 48

Index 197


descendants() (rmgpy.data.statmech.StatmechLibrarymethod), 50

descendants() (rmgpy.data.thermo.ThermoDepositorymethod), 58

descendants() (rmgpy.data.thermo.ThermoGroupsmethod), 60

descendants() (rmgpy.data.thermo.ThermoLibrarymethod), 62

descendTree() (rmgpy.data.base.Database method), 15descendTree() (rmgpy.data.kinetics.KineticsDepository

method), 22descendTree() (rmgpy.data.kinetics.KineticsFamily

method), 25descendTree() (rmgpy.data.kinetics.KineticsGroups

method), 30descendTree() (rmgpy.data.kinetics.KineticsLibrary

method), 32descendTree() (rmgpy.data.kinetics.KineticsRules

method), 34descendTree() (rmgpy.data.statmech.StatmechDepository

method), 42descendTree() (rmgpy.data.statmech.StatmechGroups

method), 48descendTree() (rmgpy.data.statmech.StatmechLibrary

method), 50descendTree() (rmgpy.data.thermo.ThermoDepository

method), 58descendTree() (rmgpy.data.thermo.ThermoGroups

method), 60descendTree() (rmgpy.data.thermo.ThermoLibrary

method), 62determinePointGroup() (rmgpy.qm.gaussian.GaussianMol

method), 124determinePointGroup() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126determinePointGroup() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128determinePointGroup() (rmgpy.qm.molecule.QMMolecule

method), 121determinePointGroup() (rmgpy.qm.mopac.MopacMol

method), 130determinePointGroup() (rmgpy.qm.mopac.MopacMolPM3



method), 135DirectFit (class in rmgpy.data.statmechfit), 45discrepancy() (rmgpy.kinetics.Arrhenius method), 67discrepancy() (rmgpy.kinetics.Chebyshev method), 74discrepancy() (rmgpy.kinetics.KineticsData method), 65discrepancy() (rmgpy.kinetics.Lindemann method), 78discrepancy() (rmgpy.kinetics.MultiArrhenius method),

68

discrepancy() (rmgpy.kinetics.MultiPDepArrheniusmethod), 72

discrepancy() (rmgpy.kinetics.PDepArrhenius method),71

discrepancy() (rmgpy.kinetics.PDepKineticsDatamethod), 69

discrepancy() (rmgpy.kinetics.ThirdBody method), 76discrepancy() (rmgpy.kinetics.Troe method), 80discrepancy() (rmgpy.thermo.NASA method), 184discrepancy() (rmgpy.thermo.NASAPolynomial method),

186discrepancy() (rmgpy.thermo.ThermoData method), 179discrepancy() (rmgpy.thermo.Wilhoit method), 181draw() (rmgpy.cantherm.PressureDependenceJob

method), 8draw() (rmgpy.data.kinetics.DepositoryReaction

method), 18draw() (rmgpy.data.kinetics.LibraryReaction method), 37draw() (rmgpy.data.kinetics.TemplateReaction method),

53draw() (rmgpy.molecule.draw.MoleculeDrawer method),

107draw() (rmgpy.molecule.draw.ReactionDrawer method),

107draw() (rmgpy.molecule.Molecule method), 94draw() (rmgpy.reaction.Reaction method), 141draw() (rmgpy.rmg.pdep.PDepReaction method), 153

EE0 (rmgpy.pdep.Configuration attribute), 111E0 (rmgpy.statmech.Conformer attribute), 176E0 (rmgpy.thermo.NASA attribute), 183E0 (rmgpy.thermo.NASAPolynomial attribute), 186E0 (rmgpy.thermo.ThermoData attribute), 178E0 (rmgpy.thermo.Wilhoit attribute), 181E0_prod (rmgpy.kinetics.Eckart attribute), 83E0_reac (rmgpy.kinetics.Eckart attribute), 83E0_TS (rmgpy.kinetics.Eckart attribute), 83Ea (rmgpy.kinetics.Arrhenius attribute), 66Eckart (class in rmgpy.kinetics), 82Edge (class in rmgpy.molecule.graph), 86efficiencies (rmgpy.kinetics.Chebyshev attribute), 74efficiencies (rmgpy.kinetics.Lindemann attribute), 78efficiencies (rmgpy.kinetics.MultiPDepArrhenius at-

tribute), 72efficiencies (rmgpy.kinetics.PDepArrhenius attribute), 71efficiencies (rmgpy.kinetics.PDepKineticsData attribute),

69efficiencies (rmgpy.kinetics.ThirdBody attribute), 76efficiencies (rmgpy.kinetics.Troe attribute), 80Element (class in rmgpy.molecule), 88energies (rmgpy.statmech.HinderedRotor attribute), 173enlarge() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 145

198 Index


Entry (class in rmgpy.data.base), 20equals() (rmgpy.quantity.ArrayQuantity method), 139equals() (rmgpy.quantity.ScalarQuantity method), 138equivalent() (rmgpy.molecule.Atom method), 91equivalent() (rmgpy.molecule.AtomType method), 89equivalent() (rmgpy.molecule.Bond method), 92equivalent() (rmgpy.molecule.graph.Edge method), 86equivalent() (rmgpy.molecule.graph.Vertex method), 85equivalent() (rmgpy.molecule.GroupAtom method), 99equivalent() (rmgpy.molecule.GroupBond method), 100estimateKinetics() (rmgpy.data.kinetics.KineticsRules

method), 34estimateKineticsUsingGroupAdditivity()


estimateKineticsUsingGroupAdditivity()(rmgpy.data.kinetics.KineticsGroups method),30

estimateKineticsUsingRateRules()(rmgpy.data.kinetics.KineticsFamily method),26

estimateRadicalThermoViaHBI()(rmgpy.data.thermo.ThermoDatabase method),55

estimateThermoViaGroupAdditivity()(rmgpy.data.thermo.ThermoDatabase method),55

execute() (rmgpy.cantherm.CanTherm method), 6execute() (rmgpy.cantherm.KineticsJob method), 6execute() (rmgpy.cantherm.StatMechJob method), 9execute() (rmgpy.cantherm.ThermoJob method), 9execute() (rmgpy.rmg.main.RMG method), 149exploreIsomer() (rmgpy.rmg.pdep.PDepNetwork

method), 151extractSourceFromComments()

(rmgpy.data.kinetics.KineticsDatabasemethod), 21

extractSourceFromComments()(rmgpy.data.kinetics.KineticsFamily method),26

extractSourceFromComments()(rmgpy.data.thermo.ThermoDatabase method),56

FfailureKeys (rmgpy.qm.gaussian.Gaussian attribute), 124failureKeys (rmgpy.qm.mopac.Mopac attribute), 129fillKineticsRulesByAveragingUp()


fillRulesByAveragingUp()(rmgpy.data.kinetics.KineticsRules method),34

findIsomorphism() (rmgpy.molecule.graph.Graphmethod), 86

findIsomorphism() (rmgpy.molecule.Group method), 101findIsomorphism() (rmgpy.molecule.Molecule method),

94findIsomorphism() (rmgpy.molecule.vf2.VF2 method),

88findSubgraphIsomorphisms()

(rmgpy.molecule.graph.Graph method), 86findSubgraphIsomorphisms() (rmgpy.molecule.Group

method), 101findSubgraphIsomorphisms() (rmgpy.molecule.Molecule

method), 94findSubgraphIsomorphisms() (rmgpy.molecule.vf2.VF2

method), 88finish() (rmgpy.rmg.main.RMG method), 149fitCosinePotentialToData()

(rmgpy.statmech.HinderedRotor method),173

fitFourierPotentialToData()(rmgpy.statmech.HinderedRotor method),174

fitStatmechDirect() (in module rmgpy.data.statmechfit),44

fitStatmechPseudo() (in module rmgpy.data.statmechfit),44

fitStatmechPseudoRotors() (in modulermgpy.data.statmechfit), 44

fitStatmechToHeatCapacity() (in modulermgpy.data.statmechfit), 44

fitToData() (rmgpy.kinetics.Arrhenius method), 67fitToData() (rmgpy.kinetics.Chebyshev method), 75fitToData() (rmgpy.kinetics.PDepArrhenius method), 71fitToData() (rmgpy.thermo.Wilhoit method), 181fitToDataForConstantB() (rmgpy.thermo.Wilhoit

method), 182fixBarrierHeight() (rmgpy.data.kinetics.DepositoryReaction

method), 18fixBarrierHeight() (rmgpy.data.kinetics.LibraryReaction

method), 37fixBarrierHeight() (rmgpy.data.kinetics.TemplateReaction

method), 53fixBarrierHeight() (rmgpy.reaction.Reaction method),

141fixBarrierHeight() (rmgpy.rmg.pdep.PDepReaction

method), 153fixDiffusionLimitedA() (rmgpy.data.kinetics.DepositoryReaction

method), 18fixDiffusionLimitedA() (rmgpy.data.kinetics.LibraryReaction

method), 37fixDiffusionLimitedA() (rmgpy.data.kinetics.TemplateReaction

method), 53fixDiffusionLimitedA() (rmgpy.reaction.Reaction

method), 141

Index 199


fixDiffusionLimitedA() (rmgpy.rmg.pdep.PDepReactionmethod), 153

fourier (rmgpy.statmech.HinderedRotor attribute), 174frequencies (rmgpy.statmech.HarmonicOscillator at-

tribute), 172frequency (rmgpy.kinetics.Eckart attribute), 83frequency (rmgpy.kinetics.Wigner attribute), 82frequency (rmgpy.statmech.HinderedRotor attribute), 174fromAdjacencyList() (in module rmgpy.molecule.adjlist),

106fromAdjacencyList() (rmgpy.molecule.Group method),

101fromAdjacencyList() (rmgpy.molecule.Molecule

method), 94fromAdjacencyList() (rmgpy.rmg.model.Species

method), 155fromAdjacencyList() (rmgpy.species.Species method),

161fromAugmentedInChI() (rmgpy.molecule.Molecule

method), 94fromInChI() (rmgpy.molecule.Molecule method), 94fromSMARTS() (rmgpy.molecule.Molecule method), 94fromSMILES() (rmgpy.molecule.Molecule method), 95fromSMILES() (rmgpy.rmg.model.Species method), 155fromSMILES() (rmgpy.species.Species method), 161fromXYZ() (rmgpy.molecule.Molecule method), 95

GGaussian (class in rmgpy.qm.gaussian), 124GaussianLog (class in rmgpy.cantherm.gaussian), 4GaussianMol (class in rmgpy.qm.gaussian), 124GaussianMolPM3 (class in rmgpy.qm.gaussian), 126GaussianMolPM6 (class in rmgpy.qm.gaussian), 127generate3dTS() (rmgpy.data.kinetics.DepositoryReaction

method), 18generate3dTS() (rmgpy.data.kinetics.LibraryReaction

method), 37generate3dTS() (rmgpy.data.kinetics.TemplateReaction

method), 53generate3dTS() (rmgpy.reaction.Reaction method), 141generate3dTS() (rmgpy.rmg.pdep.PDepReaction

method), 153generate_rate_coefficients()

(rmgpy.solver.SimpleReactor method), 159generate_reactant_product_indices()

(rmgpy.solver.ReactionSystem method),157

generate_reactant_product_indices()(rmgpy.solver.SimpleReactor method), 159

generate_reaction_indices()(rmgpy.solver.ReactionSystem method),157

generate_reaction_indices() (rmgpy.solver.SimpleReactormethod), 159

generate_species_indices()(rmgpy.solver.ReactionSystem method),157

generate_species_indices() (rmgpy.solver.SimpleReactormethod), 159

generateCollisionMatrix() (rmgpy.pdep.Configurationmethod), 111

generateCollisionMatrix()(rmgpy.pdep.SingleExponentialDown method),110

generateEnergyTransferModel()(rmgpy.rmg.model.Species method), 155

generateEnergyTransferModel() (rmgpy.species.Speciesmethod), 161

generateFrequencies() (rmgpy.data.statmech.GroupFrequenciesmethod), 20

generateFullMEMatrix() (in module rmgpy.pdep.me),114

generateGroupAdditivityValues()(rmgpy.data.kinetics.KineticsGroups method),30

generateKinetics() (rmgpy.cantherm.KineticsJobmethod), 6

generateKinetics() (rmgpy.rmg.model.CoreEdgeReactionModelmethod), 145

generateOldLibraryEntry()(rmgpy.data.statmech.StatmechGroupsmethod), 48

generateOldLibraryEntry()(rmgpy.data.statmech.StatmechLibrarymethod), 51

generateOldLibraryEntry()(rmgpy.data.thermo.ThermoGroups method),60

generateOldLibraryEntry()(rmgpy.data.thermo.ThermoLibrary method),62

generateOldTree() (rmgpy.data.base.Database method),15

generateOldTree() (rmgpy.data.kinetics.KineticsDepositorymethod), 23

generateOldTree() (rmgpy.data.kinetics.KineticsFamilymethod), 26

generateOldTree() (rmgpy.data.kinetics.KineticsGroupsmethod), 30

generateOldTree() (rmgpy.data.kinetics.KineticsLibrarymethod), 32

generateOldTree() (rmgpy.data.kinetics.KineticsRulesmethod), 34

generateOldTree() (rmgpy.data.statmech.StatmechDepositorymethod), 42

generateOldTree() (rmgpy.data.statmech.StatmechGroupsmethod), 48

generateOldTree() (rmgpy.data.statmech.StatmechLibrary

200 Index


method), 51generateOldTree() (rmgpy.data.thermo.ThermoDepository

method), 58generateOldTree() (rmgpy.data.thermo.ThermoGroups

method), 60generateOldTree() (rmgpy.data.thermo.ThermoLibrary

method), 62generatePairs() (rmgpy.data.kinetics.DepositoryReaction

method), 18generatePairs() (rmgpy.data.kinetics.LibraryReaction

method), 37generatePairs() (rmgpy.data.kinetics.TemplateReaction

method), 53generatePairs() (rmgpy.reaction.Reaction method), 141generatePairs() (rmgpy.rmg.pdep.PDepReaction method),

153generatePressureList() (rmgpy.cantherm.PressureDependenceJob

method), 9generateProductTemplate()


generateQMData() (rmgpy.qm.gaussian.GaussianMolmethod), 124

generateQMData() (rmgpy.qm.gaussian.GaussianMolPM3method), 126

generateQMData() (rmgpy.qm.gaussian.GaussianMolPM6method), 128

generateQMData() (rmgpy.qm.molecule.QMMoleculemethod), 121

generateQMData() (rmgpy.qm.mopac.MopacMolmethod), 130

generateQMData() (rmgpy.qm.mopac.MopacMolPM3method), 131



generateRDKitGeometries()(rmgpy.qm.molecule.Geometry method),120

generateReactions() (rmgpy.data.kinetics.KineticsDatabasemethod), 21

generateReactions() (rmgpy.data.kinetics.KineticsFamilymethod), 26

generateReactionsFromFamilies()(rmgpy.data.kinetics.KineticsDatabasemethod), 21

generateReactionsFromLibraries()(rmgpy.data.kinetics.KineticsDatabasemethod), 21

generateReactionsFromLibrary()(rmgpy.data.kinetics.KineticsDatabasemethod), 21

generateResonanceIsomers() (rmgpy.rmg.model.Species

method), 155generateResonanceIsomers() (rmgpy.species.Species

method), 161generateReverseRateCoefficient()

(rmgpy.data.kinetics.DepositoryReactionmethod), 18

generateReverseRateCoefficient()(rmgpy.data.kinetics.LibraryReaction method),38

generateReverseRateCoefficient()(rmgpy.data.kinetics.TemplateReactionmethod), 54

generateReverseRateCoefficient()(rmgpy.reaction.Reaction method), 142

generateReverseRateCoefficient()(rmgpy.rmg.pdep.PDepReaction method),153

generateStatMech() (rmgpy.rmg.model.Species method),155

generateStatMech() (rmgpy.species.Species method), 161generateTemperatureList()

(rmgpy.cantherm.PressureDependenceJobmethod), 9

generateThermo() (rmgpy.cantherm.ThermoJob method),9

generateThermoData() (rmgpy.qm.gaussian.GaussianMolmethod), 125

generateThermoData() (rmgpy.qm.gaussian.GaussianMolPM3method), 126

generateThermoData() (rmgpy.qm.gaussian.GaussianMolPM6method), 128

generateThermoData() (rmgpy.qm.molecule.QMMoleculemethod), 121

generateThermoData() (rmgpy.qm.mopac.MopacMolmethod), 130

generateThermoData() (rmgpy.qm.mopac.MopacMolPM3method), 132



generateTransportData() (rmgpy.rmg.model.Speciesmethod), 156

generateTransportData() (rmgpy.species.Speciesmethod), 162

generic_visit() (rmgpy.cantherm.output.PrettifyVisitormethod), 7

Geometry (class in rmgpy.cantherm.geometry), 5Geometry (class in rmgpy.qm.molecule), 120get_species_index() (rmgpy.solver.ReactionSystem

method), 157get_species_index() (rmgpy.solver.SimpleReactor

method), 159getActiveModes() (rmgpy.statmech.Conformer method),

Index 201


176getAllCycles() (rmgpy.molecule.graph.Graph method),

86getAllCycles() (rmgpy.molecule.Group method), 101getAllCycles() (rmgpy.molecule.Molecule method), 95getAllCyclicVertices() (rmgpy.molecule.graph.Graph

method), 86getAllCyclicVertices() (rmgpy.molecule.Group method),

101getAllCyclicVertices() (rmgpy.molecule.Molecule

method), 95getAllPolycyclicVertices() (rmgpy.molecule.graph.Graph

method), 86getAllPolycyclicVertices() (rmgpy.molecule.Group

method), 101getAllPolycyclicVertices() (rmgpy.molecule.Molecule

method), 95getAllRules() (rmgpy.data.kinetics.KineticsRules

method), 34getAllSpecies() (rmgpy.pdep.Network method), 113getAllSpecies() (rmgpy.rmg.pdep.PDepNetwork

method), 151getAllThermoData() (rmgpy.data.thermo.ThermoDatabase

method), 56getAlpha() (rmgpy.pdep.SingleExponentialDown

method), 110getAtomType() (in module rmgpy.molecule), 89getBond() (rmgpy.molecule.Group method), 101getBond() (rmgpy.molecule.Molecule method), 95getBondOrdersForAtom() (rmgpy.molecule.Atom

method), 91getBonds() (rmgpy.molecule.Group method), 101getBonds() (rmgpy.molecule.Molecule method), 95getCanteraEfficiencies() (rmgpy.kinetics.Chebyshev

method), 75getCanteraEfficiencies() (rmgpy.kinetics.Lindemann

method), 78getCanteraEfficiencies() (rmgpy.kinetics.MultiPDepArrhenius

method), 72getCanteraEfficiencies() (rmgpy.kinetics.PDepArrhenius

method), 71getCanteraEfficiencies() (rmgpy.kinetics.PDepKineticsData

method), 69getCanteraEfficiencies() (rmgpy.kinetics.ThirdBody

method), 76getCanteraEfficiencies() (rmgpy.kinetics.Troe method),

81getCenterOfMass() (rmgpy.cantherm.geometry.Geometry

method), 5getCenterOfMass() (rmgpy.statmech.Conformer

method), 176getConversionFactorFromSI()

(rmgpy.quantity.ArrayQuantity method),139

getConversionFactorFromSI()(rmgpy.quantity.ScalarQuantity method),138

getConversionFactorToSI()(rmgpy.quantity.ArrayQuantity method),139

getConversionFactorToSI()(rmgpy.quantity.ScalarQuantity method),138

getCrudeMolFilePath() (rmgpy.qm.molecule.Geometrymethod), 120

getDensityOfStates() (in modulermgpy.statmech.schrodinger), 175

getDensityOfStates() (rmgpy.rmg.model.Speciesmethod), 156

getDensityOfStates() (rmgpy.species.Species method),162

getDensityOfStates() (rmgpy.species.TransitionStatemethod), 163

getDensityOfStates() (rmgpy.statmech.Conformermethod), 177

getDensityOfStates() (rmgpy.statmech.HarmonicOscillatormethod), 172

getDensityOfStates() (rmgpy.statmech.HinderedRotormethod), 174

getDensityOfStates() (rmgpy.statmech.IdealGasTranslationmethod), 166

getDensityOfStates() (rmgpy.statmech.KRotor method),169

getDensityOfStates() (rmgpy.statmech.LinearRotormethod), 167

getDensityOfStates() (rmgpy.statmech.NonlinearRotormethod), 168

getDensityOfStates() (rmgpy.statmech.SphericalTopRotormethod), 170

getDisparateRings() (rmgpy.molecule.graph.Graphmethod), 87

getDisparateRings() (rmgpy.molecule.Group method),101

getDisparateRings() (rmgpy.molecule.Molecule method),95

getEdge() (rmgpy.molecule.graph.Graph method), 87getEdge() (rmgpy.molecule.Group method), 102getEdge() (rmgpy.molecule.Molecule method), 95getEdges() (rmgpy.molecule.graph.Graph method), 87getEdges() (rmgpy.molecule.Group method), 102getEdges() (rmgpy.molecule.Molecule method), 95getEffectiveColliderEfficiencies()

(rmgpy.kinetics.Chebyshev method), 75getEffectiveColliderEfficiencies()

(rmgpy.kinetics.Lindemann method), 78getEffectiveColliderEfficiencies()

(rmgpy.kinetics.MultiPDepArrhenius method),73

202 Index


getEffectiveColliderEfficiencies()(rmgpy.kinetics.PDepArrhenius method),71

getEffectiveColliderEfficiencies()(rmgpy.kinetics.PDepKineticsData method), 69

getEffectiveColliderEfficiencies()(rmgpy.kinetics.ThirdBody method), 76

getEffectiveColliderEfficiencies() (rmgpy.kinetics.Troemethod), 81

getEffectivePressure() (rmgpy.kinetics.Chebyshevmethod), 75

getEffectivePressure() (rmgpy.kinetics.Lindemannmethod), 78

getEffectivePressure() (rmgpy.kinetics.MultiPDepArrheniusmethod), 73

getEffectivePressure() (rmgpy.kinetics.PDepArrheniusmethod), 71

getEffectivePressure() (rmgpy.kinetics.PDepKineticsDatamethod), 69

getEffectivePressure() (rmgpy.kinetics.ThirdBodymethod), 76

getEffectivePressure() (rmgpy.kinetics.Troe method), 81getElement() (in module rmgpy.molecule), 89getEnthalpiesOfReaction()


getEnthalpiesOfReaction()(rmgpy.data.kinetics.LibraryReaction method),38

getEnthalpiesOfReaction()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getEnthalpiesOfReaction() (rmgpy.reaction.Reactionmethod), 142

getEnthalpiesOfReaction()(rmgpy.rmg.pdep.PDepReaction method),153

getEnthalpy() (in module rmgpy.statmech.schrodinger),175

getEnthalpy() (rmgpy.pdep.Configuration method), 112getEnthalpy() (rmgpy.rmg.model.Species method), 156getEnthalpy() (rmgpy.species.Species method), 162getEnthalpy() (rmgpy.species.TransitionState method),

163getEnthalpy() (rmgpy.statmech.Conformer method), 177getEnthalpy() (rmgpy.statmech.HarmonicOscillator

method), 172getEnthalpy() (rmgpy.statmech.HinderedRotor method),

174getEnthalpy() (rmgpy.statmech.IdealGasTranslation

method), 166getEnthalpy() (rmgpy.statmech.KRotor method), 169getEnthalpy() (rmgpy.statmech.LinearRotor method), 167getEnthalpy() (rmgpy.statmech.NonlinearRotor method),

168getEnthalpy() (rmgpy.statmech.SphericalTopRotor

method), 170getEnthalpy() (rmgpy.thermo.NASA method), 184getEnthalpy() (rmgpy.thermo.NASAPolynomial method),

186getEnthalpy() (rmgpy.thermo.ThermoData method), 179getEnthalpy() (rmgpy.thermo.Wilhoit method), 182getEnthalpyOfReaction()


getEnthalpyOfReaction()(rmgpy.data.kinetics.LibraryReaction method),38

getEnthalpyOfReaction()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getEnthalpyOfReaction() (rmgpy.reaction.Reactionmethod), 142

getEnthalpyOfReaction()(rmgpy.rmg.pdep.PDepReaction method),153

getEntries() (rmgpy.data.kinetics.KineticsRules method),35

getEntriesToSave() (rmgpy.data.base.Database method),15

getEntriesToSave() (rmgpy.data.kinetics.KineticsDepositorymethod), 23

getEntriesToSave() (rmgpy.data.kinetics.KineticsFamilymethod), 26

getEntriesToSave() (rmgpy.data.kinetics.KineticsGroupsmethod), 30

getEntriesToSave() (rmgpy.data.kinetics.KineticsLibrarymethod), 32

getEntriesToSave() (rmgpy.data.kinetics.KineticsRulesmethod), 35

getEntriesToSave() (rmgpy.data.statmech.StatmechDepositorymethod), 42

getEntriesToSave() (rmgpy.data.statmech.StatmechGroupsmethod), 48

getEntriesToSave() (rmgpy.data.statmech.StatmechLibrarymethod), 51

getEntriesToSave() (rmgpy.data.thermo.ThermoDepositorymethod), 58

getEntriesToSave() (rmgpy.data.thermo.ThermoGroupsmethod), 60

getEntriesToSave() (rmgpy.data.thermo.ThermoLibrarymethod), 62

getEntropiesOfReaction()(rmgpy.data.kinetics.DepositoryReactionmethod), 18

getEntropiesOfReaction()(rmgpy.data.kinetics.LibraryReaction method),38

Index 203


getEntropiesOfReaction()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getEntropiesOfReaction() (rmgpy.reaction.Reactionmethod), 142

getEntropiesOfReaction()(rmgpy.rmg.pdep.PDepReaction method),154

getEntropy() (in module rmgpy.statmech.schrodinger),175

getEntropy() (rmgpy.pdep.Configuration method), 112getEntropy() (rmgpy.rmg.model.Species method), 156getEntropy() (rmgpy.species.Species method), 162getEntropy() (rmgpy.species.TransitionState method),

163getEntropy() (rmgpy.statmech.Conformer method), 177getEntropy() (rmgpy.statmech.HarmonicOscillator

method), 172getEntropy() (rmgpy.statmech.HinderedRotor method),

174getEntropy() (rmgpy.statmech.IdealGasTranslation

method), 166getEntropy() (rmgpy.statmech.KRotor method), 169getEntropy() (rmgpy.statmech.LinearRotor method), 167getEntropy() (rmgpy.statmech.NonlinearRotor method),

168getEntropy() (rmgpy.statmech.SphericalTopRotor

method), 171getEntropy() (rmgpy.thermo.NASA method), 184getEntropy() (rmgpy.thermo.NASAPolynomial method),

187getEntropy() (rmgpy.thermo.ThermoData method), 179getEntropy() (rmgpy.thermo.Wilhoit method), 182getEntropyOfReaction() (rmgpy.data.kinetics.DepositoryReaction

method), 18getEntropyOfReaction() (rmgpy.data.kinetics.LibraryReaction

method), 38getEntropyOfReaction() (rmgpy.data.kinetics.TemplateReaction

method), 54getEntropyOfReaction() (rmgpy.reaction.Reaction

method), 142getEntropyOfReaction() (rmgpy.rmg.pdep.PDepReaction

method), 154getEquilibriumConstant()


getEquilibriumConstant()(rmgpy.data.kinetics.LibraryReaction method),38

getEquilibriumConstant()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getEquilibriumConstant() (rmgpy.reaction.Reactionmethod), 142

getEquilibriumConstant()(rmgpy.rmg.pdep.PDepReaction method),154

getEquilibriumConstants()(rmgpy.data.kinetics.DepositoryReactionmethod), 19

getEquilibriumConstants()(rmgpy.data.kinetics.LibraryReaction method),38

getEquilibriumConstants()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getEquilibriumConstants() (rmgpy.reaction.Reactionmethod), 142

getEquilibriumConstants()(rmgpy.rmg.pdep.PDepReaction method),154

getFeatures() (rmgpy.molecule.AtomType method), 89getFilePath() (rmgpy.qm.gaussian.GaussianMol method),

125getFilePath() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126getFilePath() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128getFilePath() (rmgpy.qm.molecule.Geometry method),

120getFilePath() (rmgpy.qm.molecule.QMMolecule

method), 121getFilePath() (rmgpy.qm.mopac.MopacMol method), 130getFilePath() (rmgpy.qm.mopac.MopacMolPM3

method), 132getFilePath() (rmgpy.qm.mopac.MopacMolPM6

method), 133getFilePath() (rmgpy.qm.mopac.MopacMolPM7

method), 135getFingerprint() (rmgpy.molecule.Molecule method), 95getFormula() (rmgpy.molecule.Molecule method), 95getForwardReactionForFamilyEntry()


getFreeEnergiesOfReaction()(rmgpy.data.kinetics.DepositoryReactionmethod), 19

getFreeEnergiesOfReaction()(rmgpy.data.kinetics.LibraryReaction method),38

getFreeEnergiesOfReaction()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getFreeEnergiesOfReaction() (rmgpy.reaction.Reactionmethod), 142

getFreeEnergiesOfReaction()(rmgpy.rmg.pdep.PDepReaction method),154

204 Index


getFreeEnergy() (rmgpy.pdep.Configuration method),112

getFreeEnergy() (rmgpy.rmg.model.Species method), 156getFreeEnergy() (rmgpy.species.Species method), 162getFreeEnergy() (rmgpy.species.TransitionState method),

163getFreeEnergy() (rmgpy.statmech.Conformer method),

177getFreeEnergy() (rmgpy.thermo.NASA method), 184getFreeEnergy() (rmgpy.thermo.NASAPolynomial

method), 187getFreeEnergy() (rmgpy.thermo.ThermoData method),

179getFreeEnergy() (rmgpy.thermo.Wilhoit method), 182getFreeEnergyOfReaction()


getFreeEnergyOfReaction()(rmgpy.data.kinetics.LibraryReaction method),38

getFreeEnergyOfReaction()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getFreeEnergyOfReaction() (rmgpy.reaction.Reactionmethod), 142

getFreeEnergyOfReaction()(rmgpy.rmg.pdep.PDepReaction method),154

getFrequency() (rmgpy.statmech.HinderedRotor method),174

getFrequencyGroups() (rmgpy.data.statmech.StatmechGroupsmethod), 48

getHamiltonian() (rmgpy.statmech.HinderedRotormethod), 174

getHeatCapacity() (in modulermgpy.statmech.schrodinger), 176

getHeatCapacity() (rmgpy.pdep.Configuration method),112

getHeatCapacity() (rmgpy.rmg.model.Species method),156

getHeatCapacity() (rmgpy.species.Species method), 162getHeatCapacity() (rmgpy.species.TransitionState

method), 163getHeatCapacity() (rmgpy.statmech.Conformer method),

177getHeatCapacity() (rmgpy.statmech.HarmonicOscillator

method), 172getHeatCapacity() (rmgpy.statmech.HinderedRotor

method), 174getHeatCapacity() (rmgpy.statmech.IdealGasTranslation

method), 166getHeatCapacity() (rmgpy.statmech.KRotor method), 169getHeatCapacity() (rmgpy.statmech.LinearRotor

method), 167

getHeatCapacity() (rmgpy.statmech.NonlinearRotormethod), 168

getHeatCapacity() (rmgpy.statmech.SphericalTopRotormethod), 171

getHeatCapacity() (rmgpy.thermo.NASA method), 184getHeatCapacity() (rmgpy.thermo.NASAPolynomial

method), 187getHeatCapacity() (rmgpy.thermo.ThermoData method),

179getHeatCapacity() (rmgpy.thermo.Wilhoit method), 182getInChiKeyAug() (rmgpy.qm.gaussian.GaussianMol

method), 125getInChiKeyAug() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126getInChiKeyAug() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128getInChiKeyAug() (rmgpy.qm.molecule.QMMolecule

method), 121getInChiKeyAug() (rmgpy.qm.mopac.MopacMol

method), 130getInChiKeyAug() (rmgpy.qm.mopac.MopacMolPM3



method), 135getInternalReducedMomentOfInertia()

(rmgpy.cantherm.geometry.Geometry method),5

getInternalReducedMomentOfInertia()(rmgpy.statmech.Conformer method), 177

getKinetics() (rmgpy.data.kinetics.KineticsFamilymethod), 26

getKineticsForTemplate()(rmgpy.data.kinetics.KineticsFamily method),26

getKineticsFromDepository()(rmgpy.data.kinetics.KineticsFamily method),26

getLabeledAtom() (rmgpy.molecule.Group method), 102getLabeledAtom() (rmgpy.molecule.Molecule method),

95getLabeledAtoms() (rmgpy.molecule.Group method),

102getLabeledAtoms() (rmgpy.molecule.Molecule method),

95getLabeledReactantsAndProducts()


getLeakBranchingRatios()(rmgpy.rmg.pdep.PDepNetwork method),151

getLeakCoefficient() (rmgpy.rmg.pdep.PDepNetworkmethod), 151

Index 205


getLevelDegeneracy() (rmgpy.statmech.HinderedRotormethod), 174

getLevelDegeneracy() (rmgpy.statmech.KRotor method),169

getLevelDegeneracy() (rmgpy.statmech.LinearRotormethod), 167

getLevelDegeneracy() (rmgpy.statmech.SphericalTopRotormethod), 171

getLevelEnergy() (rmgpy.statmech.HinderedRotormethod), 174

getLevelEnergy() (rmgpy.statmech.KRotor method), 169getLevelEnergy() (rmgpy.statmech.LinearRotor method),

167getLevelEnergy() (rmgpy.statmech.SphericalTopRotor

method), 171getLists() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 145getMaximumLeakSpecies()


getModelSize() (rmgpy.rmg.model.CoreEdgeReactionModelmethod), 145

getMolecularWeight() (rmgpy.molecule.Moleculemethod), 95

getMolFilePathForCalculation()(rmgpy.qm.gaussian.GaussianMol method),125

getMolFilePathForCalculation()(rmgpy.qm.gaussian.GaussianMolPM3method), 126

getMolFilePathForCalculation()(rmgpy.qm.gaussian.GaussianMolPM6method), 128

getMolFilePathForCalculation()(rmgpy.qm.molecule.QMMolecule method),122

getMolFilePathForCalculation()(rmgpy.qm.mopac.MopacMol method), 130

getMolFilePathForCalculation()(rmgpy.qm.mopac.MopacMolPM3 method),132



getMomentOfInertiaTensor()(rmgpy.cantherm.geometry.Geometry method),5

getMomentOfInertiaTensor()(rmgpy.statmech.Conformer method), 177

getMonocyclicRings() (rmgpy.molecule.graph.Graphmethod), 87

getMonocyclicRings() (rmgpy.molecule.Group method),102

getMonocyclicRings() (rmgpy.molecule.Moleculemethod), 95

getNetCharge() (rmgpy.molecule.Molecule method), 95getNumAtoms() (rmgpy.molecule.Molecule method), 95getNumberDegreesOfFreedom()

(rmgpy.statmech.Conformer method), 177getNumberOfAtoms() (rmgpy.cantherm.gaussian.GaussianLog

method), 4getNumberOfRadicalElectrons()

(rmgpy.molecule.Molecule method), 96getOtherVertex() (rmgpy.molecule.Bond method), 92getOtherVertex() (rmgpy.molecule.graph.Edge method),

86getOtherVertex() (rmgpy.molecule.GroupBond method),

100getParser() (rmgpy.qm.gaussian.GaussianMol method),

125getParser() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126getParser() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128getParser() (rmgpy.qm.mopac.Mopac method), 129getParser() (rmgpy.qm.mopac.MopacMol method), 130getParser() (rmgpy.qm.mopac.MopacMolPM3 method),

132getParser() (rmgpy.qm.mopac.MopacMolPM6 method),

133getParser() (rmgpy.qm.mopac.MopacMolPM7 method),

135getPartitionFunction() (in module

rmgpy.statmech.schrodinger), 176getPartitionFunction() (rmgpy.rmg.model.Species

method), 156getPartitionFunction() (rmgpy.species.Species method),

162getPartitionFunction() (rmgpy.species.TransitionState

method), 163getPartitionFunction() (rmgpy.statmech.Conformer

method), 177getPartitionFunction() (rmgpy.statmech.HarmonicOscillator

method), 172getPartitionFunction() (rmgpy.statmech.HinderedRotor

method), 174getPartitionFunction() (rmgpy.statmech.IdealGasTranslation

method), 166getPartitionFunction() (rmgpy.statmech.KRotor method),

169getPartitionFunction() (rmgpy.statmech.LinearRotor

method), 167getPartitionFunction() (rmgpy.statmech.NonlinearRotor

method), 168getPartitionFunction() (rmgpy.statmech.SphericalTopRotor

206 Index


method), 171getPolycyclicRings() (rmgpy.molecule.graph.Graph

method), 87getPolycyclicRings() (rmgpy.molecule.Group method),

102getPolycyclicRings() (rmgpy.molecule.Molecule

method), 96getPossibleStructures() (rmgpy.data.base.LogicOr

method), 39getPotential() (rmgpy.statmech.HinderedRotor method),

174getPrincipalMomentsOfInertia()

(rmgpy.cantherm.geometry.Geometry method),5

getPrincipalMomentsOfInertia()(rmgpy.statmech.Conformer method), 177

getRadicalAtoms() (rmgpy.molecule.Molecule method),96

getRadicalCount() (rmgpy.molecule.Molecule method),96

getRateCoefficient() (rmgpy.data.kinetics.DepositoryReactionmethod), 19

getRateCoefficient() (rmgpy.data.kinetics.LibraryReactionmethod), 38

getRateCoefficient() (rmgpy.data.kinetics.TemplateReactionmethod), 54

getRateCoefficient() (rmgpy.kinetics.Arrhenius method),67

getRateCoefficient() (rmgpy.kinetics.Chebyshevmethod), 75

getRateCoefficient() (rmgpy.kinetics.KineticsDatamethod), 65

getRateCoefficient() (rmgpy.kinetics.Lindemannmethod), 78

getRateCoefficient() (rmgpy.kinetics.MultiArrheniusmethod), 68

getRateCoefficient() (rmgpy.kinetics.MultiPDepArrheniusmethod), 73

getRateCoefficient() (rmgpy.kinetics.PDepArrheniusmethod), 71

getRateCoefficient() (rmgpy.kinetics.PDepKineticsDatamethod), 69

getRateCoefficient() (rmgpy.kinetics.ThirdBody method),76

getRateCoefficient() (rmgpy.kinetics.Troe method), 81getRateCoefficient() (rmgpy.reaction.Reaction method),

142getRateCoefficient() (rmgpy.rmg.pdep.PDepReaction

method), 154getRateRule() (rmgpy.data.kinetics.KineticsFamily

method), 27getReactionPairs() (rmgpy.data.kinetics.KineticsFamily

method), 27getReactionTemplate() (rmgpy.data.kinetics.KineticsFamily

method), 27getReactionTemplate() (rmgpy.data.kinetics.KineticsGroups

method), 30getReactionTemplateLabels()


getRefinedMolFilePath() (rmgpy.qm.molecule.Geometrymethod), 120

getReverse() (rmgpy.data.kinetics.ReactionRecipemethod), 40

getRingGroupsFromComments()(rmgpy.data.thermo.ThermoDatabase method),56

getRootTemplate() (rmgpy.data.kinetics.KineticsFamilymethod), 27

getRule() (rmgpy.data.kinetics.KineticsRules method), 35getSmallestSetOfSmallestRings()

(rmgpy.molecule.graph.Graph method), 87getSmallestSetOfSmallestRings()

(rmgpy.molecule.Group method), 102getSmallestSetOfSmallestRings()

(rmgpy.molecule.Molecule method), 96getSource() (rmgpy.data.kinetics.DepositoryReaction

method), 19getSource() (rmgpy.data.kinetics.LibraryReaction

method), 38getSource() (rmgpy.data.kinetics.TemplateReaction

method), 54getSource() (rmgpy.rmg.pdep.PDepReaction method),

154getSourcesForTemplate()


getSpecies() (rmgpy.data.base.Database method), 15getSpecies() (rmgpy.data.kinetics.KineticsDepository

method), 23getSpecies() (rmgpy.data.kinetics.KineticsFamily

method), 27getSpecies() (rmgpy.data.kinetics.KineticsGroups

method), 30getSpecies() (rmgpy.data.kinetics.KineticsLibrary

method), 32getSpecies() (rmgpy.data.kinetics.KineticsRules method),

35getSpecies() (rmgpy.data.statmech.StatmechDepository

method), 42getSpecies() (rmgpy.data.statmech.StatmechGroups

method), 48getSpecies() (rmgpy.data.statmech.StatmechLibrary

method), 51getSpecies() (rmgpy.data.thermo.ThermoDepository

method), 58getSpecies() (rmgpy.data.thermo.ThermoGroups

method), 60

Index 207


getSpecies() (rmgpy.data.thermo.ThermoLibrarymethod), 62

getSpecies() (rmgpy.rmg.model.CoreEdgeReactionModelmethod), 146

getSpeciesIdentifier() (in module rmgpy.chemkin), 12getStatmechData() (rmgpy.data.statmech.StatmechDatabase

method), 41getStatmechData() (rmgpy.data.statmech.StatmechGroups

method), 48getStatmechDataFromDepository()

(rmgpy.data.statmech.StatmechDatabasemethod), 41

getStatmechDataFromGroups()(rmgpy.data.statmech.StatmechDatabasemethod), 41

getStatmechDataFromLibrary()(rmgpy.data.statmech.StatmechDatabasemethod), 41

getStoichiometricCoefficient()(rmgpy.data.kinetics.DepositoryReactionmethod), 19

getStoichiometricCoefficient()(rmgpy.data.kinetics.LibraryReaction method),38

getStoichiometricCoefficient()(rmgpy.data.kinetics.TemplateReactionmethod), 54

getStoichiometricCoefficient() (rmgpy.reaction.Reactionmethod), 142

getStoichiometricCoefficient()(rmgpy.rmg.pdep.PDepReaction method),154

getStoichiometryMatrix()(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 146

getSumOfStates() (in modulermgpy.statmech.schrodinger), 176

getSumOfStates() (rmgpy.rmg.model.Species method),156

getSumOfStates() (rmgpy.species.Species method), 162getSumOfStates() (rmgpy.species.TransitionState

method), 163getSumOfStates() (rmgpy.statmech.Conformer method),

177getSumOfStates() (rmgpy.statmech.HarmonicOscillator

method), 172getSumOfStates() (rmgpy.statmech.HinderedRotor

method), 174getSumOfStates() (rmgpy.statmech.IdealGasTranslation

method), 166getSumOfStates() (rmgpy.statmech.KRotor method), 169getSumOfStates() (rmgpy.statmech.LinearRotor method),

167getSumOfStates() (rmgpy.statmech.NonlinearRotor

method), 168getSumOfStates() (rmgpy.statmech.SphericalTopRotor

method), 171getSymmetricTopRotors() (rmgpy.statmech.Conformer

method), 177getSymmetryNumber() (rmgpy.molecule.Molecule

method), 96getSymmetryNumber() (rmgpy.rmg.model.Species

method), 156getSymmetryNumber() (rmgpy.species.Species method),

162getThermoData() (rmgpy.data.thermo.ThermoDatabase

method), 56getThermoData() (rmgpy.qm.main.QMCalculator

method), 120getThermoData() (rmgpy.rmg.model.Species method),

156getThermoData() (rmgpy.species.Species method), 162getThermoDataFromDepository()

(rmgpy.data.thermo.ThermoDatabase method),56

getThermoDataFromGroups()(rmgpy.data.thermo.ThermoDatabase method),56

getThermoDataFromLibraries()(rmgpy.data.thermo.ThermoDatabase method),56

getThermoDataFromLibrary()(rmgpy.data.thermo.ThermoDatabase method),56

getThermoFilePath() (rmgpy.qm.gaussian.GaussianMolmethod), 125

getThermoFilePath() (rmgpy.qm.gaussian.GaussianMolPM3method), 126

getThermoFilePath() (rmgpy.qm.gaussian.GaussianMolPM6method), 128

getThermoFilePath() (rmgpy.qm.molecule.QMMoleculemethod), 122

getThermoFilePath() (rmgpy.qm.mopac.MopacMolmethod), 130

getThermoFilePath() (rmgpy.qm.mopac.MopacMolPM3method), 132



getTotalMass() (rmgpy.cantherm.geometry.Geometrymethod), 5

getTotalMass() (rmgpy.statmech.Conformer method),177

getTrainingDepository() (rmgpy.data.kinetics.KineticsFamilymethod), 27

getTransportData() (rmgpy.rmg.model.Species method),156

208 Index


getTransportData() (rmgpy.species.Species method), 162getUncertainty() (rmgpy.quantity.ArrayQuantity method),

139getUncertainty() (rmgpy.quantity.ScalarQuantity

method), 138getUncertaintyType() (rmgpy.quantity.ArrayQuantity

method), 139getUncertaintyType() (rmgpy.quantity.ScalarQuantity

method), 138getURL() (rmgpy.data.kinetics.DepositoryReaction

method), 19getURL() (rmgpy.data.kinetics.LibraryReaction method),

38getURL() (rmgpy.data.kinetics.TemplateReaction

method), 54getURL() (rmgpy.molecule.Molecule method), 96getURL() (rmgpy.reaction.Reaction method), 142getURL() (rmgpy.rmg.pdep.PDepReaction method), 154getValue() (rmgpy.quantity.ArrayQuantity method), 139getValue() (rmgpy.quantity.ScalarQuantity method), 138Graph (class in rmgpy.molecule.graph), 86groundStateDegeneracy (rmgpy.qm.qmdata.QMData at-

tribute), 122Group (class in rmgpy.molecule), 100GroupAtom (class in rmgpy.molecule), 99GroupBond (class in rmgpy.molecule), 100GroupFrequencies (class in rmgpy.data.statmech), 20

HH0 (rmgpy.thermo.Wilhoit attribute), 181H298 (rmgpy.thermo.ThermoData attribute), 178HarmonicOscillator (class in rmgpy.statmech), 171harmonicOscillator_d_heatCapacity_d_freq() (in module

rmgpy.data.statmechfit), 44harmonicOscillator_heatCapacity() (in module

rmgpy.data.statmechfit), 44hasAtom() (rmgpy.molecule.Group method), 102hasAtom() (rmgpy.molecule.Molecule method), 96hasBond() (rmgpy.molecule.Group method), 102hasBond() (rmgpy.molecule.Molecule method), 96hasEdge() (rmgpy.molecule.graph.Graph method), 87hasEdge() (rmgpy.molecule.Group method), 102hasEdge() (rmgpy.molecule.Molecule method), 96hasRateRule() (rmgpy.data.kinetics.KineticsFamily

method), 27hasRule() (rmgpy.data.kinetics.KineticsRules method),

35hasStatMech() (rmgpy.pdep.Configuration method), 112hasStatMech() (rmgpy.rmg.model.Species method), 156hasStatMech() (rmgpy.species.Species method), 162hasTemplate() (rmgpy.data.kinetics.DepositoryReaction

method), 19hasTemplate() (rmgpy.data.kinetics.LibraryReaction

method), 38

hasTemplate() (rmgpy.data.kinetics.TemplateReactionmethod), 54

hasTemplate() (rmgpy.reaction.Reaction method), 142hasTemplate() (rmgpy.rmg.pdep.PDepReaction method),

154hasThermo() (rmgpy.pdep.Configuration method), 112hasThermo() (rmgpy.rmg.model.Species method), 156hasThermo() (rmgpy.species.Species method), 162hasVertex() (rmgpy.molecule.graph.Graph method), 87hasVertex() (rmgpy.molecule.Group method), 102hasVertex() (rmgpy.molecule.Molecule method), 96highPlimit (rmgpy.kinetics.Chebyshev attribute), 75highPlimit (rmgpy.kinetics.Lindemann attribute), 78highPlimit (rmgpy.kinetics.MultiPDepArrhenius at-

tribute), 73highPlimit (rmgpy.kinetics.PDepArrhenius attribute), 71highPlimit (rmgpy.kinetics.PDepKineticsData attribute),

69highPlimit (rmgpy.kinetics.ThirdBody attribute), 77highPlimit (rmgpy.kinetics.Troe attribute), 81HinderedRotor (class in rmgpy.statmech), 172hinderedRotor_d_heatCapacity_d_barr() (in module

rmgpy.data.statmechfit), 44hinderedRotor_d_heatCapacity_d_freq() (in module

rmgpy.data.statmechfit), 44hinderedRotor_heatCapacity() (in module

rmgpy.data.statmechfit), 44

IIdealGasTranslation (class in rmgpy.statmech), 165incrementLonePairs() (rmgpy.molecule.Atom method),

91incrementOrder() (rmgpy.molecule.Bond method), 93incrementRadical() (rmgpy.molecule.Atom method), 91inertia (rmgpy.statmech.HinderedRotor attribute), 174inertia (rmgpy.statmech.KRotor attribute), 170inertia (rmgpy.statmech.LinearRotor attribute), 167inertia (rmgpy.statmech.NonlinearRotor attribute), 168inertia (rmgpy.statmech.SphericalTopRotor attribute),

171inflate() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 146initialize() (rmgpy.data.statmechfit.DirectFit method), 45initialize() (rmgpy.data.statmechfit.PseudoFit method),

47initialize() (rmgpy.data.statmechfit.PseudoRotorFit

method), 46initialize() (rmgpy.pdep.Network method), 113initialize() (rmgpy.qm.gaussian.GaussianMol method),

125initialize() (rmgpy.qm.gaussian.GaussianMolPM3

method), 126initialize() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128

Index 209


initialize() (rmgpy.qm.main.QMCalculator method), 120initialize() (rmgpy.qm.molecule.QMMolecule method),

122initialize() (rmgpy.qm.mopac.MopacMol method), 130initialize() (rmgpy.qm.mopac.MopacMolPM3 method),

132initialize() (rmgpy.qm.mopac.MopacMolPM6 method),

134initialize() (rmgpy.qm.mopac.MopacMolPM7 method),

135initialize() (rmgpy.rmg.main.RMG method), 149initialize() (rmgpy.rmg.pdep.PDepNetwork method), 151initialize() (rmgpy.solver.ReactionSystem method), 157initialize() (rmgpy.solver.SimpleReactor method), 159initializeIndexSpeciesDict()


initializeLog() (in module rmgpy.rmg.main), 149initializeLog() (rmgpy.cantherm.CanTherm method), 6initializeModel() (rmgpy.solver.ReactionSystem method),

157initializeModel() (rmgpy.solver.SimpleReactor method),

159initiate_tolerances() (rmgpy.solver.ReactionSystem

method), 158initiate_tolerances() (rmgpy.solver.SimpleReactor

method), 159inputFileKeywords() (rmgpy.qm.gaussian.GaussianMol

method), 125inputFileKeywords() (rmgpy.qm.gaussian.GaussianMolPM3

method), 127inputFileKeywords() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128inputFileKeywords() (rmgpy.qm.mopac.MopacMol

method), 130inputFileKeywords() (rmgpy.qm.mopac.MopacMolPM3



method), 135inputFilePath (rmgpy.qm.gaussian.GaussianMol at-

tribute), 125inputFilePath (rmgpy.qm.gaussian.GaussianMolPM3 at-

tribute), 127inputFilePath (rmgpy.qm.gaussian.GaussianMolPM6 at-

tribute), 128inputFilePath (rmgpy.qm.molecule.QMMolecule at-

tribute), 122inputFilePath (rmgpy.qm.mopac.MopacMol attribute),

130inputFilePath (rmgpy.qm.mopac.MopacMolPM3 at-

tribute), 132inputFilePath (rmgpy.qm.mopac.MopacMolPM6 at-

tribute), 134inputFilePath (rmgpy.qm.mopac.MopacMolPM7 at-

tribute), 135inputFilePath (rmgpy.qm.symmetry.SymmetryJob at-

tribute), 123invalidate() (rmgpy.pdep.Network method), 114invalidate() (rmgpy.rmg.pdep.PDepNetwork method),

151is_equal() (rmgpy.molecule.Molecule method), 97isAromatic() (rmgpy.molecule.Molecule method), 96isAssociation() (rmgpy.data.kinetics.DepositoryReaction

method), 19isAssociation() (rmgpy.data.kinetics.LibraryReaction

method), 39isAssociation() (rmgpy.data.kinetics.TemplateReaction

method), 55isAssociation() (rmgpy.reaction.Reaction method), 142isAssociation() (rmgpy.rmg.pdep.PDepReaction method),

154isAtomInCycle() (rmgpy.molecule.Molecule method), 96isBalanced() (rmgpy.data.kinetics.DepositoryReaction

method), 19isBalanced() (rmgpy.data.kinetics.LibraryReaction

method), 39isBalanced() (rmgpy.data.kinetics.TemplateReaction

method), 55isBalanced() (rmgpy.reaction.Reaction method), 143isBalanced() (rmgpy.rmg.pdep.PDepReaction method),

154isBenzene() (rmgpy.molecule.Bond method), 93isBenzene() (rmgpy.molecule.GroupBond method), 100isBimolecular() (rmgpy.pdep.Configuration method), 112isBondInCycle() (rmgpy.molecule.Molecule method), 96isCarbon() (rmgpy.molecule.Atom method), 92isCyclic() (rmgpy.molecule.graph.Graph method), 87isCyclic() (rmgpy.molecule.Group method), 102isCyclic() (rmgpy.molecule.Molecule method), 96isDissociation() (rmgpy.data.kinetics.DepositoryReaction

method), 19isDissociation() (rmgpy.data.kinetics.LibraryReaction

method), 39isDissociation() (rmgpy.data.kinetics.TemplateReaction

method), 55isDissociation() (rmgpy.reaction.Reaction method), 143isDissociation() (rmgpy.rmg.pdep.PDepReaction

method), 154isDouble() (rmgpy.molecule.Bond method), 93isDouble() (rmgpy.molecule.GroupBond method), 100isEdgeInCycle() (rmgpy.molecule.graph.Graph method),

87isEdgeInCycle() (rmgpy.molecule.Group method), 102isEdgeInCycle() (rmgpy.molecule.Molecule method), 96isHydrogen() (rmgpy.molecule.Atom method), 92isIdentical() (rmgpy.molecule.Group method), 102

210 Index


isIdenticalTo() (rmgpy.kinetics.Arrhenius method), 67isIdenticalTo() (rmgpy.kinetics.Chebyshev method), 75isIdenticalTo() (rmgpy.kinetics.KineticsData method), 65isIdenticalTo() (rmgpy.kinetics.Lindemann method), 79isIdenticalTo() (rmgpy.kinetics.MultiArrhenius method),

68isIdenticalTo() (rmgpy.kinetics.MultiPDepArrhenius

method), 73isIdenticalTo() (rmgpy.kinetics.PDepArrhenius method),

71isIdenticalTo() (rmgpy.kinetics.PDepKineticsData

method), 70isIdenticalTo() (rmgpy.kinetics.ThirdBody method), 77isIdenticalTo() (rmgpy.kinetics.Troe method), 81isIdenticalTo() (rmgpy.thermo.NASA method), 184isIdenticalTo() (rmgpy.thermo.NASAPolynomial

method), 187isIdenticalTo() (rmgpy.thermo.ThermoData method), 179isIdenticalTo() (rmgpy.thermo.Wilhoit method), 182isIsomerization() (rmgpy.data.kinetics.DepositoryReaction

method), 19isIsomerization() (rmgpy.data.kinetics.LibraryReaction

method), 39isIsomerization() (rmgpy.data.kinetics.TemplateReaction

method), 55isIsomerization() (rmgpy.reaction.Reaction method), 143isIsomerization() (rmgpy.rmg.pdep.PDepReaction

method), 154isIsomorphic() (rmgpy.data.kinetics.DepositoryReaction

method), 19isIsomorphic() (rmgpy.data.kinetics.LibraryReaction

method), 39isIsomorphic() (rmgpy.data.kinetics.TemplateReaction

method), 55isIsomorphic() (rmgpy.molecule.graph.Graph method),

87isIsomorphic() (rmgpy.molecule.Group method), 102isIsomorphic() (rmgpy.molecule.Molecule method), 97isIsomorphic() (rmgpy.molecule.vf2.VF2 method), 88isIsomorphic() (rmgpy.reaction.Reaction method), 143isIsomorphic() (rmgpy.rmg.model.Species method), 156isIsomorphic() (rmgpy.rmg.pdep.PDepReaction method),

154isIsomorphic() (rmgpy.species.Species method), 162isLinear() (rmgpy.molecule.Molecule method), 97isMappingValid() (rmgpy.molecule.graph.Graph

method), 87isMappingValid() (rmgpy.molecule.Group method), 102isMappingValid() (rmgpy.molecule.Molecule method),

97isMoleculeForbidden() (rmgpy.data.kinetics.KineticsFamily

method), 27isNitrogen() (rmgpy.molecule.Atom method), 92isNonHydrogen() (rmgpy.molecule.Atom method), 92

isOxygen() (rmgpy.molecule.Atom method), 92isOxygen() (rmgpy.molecule.GroupAtom method), 99isPressureDependent() (rmgpy.kinetics.Arrhenius

method), 67isPressureDependent() (rmgpy.kinetics.Chebyshev

method), 75isPressureDependent() (rmgpy.kinetics.KineticsData

method), 65isPressureDependent() (rmgpy.kinetics.Lindemann

method), 79isPressureDependent() (rmgpy.kinetics.MultiArrhenius

method), 68isPressureDependent() (rmgpy.kinetics.MultiPDepArrhenius

method), 73isPressureDependent() (rmgpy.kinetics.PDepArrhenius

method), 71isPressureDependent() (rmgpy.kinetics.PDepKineticsData

method), 70isPressureDependent() (rmgpy.kinetics.ThirdBody

method), 77isPressureDependent() (rmgpy.kinetics.Troe method), 81isPressureValid() (rmgpy.kinetics.Chebyshev method), 75isPressureValid() (rmgpy.kinetics.Lindemann method),

79isPressureValid() (rmgpy.kinetics.MultiPDepArrhenius

method), 73isPressureValid() (rmgpy.kinetics.PDepArrhenius

method), 71isPressureValid() (rmgpy.kinetics.PDepKineticsData

method), 70isPressureValid() (rmgpy.kinetics.ThirdBody method), 77isPressureValid() (rmgpy.kinetics.Troe method), 81isRadical() (rmgpy.molecule.Molecule method), 97isSilicon() (rmgpy.molecule.Atom method), 92isSimilarTo() (rmgpy.kinetics.Arrhenius method), 67isSimilarTo() (rmgpy.kinetics.Chebyshev method), 75isSimilarTo() (rmgpy.kinetics.KineticsData method), 65isSimilarTo() (rmgpy.kinetics.Lindemann method), 79isSimilarTo() (rmgpy.kinetics.MultiArrhenius method),

68isSimilarTo() (rmgpy.kinetics.MultiPDepArrhenius

method), 73isSimilarTo() (rmgpy.kinetics.PDepArrhenius method),

71isSimilarTo() (rmgpy.kinetics.PDepKineticsData

method), 70isSimilarTo() (rmgpy.kinetics.ThirdBody method), 77isSimilarTo() (rmgpy.kinetics.Troe method), 81isSimilarTo() (rmgpy.thermo.NASA method), 184isSimilarTo() (rmgpy.thermo.NASAPolynomial method),

187isSimilarTo() (rmgpy.thermo.ThermoData method), 179isSimilarTo() (rmgpy.thermo.Wilhoit method), 182isSingle() (rmgpy.molecule.Bond method), 93

Index 211


isSingle() (rmgpy.molecule.GroupBond method), 100isSpecificCaseOf() (rmgpy.molecule.Atom method), 92isSpecificCaseOf() (rmgpy.molecule.AtomType method),

89isSpecificCaseOf() (rmgpy.molecule.Bond method), 93isSpecificCaseOf() (rmgpy.molecule.graph.Edge

method), 86isSpecificCaseOf() (rmgpy.molecule.graph.Vertex

method), 85isSpecificCaseOf() (rmgpy.molecule.GroupAtom

method), 99isSpecificCaseOf() (rmgpy.molecule.GroupBond

method), 100isSubgraphIsomorphic() (rmgpy.molecule.graph.Graph

method), 87isSubgraphIsomorphic() (rmgpy.molecule.Group

method), 103isSubgraphIsomorphic() (rmgpy.molecule.Molecule

method), 97isSubgraphIsomorphic() (rmgpy.molecule.vf2.VF2

method), 88isSulfur() (rmgpy.molecule.Atom method), 92isSulfur() (rmgpy.molecule.GroupAtom method), 99isTemperatureValid() (rmgpy.kinetics.Arrhenius method),

67isTemperatureValid() (rmgpy.kinetics.Chebyshev

method), 75isTemperatureValid() (rmgpy.kinetics.KineticsData

method), 65isTemperatureValid() (rmgpy.kinetics.Lindemann

method), 79isTemperatureValid() (rmgpy.kinetics.MultiArrhenius

method), 68isTemperatureValid() (rmgpy.kinetics.MultiPDepArrhenius

method), 73isTemperatureValid() (rmgpy.kinetics.PDepArrhenius

method), 72isTemperatureValid() (rmgpy.kinetics.PDepKineticsData

method), 70isTemperatureValid() (rmgpy.kinetics.ThirdBody

method), 77isTemperatureValid() (rmgpy.kinetics.Troe method), 81isTemperatureValid() (rmgpy.thermo.NASA method),

184isTemperatureValid() (rmgpy.thermo.NASAPolynomial

method), 187isTemperatureValid() (rmgpy.thermo.ThermoData

method), 179isTemperatureValid() (rmgpy.thermo.Wilhoit method),

182isTransitionState() (rmgpy.pdep.Configuration method),

112isTriple() (rmgpy.molecule.Bond method), 93isTriple() (rmgpy.molecule.GroupBond method), 100

isUncertaintyAdditive() (rmgpy.quantity.ArrayQuantitymethod), 139

isUncertaintyAdditive() (rmgpy.quantity.ScalarQuantitymethod), 138

isUncertaintyMultiplicative()(rmgpy.quantity.ArrayQuantity method),139

isUncertaintyMultiplicative()(rmgpy.quantity.ScalarQuantity method),138

isUnimolecular() (rmgpy.data.kinetics.DepositoryReactionmethod), 19

isUnimolecular() (rmgpy.data.kinetics.LibraryReactionmethod), 39

isUnimolecular() (rmgpy.data.kinetics.TemplateReactionmethod), 55

isUnimolecular() (rmgpy.pdep.Configuration method),112

isUnimolecular() (rmgpy.reaction.Reaction method), 143isUnimolecular() (rmgpy.rmg.pdep.PDepReaction

method), 155isVertexInCycle() (rmgpy.molecule.graph.Graph

method), 87isVertexInCycle() (rmgpy.molecule.Group method), 103isVertexInCycle() (rmgpy.molecule.Molecule method),

97

Jjacobian() (rmgpy.solver.SimpleReactor method), 159

Kkdata (rmgpy.kinetics.KineticsData attribute), 65kdata (rmgpy.kinetics.PDepKineticsData attribute), 70keywords (rmgpy.qm.gaussian.GaussianMolPM3 at-

tribute), 127keywords (rmgpy.qm.gaussian.GaussianMolPM6 at-

tribute), 128keywords (rmgpy.qm.mopac.MopacMol attribute), 130KineticsData (class in rmgpy.kinetics), 65KineticsDatabase (class in rmgpy.data.kinetics), 21KineticsDepository (class in rmgpy.data.kinetics), 22KineticsFamily (class in rmgpy.data.kinetics), 24KineticsGroups (class in rmgpy.data.kinetics), 30KineticsJob (class in rmgpy.cantherm), 6KineticsLibrary (class in rmgpy.data.kinetics), 32KineticsRules (class in rmgpy.data.kinetics), 34KRotor (class in rmgpy.statmech), 169kunits (rmgpy.kinetics.Chebyshev attribute), 75

Llabel (rmgpy.rmg.pdep.PDepNetwork attribute), 151LibraryReaction (class in rmgpy.data.kinetics), 36Lindemann (class in rmgpy.kinetics), 77LinearRotor (class in rmgpy.statmech), 166

212 Index


load() (rmgpy.cantherm.StatMechJob method), 9load() (rmgpy.data.base.Database method), 15load() (rmgpy.data.kinetics.KineticsDatabase method), 21load() (rmgpy.data.kinetics.KineticsFamily method), 27load() (rmgpy.data.kinetics.KineticsGroups method), 30load() (rmgpy.data.kinetics.KineticsRules method), 35load() (rmgpy.data.statmech.StatmechDatabase method),

41load() (rmgpy.data.statmech.StatmechDepository

method), 42load() (rmgpy.data.statmech.StatmechGroups method),

49load() (rmgpy.data.statmech.StatmechLibrary method),

51load() (rmgpy.data.thermo.ThermoDatabase method), 57load() (rmgpy.data.thermo.ThermoDepository method),

58load() (rmgpy.data.thermo.ThermoGroups method), 60load() (rmgpy.data.thermo.ThermoLibrary method), 62loadChemkinFile() (in module rmgpy.chemkin), 11loadConformer() (rmgpy.cantherm.gaussian.GaussianLog

method), 4loadDepository() (rmgpy.data.statmech.StatmechDatabase

method), 41loadDepository() (rmgpy.data.thermo.ThermoDatabase

method), 57loadEnergy() (rmgpy.cantherm.gaussian.GaussianLog

method), 4loadFamilies() (rmgpy.data.kinetics.KineticsDatabase

method), 21loadForbidden() (rmgpy.data.kinetics.KineticsFamily

method), 27loadForceConstantMatrix()

(rmgpy.cantherm.gaussian.GaussianLogmethod), 4

loadGeometry() (rmgpy.cantherm.gaussian.GaussianLogmethod), 4

loadGroups() (rmgpy.data.statmech.StatmechDatabasemethod), 41

loadGroups() (rmgpy.data.thermo.ThermoDatabasemethod), 57

loadInput() (rmgpy.rmg.main.RMG method), 149loadInputFile() (in module rmgpy.cantherm.input), 5loadInputFile() (rmgpy.cantherm.CanTherm method), 6loadLibraries() (rmgpy.data.kinetics.KineticsDatabase

method), 21loadLibraries() (rmgpy.data.statmech.StatmechDatabase

method), 41loadLibraries() (rmgpy.data.thermo.ThermoDatabase

method), 57loadNegativeFrequency()

(rmgpy.cantherm.gaussian.GaussianLogmethod), 4

loadOld() (rmgpy.data.base.Database method), 16

loadOld() (rmgpy.data.kinetics.KineticsDatabasemethod), 22

loadOld() (rmgpy.data.kinetics.KineticsDepositorymethod), 23

loadOld() (rmgpy.data.kinetics.KineticsFamily method),28

loadOld() (rmgpy.data.kinetics.KineticsGroups method),30

loadOld() (rmgpy.data.kinetics.KineticsLibrary method),32

loadOld() (rmgpy.data.kinetics.KineticsRules method),35

loadOld() (rmgpy.data.statmech.StatmechDatabasemethod), 41

loadOld() (rmgpy.data.statmech.StatmechDepositorymethod), 42

loadOld() (rmgpy.data.statmech.StatmechGroupsmethod), 49

loadOld() (rmgpy.data.statmech.StatmechLibrarymethod), 51

loadOld() (rmgpy.data.thermo.ThermoDatabase method),57

loadOld() (rmgpy.data.thermo.ThermoDepositorymethod), 58

loadOld() (rmgpy.data.thermo.ThermoGroups method),60

loadOld() (rmgpy.data.thermo.ThermoLibrary method),62

loadOldDictionary() (rmgpy.data.base.Database method),16

loadOldDictionary() (rmgpy.data.kinetics.KineticsDepositorymethod), 23

loadOldDictionary() (rmgpy.data.kinetics.KineticsFamilymethod), 28

loadOldDictionary() (rmgpy.data.kinetics.KineticsGroupsmethod), 30

loadOldDictionary() (rmgpy.data.kinetics.KineticsLibrarymethod), 32

loadOldDictionary() (rmgpy.data.kinetics.KineticsRulesmethod), 35

loadOldDictionary() (rmgpy.data.statmech.StatmechDepositorymethod), 42

loadOldDictionary() (rmgpy.data.statmech.StatmechGroupsmethod), 49

loadOldDictionary() (rmgpy.data.statmech.StatmechLibrarymethod), 51

loadOldDictionary() (rmgpy.data.thermo.ThermoDepositorymethod), 58

loadOldDictionary() (rmgpy.data.thermo.ThermoGroupsmethod), 60

loadOldDictionary() (rmgpy.data.thermo.ThermoLibrarymethod), 63

loadOldLibrary() (rmgpy.data.base.Database method), 16loadOldLibrary() (rmgpy.data.kinetics.KineticsDepository

Index 213


method), 23loadOldLibrary() (rmgpy.data.kinetics.KineticsFamily

method), 28loadOldLibrary() (rmgpy.data.kinetics.KineticsGroups

method), 31loadOldLibrary() (rmgpy.data.kinetics.KineticsLibrary

method), 33loadOldLibrary() (rmgpy.data.kinetics.KineticsRules

method), 35loadOldLibrary() (rmgpy.data.statmech.StatmechDepository

method), 42loadOldLibrary() (rmgpy.data.statmech.StatmechGroups

method), 49loadOldLibrary() (rmgpy.data.statmech.StatmechLibrary

method), 51loadOldLibrary() (rmgpy.data.thermo.ThermoDepository

method), 58loadOldLibrary() (rmgpy.data.thermo.ThermoGroups

method), 61loadOldLibrary() (rmgpy.data.thermo.ThermoLibrary

method), 63loadOldTemplate() (rmgpy.data.kinetics.KineticsFamily

method), 28loadOldTree() (rmgpy.data.base.Database method), 16loadOldTree() (rmgpy.data.kinetics.KineticsDepository

method), 23loadOldTree() (rmgpy.data.kinetics.KineticsFamily

method), 28loadOldTree() (rmgpy.data.kinetics.KineticsGroups

method), 31loadOldTree() (rmgpy.data.kinetics.KineticsLibrary

method), 33loadOldTree() (rmgpy.data.kinetics.KineticsRules

method), 35loadOldTree() (rmgpy.data.statmech.StatmechDepository

method), 43loadOldTree() (rmgpy.data.statmech.StatmechGroups

method), 49loadOldTree() (rmgpy.data.statmech.StatmechLibrary

method), 51loadOldTree() (rmgpy.data.thermo.ThermoDepository

method), 58loadOldTree() (rmgpy.data.thermo.ThermoGroups

method), 61loadOldTree() (rmgpy.data.thermo.ThermoLibrary

method), 63loadRecipe() (rmgpy.data.kinetics.KineticsFamily

method), 28loadRecommendedFamiliesList()


loadRestartFile() (rmgpy.rmg.main.RMG method), 149loadRMGJavaInput() (rmgpy.rmg.main.RMG method),

149

loadScanEnergies() (rmgpy.cantherm.gaussian.GaussianLogmethod), 5

loadSpeciesDictionary() (in module rmgpy.chemkin), 11loadTemplate() (rmgpy.data.kinetics.KineticsFamily

method), 28loadThermoData() (rmgpy.qm.gaussian.GaussianMol

method), 125loadThermoData() (rmgpy.qm.gaussian.GaussianMolPM3

method), 127loadThermoData() (rmgpy.qm.gaussian.GaussianMolPM6

method), 128loadThermoData() (rmgpy.qm.molecule.QMMolecule

method), 122loadThermoData() (rmgpy.qm.mopac.MopacMol

method), 130loadThermoData() (rmgpy.qm.mopac.MopacMolPM3



method), 135loadThermoInput() (rmgpy.rmg.main.RMG method), 149loadTransportFile() (in module rmgpy.chemkin), 11loadZeroPointEnergy() (rmgpy.cantherm.gaussian.GaussianLog

method), 5logConversions() (rmgpy.solver.ReactionSystem

method), 158logConversions() (rmgpy.solver.SimpleReactor method),

159logFooter() (rmgpy.cantherm.CanTherm method), 6logHeader() (rmgpy.cantherm.CanTherm method), 6logHeader() (rmgpy.rmg.main.RMG method), 149LogicAnd (class in rmgpy.data.base), 39LogicNode (class in rmgpy.data.base), 39LogicOr (class in rmgpy.data.base), 39logRates() (rmgpy.solver.ReactionSystem method), 158logRates() (rmgpy.solver.SimpleReactor method), 159

MmakeLogicNode() (in module rmgpy.data.base), 40makeNewPDepReaction()


makeNewReaction() (rmgpy.rmg.model.CoreEdgeReactionModelmethod), 146

makeNewSpecies() (rmgpy.rmg.model.CoreEdgeReactionModelmethod), 146

makeProfileGraph() (in module rmgpy.rmg.main), 149mapDensitiesOfStates() (rmgpy.pdep.Network method),

114mapDensitiesOfStates() (rmgpy.rmg.pdep.PDepNetwork

method), 151mapDensityOfStates() (rmgpy.pdep.Configuration

method), 112

214 Index


mapSumOfStates() (rmgpy.pdep.Configuration method),112

markChemkinDuplicates()(rmgpy.rmg.model.CoreEdgeReactionModelmethod), 146

markDuplicateReactions() (in module rmgpy.chemkin),12

markValidDuplicates() (rmgpy.data.kinetics.KineticsLibrarymethod), 33

mass (rmgpy.statmech.Conformer attribute), 177mass (rmgpy.statmech.IdealGasTranslation attribute), 166matchesMolecules() (rmgpy.data.kinetics.DepositoryReaction

method), 19matchesMolecules() (rmgpy.data.kinetics.LibraryReaction

method), 39matchesMolecules() (rmgpy.data.kinetics.TemplateReaction

method), 55matchesMolecules() (rmgpy.reaction.Reaction method),

143matchesMolecules() (rmgpy.rmg.pdep.PDepReaction

method), 155matchLogicOr() (rmgpy.data.base.LogicOr method), 40matchNodeToChild() (rmgpy.data.base.Database

method), 16matchNodeToChild() (rmgpy.data.kinetics.KineticsDepository

method), 23matchNodeToChild() (rmgpy.data.kinetics.KineticsFamily

method), 28matchNodeToChild() (rmgpy.data.kinetics.KineticsGroups

method), 31matchNodeToChild() (rmgpy.data.kinetics.KineticsLibrary

method), 33matchNodeToChild() (rmgpy.data.kinetics.KineticsRules

method), 35matchNodeToChild() (rmgpy.data.statmech.StatmechDepository

method), 43matchNodeToChild() (rmgpy.data.statmech.StatmechGroups

method), 49matchNodeToChild() (rmgpy.data.statmech.StatmechLibrary

method), 51matchNodeToChild() (rmgpy.data.thermo.ThermoDepository

method), 58matchNodeToChild() (rmgpy.data.thermo.ThermoGroups

method), 61matchNodeToChild() (rmgpy.data.thermo.ThermoLibrary

method), 63matchNodeToNode() (rmgpy.data.base.Database

method), 16matchNodeToNode() (rmgpy.data.kinetics.KineticsDepository

method), 23matchNodeToNode() (rmgpy.data.kinetics.KineticsFamily

method), 28matchNodeToNode() (rmgpy.data.kinetics.KineticsGroups

method), 31

matchNodeToNode() (rmgpy.data.kinetics.KineticsLibrarymethod), 33

matchNodeToNode() (rmgpy.data.kinetics.KineticsRulesmethod), 35

matchNodeToNode() (rmgpy.data.statmech.StatmechDepositorymethod), 43

matchNodeToNode() (rmgpy.data.statmech.StatmechGroupsmethod), 49

matchNodeToNode() (rmgpy.data.statmech.StatmechLibrarymethod), 51

matchNodeToNode() (rmgpy.data.thermo.ThermoDepositorymethod), 59

matchNodeToNode() (rmgpy.data.thermo.ThermoGroupsmethod), 61

matchNodeToNode() (rmgpy.data.thermo.ThermoLibrarymethod), 63

matchNodeToStructure() (rmgpy.data.base.Databasemethod), 16

matchNodeToStructure()(rmgpy.data.kinetics.KineticsDepositorymethod), 23

matchNodeToStructure()(rmgpy.data.kinetics.KineticsFamily method),28

matchNodeToStructure()(rmgpy.data.kinetics.KineticsGroups method),31

matchNodeToStructure()(rmgpy.data.kinetics.KineticsLibrary method),33

matchNodeToStructure()(rmgpy.data.kinetics.KineticsRules method),35

matchNodeToStructure()(rmgpy.data.statmech.StatmechDepositorymethod), 43

matchNodeToStructure()(rmgpy.data.statmech.StatmechGroupsmethod), 49

matchNodeToStructure()(rmgpy.data.statmech.StatmechLibrarymethod), 51

matchNodeToStructure()(rmgpy.data.thermo.ThermoDepositorymethod), 59

matchNodeToStructure()(rmgpy.data.thermo.ThermoGroups method),61

matchNodeToStructure()(rmgpy.data.thermo.ThermoLibrary method),63

matchToStructure() (rmgpy.data.base.LogicAnd method),39

matchToStructure() (rmgpy.data.base.LogicOr method),

Index 215


40maxAttempts (rmgpy.qm.gaussian.GaussianMol at-

tribute), 125maxAttempts (rmgpy.qm.gaussian.GaussianMolPM3 at-

tribute), 127maxAttempts (rmgpy.qm.gaussian.GaussianMolPM6 at-

tribute), 128maxAttempts (rmgpy.qm.molecule.QMMolecule at-

tribute), 122maxAttempts (rmgpy.qm.mopac.MopacMol attribute),

131maxAttempts (rmgpy.qm.mopac.MopacMolPM3 at-

tribute), 132maxAttempts (rmgpy.qm.mopac.MopacMolPM6 at-

tribute), 134maxAttempts (rmgpy.qm.mopac.MopacMolPM7 at-

tribute), 135maximumGrainSize (rmgpy.cantherm.PressureDependenceJob

attribute), 9merge() (rmgpy.molecule.graph.Graph method), 87merge() (rmgpy.molecule.Group method), 103merge() (rmgpy.molecule.Molecule method), 97merge() (rmgpy.rmg.model.ReactionModel method), 147merge() (rmgpy.rmg.pdep.PDepNetwork method), 151modes (rmgpy.statmech.Conformer attribute), 178Molecule (class in rmgpy.molecule), 93MoleculeDrawer (class in rmgpy.molecule.draw), 107Mopac (class in rmgpy.qm.mopac), 129MopacMol (class in rmgpy.qm.mopac), 129MopacMolPM3 (class in rmgpy.qm.mopac), 131MopacMolPM6 (class in rmgpy.qm.mopac), 133MopacMolPM7 (class in rmgpy.qm.mopac), 134MultiArrhenius (class in rmgpy.kinetics), 67MultiPDepArrhenius (class in rmgpy.kinetics), 72

Nn (rmgpy.kinetics.Arrhenius attribute), 67n (rmgpy.pdep.SingleExponentialDown attribute), 110NASA (class in rmgpy.thermo), 183NASAPolynomial (class in rmgpy.thermo), 185Network (class in rmgpy.pdep), 112NonlinearRotor (class in rmgpy.statmech), 168number (rmgpy.statmech.Conformer attribute), 178numberOfAtoms (rmgpy.qm.qmdata.QMData attribute),

122

OopticalIsomers (rmgpy.statmech.Conformer attribute),

178outputFilePath (rmgpy.qm.gaussian.GaussianMol at-

tribute), 125outputFilePath (rmgpy.qm.gaussian.GaussianMolPM3 at-

tribute), 127

outputFilePath (rmgpy.qm.gaussian.GaussianMolPM6 at-tribute), 128

outputFilePath (rmgpy.qm.molecule.QMMoleculeattribute), 122

outputFilePath (rmgpy.qm.mopac.MopacMol attribute),131

outputFilePath (rmgpy.qm.mopac.MopacMolPM3attribute), 132



Pparse() (rmgpy.qm.gaussian.Gaussian method), 124parse() (rmgpy.qm.gaussian.GaussianMol method), 125parse() (rmgpy.qm.gaussian.GaussianMolPM3 method),

127parse() (rmgpy.qm.gaussian.GaussianMolPM6 method),

128parse() (rmgpy.qm.molecule.QMMolecule method), 122parse() (rmgpy.qm.mopac.MopacMol method), 131parse() (rmgpy.qm.mopac.MopacMolPM3 method), 132parse() (rmgpy.qm.mopac.MopacMolPM6 method), 134parse() (rmgpy.qm.mopac.MopacMolPM7 method), 135parse() (rmgpy.qm.symmetry.SymmetryJob method), 123parseCommandLineArguments()

(rmgpy.cantherm.CanTherm method), 7parseOldLibrary() (rmgpy.data.base.Database method),

16parseOldLibrary() (rmgpy.data.kinetics.KineticsDepository

method), 24parseOldLibrary() (rmgpy.data.kinetics.KineticsFamily

method), 28parseOldLibrary() (rmgpy.data.kinetics.KineticsGroups

method), 31parseOldLibrary() (rmgpy.data.kinetics.KineticsLibrary

method), 33parseOldLibrary() (rmgpy.data.kinetics.KineticsRules

method), 36parseOldLibrary() (rmgpy.data.statmech.StatmechDepository

method), 43parseOldLibrary() (rmgpy.data.statmech.StatmechGroups

method), 49parseOldLibrary() (rmgpy.data.statmech.StatmechLibrary

method), 52parseOldLibrary() (rmgpy.data.thermo.ThermoDepository

method), 59parseOldLibrary() (rmgpy.data.thermo.ThermoGroups

method), 61parseOldLibrary() (rmgpy.data.thermo.ThermoLibrary

method), 63Pdata (rmgpy.kinetics.PDepKineticsData attribute), 69PDepArrhenius (class in rmgpy.kinetics), 70

216 Index


PDepKineticsData (class in rmgpy.kinetics), 69PDepNetwork (class in rmgpy.rmg.pdep), 150PDepReaction (class in rmgpy.rmg.pdep), 152Plist (rmgpy.cantherm.PressureDependenceJob attribute),

8plot() (rmgpy.cantherm.KineticsJob method), 6plot() (rmgpy.cantherm.ThermoJob method), 10plotHinderedRotor() (rmgpy.cantherm.StatMechJob

method), 9Pmax (rmgpy.cantherm.PressureDependenceJob at-

tribute), 8Pmax (rmgpy.kinetics.Arrhenius attribute), 66Pmax (rmgpy.kinetics.Chebyshev attribute), 74Pmax (rmgpy.kinetics.KineticsData attribute), 65Pmax (rmgpy.kinetics.Lindemann attribute), 78Pmax (rmgpy.kinetics.MultiArrhenius attribute), 67Pmax (rmgpy.kinetics.MultiPDepArrhenius attribute), 72Pmax (rmgpy.kinetics.PDepArrhenius attribute), 70Pmax (rmgpy.kinetics.PDepKineticsData attribute), 69Pmax (rmgpy.kinetics.ThirdBody attribute), 76Pmax (rmgpy.kinetics.Troe attribute), 80Pmin (rmgpy.cantherm.PressureDependenceJob at-

tribute), 8Pmin (rmgpy.kinetics.Arrhenius attribute), 66Pmin (rmgpy.kinetics.Chebyshev attribute), 74Pmin (rmgpy.kinetics.KineticsData attribute), 65Pmin (rmgpy.kinetics.Lindemann attribute), 78Pmin (rmgpy.kinetics.MultiArrhenius attribute), 68Pmin (rmgpy.kinetics.MultiPDepArrhenius attribute), 72Pmin (rmgpy.kinetics.PDepArrhenius attribute), 71Pmin (rmgpy.kinetics.PDepKineticsData attribute), 69Pmin (rmgpy.kinetics.ThirdBody attribute), 76Pmin (rmgpy.kinetics.Troe attribute), 80PointGroup (class in rmgpy.qm.symmetry), 123PointGroupCalculator (class in rmgpy.qm.symmetry),

123poly1 (rmgpy.thermo.NASA attribute), 184poly2 (rmgpy.thermo.NASA attribute), 184poly3 (rmgpy.thermo.NASA attribute), 184polynomials (rmgpy.thermo.NASA attribute), 184PressureDependenceJob (class in rmgpy.cantherm), 7pressures (rmgpy.kinetics.PDepArrhenius attribute), 72prettify() (in module rmgpy.cantherm.output), 7PrettifyVisitor (class in rmgpy.cantherm.output), 7printEnlargeSummary() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 146printSummary() (rmgpy.pdep.Network method), 114printSummary() (rmgpy.rmg.pdep.PDepNetwork

method), 151prioritizeThermo() (rmgpy.data.thermo.ThermoDatabase

method), 57processNewReactions() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 146processOldLibraryEntry()

(rmgpy.data.kinetics.KineticsRules method),36

processOldLibraryEntry()(rmgpy.data.statmech.StatmechGroupsmethod), 50

processOldLibraryEntry()(rmgpy.data.statmech.StatmechLibrarymethod), 52

processOldLibraryEntry()(rmgpy.data.thermo.ThermoGroups method),61

processOldLibraryEntry()(rmgpy.data.thermo.ThermoLibrary method),63

processProfileStats() (in module rmgpy.rmg.main), 150prune() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 146pruneHeteroatoms() (rmgpy.data.thermo.ThermoDatabase

method), 57PseudoFit (class in rmgpy.data.statmechfit), 47PseudoRotorFit (class in rmgpy.data.statmechfit), 46

QQMCalculator (class in rmgpy.qm.main), 119QMData (class in rmgpy.qm.qmdata), 122QMMolecule (class in rmgpy.qm.molecule), 121QMSettings (class in rmgpy.qm.main), 119QMVerifier (class in rmgpy.qm.qmverifier), 122Quantity() (in module rmgpy.quantity), 140quantum (rmgpy.statmech.HarmonicOscillator attribute),

172quantum (rmgpy.statmech.HinderedRotor attribute), 174quantum (rmgpy.statmech.IdealGasTranslation attribute),

166quantum (rmgpy.statmech.KRotor attribute), 170quantum (rmgpy.statmech.LinearRotor attribute), 167quantum (rmgpy.statmech.NonlinearRotor attribute), 168quantum (rmgpy.statmech.SphericalTopRotor attribute),

171

Rrd_build() (rmgpy.qm.molecule.Geometry method), 120rd_embed() (rmgpy.qm.molecule.Geometry method), 120Reaction (class in rmgpy.reaction), 140ReactionDrawer (class in rmgpy.molecule.draw), 107ReactionModel (class in rmgpy.rmg.model), 147ReactionRecipe (class in rmgpy.data.kinetics), 40ReactionSystem (class in rmgpy.solver), 157readInputFile() (in module rmgpy.rmg.input), 147readKineticsEntry() (in module rmgpy.chemkin), 11readMeaningfulLineJava() (rmgpy.rmg.main.RMG

method), 149readReactionComments() (in module rmgpy.chemkin), 11readReactionsBlock() (in module rmgpy.chemkin), 11

Index 217


readThermoEntry() (in module rmgpy.chemkin), 11reconstructKineticsFromSource()


register_listeners() (rmgpy.rmg.main.RMG method), 149registerReaction() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 147removeAtom() (rmgpy.molecule.Group method), 103removeAtom() (rmgpy.molecule.Molecule method), 97removeBond() (rmgpy.molecule.Group method), 103removeBond() (rmgpy.molecule.Molecule method), 97removeCommentFromLine() (in module

rmgpy.chemkin), 11removeEdge() (rmgpy.molecule.graph.Graph method), 87removeEdge() (rmgpy.molecule.Group method), 103removeEdge() (rmgpy.molecule.Molecule method), 97removeGroup() (rmgpy.data.base.Database method), 16removeGroup() (rmgpy.data.kinetics.KineticsDepository

method), 24removeGroup() (rmgpy.data.kinetics.KineticsFamily

method), 28removeGroup() (rmgpy.data.kinetics.KineticsGroups

method), 31removeGroup() (rmgpy.data.kinetics.KineticsLibrary

method), 33removeGroup() (rmgpy.data.kinetics.KineticsRules

method), 36removeGroup() (rmgpy.data.statmech.StatmechDepository

method), 43removeGroup() (rmgpy.data.statmech.StatmechGroups

method), 50removeGroup() (rmgpy.data.statmech.StatmechLibrary

method), 52removeGroup() (rmgpy.data.thermo.ThermoDepository

method), 59removeGroup() (rmgpy.data.thermo.ThermoGroups

method), 61removeGroup() (rmgpy.data.thermo.ThermoLibrary

method), 63removeSpeciesFromEdge()


removeVertex() (rmgpy.molecule.graph.Graph method),88

removeVertex() (rmgpy.molecule.Group method), 103removeVertex() (rmgpy.molecule.Molecule method), 97render() (rmgpy.molecule.draw.MoleculeDrawer

method), 107resetConnectivityValues() (rmgpy.molecule.Atom

method), 92resetConnectivityValues() (rmgpy.molecule.graph.Graph

method), 88resetConnectivityValues() (rmgpy.molecule.graph.Vertex

method), 85

resetConnectivityValues() (rmgpy.molecule.Groupmethod), 103

resetConnectivityValues() (rmgpy.molecule.GroupAtommethod), 99

resetConnectivityValues() (rmgpy.molecule.Moleculemethod), 97

residual() (rmgpy.solver.ReactionSystem method), 158residual() (rmgpy.solver.SimpleReactor method), 159retrieve() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 147retrieveNewSpecies() (rmgpy.rmg.model.CoreEdgeReactionModel

method), 147retrieveOriginalEntry() (rmgpy.data.kinetics.KineticsFamily

method), 29retrieveTemplate() (rmgpy.data.kinetics.KineticsFamily

method), 29reverseThisArrheniusRate()


reverseThisArrheniusRate()(rmgpy.data.kinetics.LibraryReaction method),39

reverseThisArrheniusRate()(rmgpy.data.kinetics.TemplateReactionmethod), 55

reverseThisArrheniusRate() (rmgpy.reaction.Reactionmethod), 143

reverseThisArrheniusRate()(rmgpy.rmg.pdep.PDepReaction method),155

RMG (class in rmgpy.rmg.main), 148rmgpy.cantherm (module), 3rmgpy.chemkin (module), 10rmgpy.constants (module), 13rmgpy.data (module), 13rmgpy.kinetics (module), 64rmgpy.molecule (module), 84rmgpy.molecule.adjlist (module), 104rmgpy.pdep (module), 108rmgpy.qm (module), 118rmgpy.quantity (module), 136rmgpy.reaction (module), 140rmgpy.rmg (module), 143rmgpy.solver (module), 157rmgpy.species (module), 160rmgpy.statmech (module), 163rmgpy.statmech.schrodinger (module), 175rmgpy.thermo (module), 178rotationalConstant (rmgpy.statmech.HinderedRotor at-

tribute), 174rotationalConstant (rmgpy.statmech.KRotor attribute),

170rotationalConstant (rmgpy.statmech.LinearRotor at-

tribute), 167

218 Index


rotationalConstant (rmgpy.statmech.NonlinearRotor at-tribute), 168

rotationalConstant (rmgpy.statmech.SphericalTopRotorattribute), 171

run() (rmgpy.qm.symmetry.SymmetryJob method), 123

SS0 (rmgpy.thermo.Wilhoit attribute), 181S298 (rmgpy.thermo.ThermoData attribute), 179saturate() (rmgpy.molecule.Molecule method), 97save() (rmgpy.cantherm.KineticsJob method), 6save() (rmgpy.cantherm.StatMechJob method), 9save() (rmgpy.cantherm.ThermoJob method), 10save() (rmgpy.data.base.Database method), 17save() (rmgpy.data.kinetics.KineticsDatabase method), 22save() (rmgpy.data.kinetics.KineticsDepository method),

24save() (rmgpy.data.kinetics.KineticsFamily method), 29save() (rmgpy.data.kinetics.KineticsGroups method), 31save() (rmgpy.data.kinetics.KineticsLibrary method), 33save() (rmgpy.data.kinetics.KineticsRules method), 36save() (rmgpy.data.statmech.StatmechDatabase method),

41save() (rmgpy.data.statmech.StatmechDepository

method), 43save() (rmgpy.data.statmech.StatmechGroups method),

50save() (rmgpy.data.statmech.StatmechLibrary method),

52save() (rmgpy.data.thermo.ThermoDatabase method), 57save() (rmgpy.data.thermo.ThermoDepository method),

59save() (rmgpy.data.thermo.ThermoGroups method), 61save() (rmgpy.data.thermo.ThermoLibrary method), 63saveChemkinFile() (in module rmgpy.chemkin), 11saveCoordinatesFromQMData()

(rmgpy.qm.molecule.Geometry method),120

saveDepository() (rmgpy.data.kinetics.KineticsFamilymethod), 29

saveDepository() (rmgpy.data.statmech.StatmechDatabasemethod), 41

saveDepository() (rmgpy.data.thermo.ThermoDatabasemethod), 57

saveDictionary() (rmgpy.data.base.Database method), 17saveDictionary() (rmgpy.data.kinetics.KineticsDepository

method), 24saveDictionary() (rmgpy.data.kinetics.KineticsFamily

method), 29saveDictionary() (rmgpy.data.kinetics.KineticsGroups

method), 31saveDictionary() (rmgpy.data.kinetics.KineticsLibrary

method), 33

saveDictionary() (rmgpy.data.kinetics.KineticsRulesmethod), 36

saveDictionary() (rmgpy.data.statmech.StatmechDepositorymethod), 43

saveDictionary() (rmgpy.data.statmech.StatmechGroupsmethod), 50

saveDictionary() (rmgpy.data.statmech.StatmechLibrarymethod), 52

saveDictionary() (rmgpy.data.thermo.ThermoDepositorymethod), 59

saveDictionary() (rmgpy.data.thermo.ThermoGroupsmethod), 61

saveDictionary() (rmgpy.data.thermo.ThermoLibrarymethod), 64

saveDiffHTML() (in module rmgpy.rmg.output), 150saveEntry() (rmgpy.data.kinetics.KineticsDepository

method), 24saveEntry() (rmgpy.data.kinetics.KineticsFamily

method), 29saveEntry() (rmgpy.data.kinetics.KineticsLibrary

method), 34saveEntry() (rmgpy.data.kinetics.KineticsRules method),

36saveEntry() (rmgpy.data.statmech.StatmechDepository

method), 43saveEntry() (rmgpy.data.statmech.StatmechGroups

method), 50saveEntry() (rmgpy.data.statmech.StatmechLibrary

method), 52saveEntry() (rmgpy.data.thermo.ThermoDepository

method), 59saveEntry() (rmgpy.data.thermo.ThermoGroups method),

61saveEntry() (rmgpy.data.thermo.ThermoLibrary method),

64saveEverything() (rmgpy.rmg.main.RMG method), 149saveFamilies() (rmgpy.data.kinetics.KineticsDatabase

method), 22saveGroups() (rmgpy.data.kinetics.KineticsFamily

method), 29saveGroups() (rmgpy.data.statmech.StatmechDatabase

method), 41saveGroups() (rmgpy.data.thermo.ThermoDatabase

method), 57saveHTMLFile() (in module rmgpy.chemkin), 12saveInput() (rmgpy.rmg.main.RMG method), 149saveInputFile() (in module rmgpy.rmg.input), 147saveInputFile() (rmgpy.cantherm.PressureDependenceJob

method), 9saveJavaKineticsLibrary() (in module rmgpy.chemkin),

12saveLibraries() (rmgpy.data.kinetics.KineticsDatabase

method), 22saveLibraries() (rmgpy.data.statmech.StatmechDatabase

Index 219


method), 41saveLibraries() (rmgpy.data.thermo.ThermoDatabase

method), 57saveOld() (rmgpy.data.base.Database method), 17saveOld() (rmgpy.data.kinetics.KineticsDatabase

method), 22saveOld() (rmgpy.data.kinetics.KineticsDepository

method), 24saveOld() (rmgpy.data.kinetics.KineticsFamily method),

29saveOld() (rmgpy.data.kinetics.KineticsGroups method),

31saveOld() (rmgpy.data.kinetics.KineticsLibrary method),

34saveOld() (rmgpy.data.kinetics.KineticsRules method),

36saveOld() (rmgpy.data.statmech.StatmechDatabase

method), 42saveOld() (rmgpy.data.statmech.StatmechDepository

method), 43saveOld() (rmgpy.data.statmech.StatmechGroups

method), 50saveOld() (rmgpy.data.statmech.StatmechLibrary

method), 52saveOld() (rmgpy.data.thermo.ThermoDatabase method),

57saveOld() (rmgpy.data.thermo.ThermoDepository

method), 59saveOld() (rmgpy.data.thermo.ThermoGroups method),

62saveOld() (rmgpy.data.thermo.ThermoLibrary method),

64saveOldDictionary() (rmgpy.data.base.Database method),

17saveOldDictionary() (rmgpy.data.kinetics.KineticsDepository

method), 24saveOldDictionary() (rmgpy.data.kinetics.KineticsFamily

method), 29saveOldDictionary() (rmgpy.data.kinetics.KineticsGroups

method), 32saveOldDictionary() (rmgpy.data.kinetics.KineticsLibrary

method), 34saveOldDictionary() (rmgpy.data.kinetics.KineticsRules

method), 36saveOldDictionary() (rmgpy.data.statmech.StatmechDepository

method), 43saveOldDictionary() (rmgpy.data.statmech.StatmechGroups

method), 50saveOldDictionary() (rmgpy.data.statmech.StatmechLibrary

method), 52saveOldDictionary() (rmgpy.data.thermo.ThermoDepository

method), 59saveOldDictionary() (rmgpy.data.thermo.ThermoGroups

method), 62

saveOldDictionary() (rmgpy.data.thermo.ThermoLibrarymethod), 64

saveOldLibrary() (rmgpy.data.base.Database method), 17saveOldLibrary() (rmgpy.data.kinetics.KineticsDepository

method), 24saveOldLibrary() (rmgpy.data.kinetics.KineticsFamily

method), 29saveOldLibrary() (rmgpy.data.kinetics.KineticsGroups

method), 32saveOldLibrary() (rmgpy.data.kinetics.KineticsLibrary

method), 34saveOldLibrary() (rmgpy.data.kinetics.KineticsRules

method), 36saveOldLibrary() (rmgpy.data.statmech.StatmechDepository

method), 43saveOldLibrary() (rmgpy.data.statmech.StatmechGroups

method), 50saveOldLibrary() (rmgpy.data.statmech.StatmechLibrary

method), 52saveOldLibrary() (rmgpy.data.thermo.ThermoDepository

method), 59saveOldLibrary() (rmgpy.data.thermo.ThermoGroups

method), 62saveOldLibrary() (rmgpy.data.thermo.ThermoLibrary

method), 64saveOldTemplate() (rmgpy.data.kinetics.KineticsFamily

method), 29saveOldTree() (rmgpy.data.base.Database method), 17saveOldTree() (rmgpy.data.kinetics.KineticsDepository

method), 24saveOldTree() (rmgpy.data.kinetics.KineticsFamily

method), 29saveOldTree() (rmgpy.data.kinetics.KineticsGroups

method), 32saveOldTree() (rmgpy.data.kinetics.KineticsLibrary

method), 34saveOldTree() (rmgpy.data.kinetics.KineticsRules

method), 36saveOldTree() (rmgpy.data.statmech.StatmechDepository

method), 44saveOldTree() (rmgpy.data.statmech.StatmechGroups

method), 50saveOldTree() (rmgpy.data.statmech.StatmechLibrary

method), 52saveOldTree() (rmgpy.data.thermo.ThermoDepository

method), 59saveOldTree() (rmgpy.data.thermo.ThermoGroups

method), 62saveOldTree() (rmgpy.data.thermo.ThermoLibrary

method), 64saveOutputHTML() (in module rmgpy.rmg.output), 150saveRecommendedFamilies()


220 Index


saveSpeciesDictionary() (in module rmgpy.chemkin), 11saveThermoData() (rmgpy.qm.gaussian.GaussianMol

method), 125saveThermoData() (rmgpy.qm.gaussian.GaussianMolPM3

method), 127saveThermoData() (rmgpy.qm.gaussian.GaussianMolPM6

method), 129saveThermoData() (rmgpy.qm.molecule.QMMolecule

method), 122saveThermoData() (rmgpy.qm.mopac.MopacMol

method), 131saveThermoData() (rmgpy.qm.mopac.MopacMolPM3



method), 136saveTrainingReactions() (rmgpy.data.kinetics.KineticsFamily

method), 29saveTransportFile() (in module rmgpy.chemkin), 12ScalarQuantity (class in rmgpy.quantity), 137scriptAttempts (rmgpy.qm.gaussian.GaussianMol at-

tribute), 125scriptAttempts (rmgpy.qm.gaussian.GaussianMolPM3 at-

tribute), 127scriptAttempts (rmgpy.qm.gaussian.GaussianMolPM6 at-

tribute), 129scriptAttempts (rmgpy.qm.molecule.QMMolecule

attribute), 122scriptAttempts (rmgpy.qm.mopac.MopacMol attribute),

131scriptAttempts (rmgpy.qm.mopac.MopacMolPM3

attribute), 132scriptAttempts (rmgpy.qm.mopac.MopacMolPM6

attribute), 134scriptAttempts (rmgpy.qm.mopac.MopacMolPM7

attribute), 136searchRetrieveReactions()


selectEnergyGrains() (rmgpy.pdep.Network method), 114selectEnergyGrains() (rmgpy.rmg.pdep.PDepNetwork

method), 151selectPolynomial() (rmgpy.thermo.NASA method), 184semiclassical (rmgpy.statmech.HinderedRotor attribute),

174set_colliders() (rmgpy.solver.SimpleReactor method),

159set_initial_conditions() (rmgpy.solver.ReactionSystem

method), 158set_initial_conditions() (rmgpy.solver.SimpleReactor

method), 159set_initial_derivative() (rmgpy.solver.ReactionSystem

method), 158

set_initial_derivative() (rmgpy.solver.SimpleReactormethod), 160

setCanteraKinetics() (rmgpy.kinetics.Arrhenius method),67

setCanteraKinetics() (rmgpy.kinetics.Chebyshevmethod), 75

setCanteraKinetics() (rmgpy.kinetics.KineticsDatamethod), 66

setCanteraKinetics() (rmgpy.kinetics.Lindemannmethod), 79

setCanteraKinetics() (rmgpy.kinetics.MultiArrheniusmethod), 68

setCanteraKinetics() (rmgpy.kinetics.MultiPDepArrheniusmethod), 73

setCanteraKinetics() (rmgpy.kinetics.PDepArrheniusmethod), 72

setCanteraKinetics() (rmgpy.kinetics.PDepKineticsDatamethod), 70

setCanteraKinetics() (rmgpy.kinetics.ThirdBodymethod), 77

setCanteraKinetics() (rmgpy.kinetics.Troe method), 81setConditions() (rmgpy.pdep.Network method), 114setConditions() (rmgpy.rmg.pdep.PDepNetwork

method), 152setDefaultOutputDirectory()

(rmgpy.qm.main.QMCalculator method),120

setLonePairs() (rmgpy.molecule.Atom method), 92setSpinMultiplicity() (rmgpy.molecule.Atom method), 92setUncertaintyType() (rmgpy.quantity.ArrayQuantity

method), 139setUncertaintyType() (rmgpy.quantity.ScalarQuantity

method), 138SimpleReactor (class in rmgpy.solver), 158simulate() (rmgpy.solver.ReactionSystem method), 158simulate() (rmgpy.solver.SimpleReactor method), 160SingleExponentialDown (class in rmgpy.pdep), 109solve() (rmgpy.data.statmechfit.DirectFit method), 45solve() (rmgpy.data.statmechfit.PseudoFit method), 47solve() (rmgpy.data.statmechfit.PseudoRotorFit method),

46solveFullME() (rmgpy.pdep.Network method), 114solveFullME() (rmgpy.rmg.pdep.PDepNetwork method),

152solveReducedME() (rmgpy.pdep.Network method), 114solveReducedME() (rmgpy.rmg.pdep.PDepNetwork

method), 152solveSchrodingerEquation()

(rmgpy.statmech.HinderedRotor method),175

sortAtoms() (rmgpy.molecule.Group method), 103sortAtoms() (rmgpy.molecule.Molecule method), 97sortVertices() (rmgpy.molecule.graph.Graph method), 88sortVertices() (rmgpy.molecule.Group method), 103

Index 221


sortVertices() (rmgpy.molecule.Molecule method), 97Species (class in rmgpy.rmg.model), 155Species (class in rmgpy.species), 161SphericalTopRotor (class in rmgpy.statmech), 170spinMultiplicity (rmgpy.statmech.Conformer attribute),

178split() (rmgpy.molecule.graph.Graph method), 88split() (rmgpy.molecule.Group method), 103split() (rmgpy.molecule.Molecule method), 98standardizeAtomType() (rmgpy.molecule.Group

method), 103standardizeGroup() (rmgpy.molecule.Group method),

103StatmechDatabase (class in rmgpy.data.statmech), 41StatmechDepository (class in rmgpy.data.statmech), 42StatmechGroups (class in rmgpy.data.statmech), 48StatMechJob (class in rmgpy.cantherm), 9StatmechLibrary (class in rmgpy.data.statmech), 50step() (rmgpy.solver.ReactionSystem method), 158step() (rmgpy.solver.SimpleReactor method), 160succesfulJobExists() (rmgpy.qm.qmverifier.QMVerifier

method), 123successKeys (rmgpy.qm.gaussian.Gaussian attribute),

124successKeys (rmgpy.qm.mopac.Mopac attribute), 129symmetry (rmgpy.statmech.HinderedRotor attribute), 175symmetry (rmgpy.statmech.KRotor attribute), 170symmetry (rmgpy.statmech.LinearRotor attribute), 167symmetry (rmgpy.statmech.NonlinearRotor attribute),

168symmetry (rmgpy.statmech.SphericalTopRotor attribute),

171SymmetryJob (class in rmgpy.qm.symmetry), 123

TT0 (rmgpy.kinetics.Arrhenius attribute), 66T0 (rmgpy.pdep.SingleExponentialDown attribute), 109T1 (rmgpy.kinetics.Troe attribute), 80T2 (rmgpy.kinetics.Troe attribute), 80T3 (rmgpy.kinetics.Troe attribute), 80Tdata (rmgpy.kinetics.KineticsData attribute), 65Tdata (rmgpy.kinetics.PDepKineticsData attribute), 69Tdata (rmgpy.thermo.ThermoData attribute), 179TemplateReaction (class in rmgpy.data.kinetics), 52TerminationConversion (class in rmgpy.solver), 160TerminationTime (class in rmgpy.solver), 160ThermoData (class in rmgpy.thermo), 178ThermoDatabase (class in rmgpy.data.thermo), 55ThermoDepository (class in rmgpy.data.thermo), 58ThermoGroups (class in rmgpy.data.thermo), 60ThermoJob (class in rmgpy.cantherm), 9ThermoLibrary (class in rmgpy.data.thermo), 62ThirdBody (class in rmgpy.kinetics), 76Tlist (rmgpy.cantherm.KineticsJob attribute), 6

Tlist (rmgpy.cantherm.PressureDependenceJob attribute),8

Tmax (rmgpy.cantherm.KineticsJob attribute), 6Tmax (rmgpy.cantherm.PressureDependenceJob at-

tribute), 8Tmax (rmgpy.kinetics.Arrhenius attribute), 66Tmax (rmgpy.kinetics.Chebyshev attribute), 74Tmax (rmgpy.kinetics.KineticsData attribute), 65Tmax (rmgpy.kinetics.Lindemann attribute), 78Tmax (rmgpy.kinetics.MultiArrhenius attribute), 68Tmax (rmgpy.kinetics.MultiPDepArrhenius attribute), 72Tmax (rmgpy.kinetics.PDepArrhenius attribute), 71Tmax (rmgpy.kinetics.PDepKineticsData attribute), 69Tmax (rmgpy.kinetics.ThirdBody attribute), 76Tmax (rmgpy.kinetics.Troe attribute), 80Tmax (rmgpy.thermo.NASA attribute), 183Tmax (rmgpy.thermo.NASAPolynomial attribute), 186Tmax (rmgpy.thermo.ThermoData attribute), 179Tmax (rmgpy.thermo.Wilhoit attribute), 181Tmin (rmgpy.cantherm.KineticsJob attribute), 6Tmin (rmgpy.cantherm.PressureDependenceJob at-

tribute), 8Tmin (rmgpy.kinetics.Arrhenius attribute), 66Tmin (rmgpy.kinetics.Chebyshev attribute), 74Tmin (rmgpy.kinetics.KineticsData attribute), 65Tmin (rmgpy.kinetics.Lindemann attribute), 78Tmin (rmgpy.kinetics.MultiArrhenius attribute), 68Tmin (rmgpy.kinetics.MultiPDepArrhenius attribute), 72Tmin (rmgpy.kinetics.PDepArrhenius attribute), 71Tmin (rmgpy.kinetics.PDepKineticsData attribute), 69Tmin (rmgpy.kinetics.ThirdBody attribute), 76Tmin (rmgpy.kinetics.Troe attribute), 80Tmin (rmgpy.thermo.NASA attribute), 183Tmin (rmgpy.thermo.NASAPolynomial attribute), 186Tmin (rmgpy.thermo.ThermoData attribute), 179Tmin (rmgpy.thermo.Wilhoit attribute), 181toAdjacencyList() (in module rmgpy.molecule.adjlist),

106toAdjacencyList() (rmgpy.molecule.Group method), 104toAdjacencyList() (rmgpy.molecule.Molecule method),

98toAdjacencyList() (rmgpy.rmg.model.Species method),

156toAdjacencyList() (rmgpy.species.Species method), 162toArrhenius() (rmgpy.kinetics.MultiArrhenius method),

68toAugmentedInChI() (rmgpy.molecule.Molecule

method), 98toAugmentedInChIKey() (rmgpy.molecule.Molecule

method), 98toCantera() (rmgpy.data.kinetics.DepositoryReaction

method), 20toCantera() (rmgpy.data.kinetics.LibraryReaction

method), 39

222 Index


toCantera() (rmgpy.data.kinetics.TemplateReactionmethod), 55

toCantera() (rmgpy.reaction.Reaction method), 143toCantera() (rmgpy.rmg.model.Species method), 156toCantera() (rmgpy.rmg.pdep.PDepReaction method),

155toCantera() (rmgpy.species.Species method), 162toCantera() (rmgpy.thermo.NASA method), 184toCanteraKinetics() (rmgpy.kinetics.Arrhenius method),

67toChemkin() (rmgpy.data.kinetics.DepositoryReaction

method), 20toChemkin() (rmgpy.data.kinetics.LibraryReaction

method), 39toChemkin() (rmgpy.data.kinetics.TemplateReaction

method), 55toChemkin() (rmgpy.reaction.Reaction method), 143toChemkin() (rmgpy.rmg.model.Species method), 156toChemkin() (rmgpy.rmg.pdep.PDepReaction method),

155toChemkin() (rmgpy.species.Species method), 162toGroup() (rmgpy.molecule.Molecule method), 98toHTML() (rmgpy.kinetics.Arrhenius method), 67toHTML() (rmgpy.kinetics.Chebyshev method), 75toHTML() (rmgpy.kinetics.KineticsData method), 66toHTML() (rmgpy.kinetics.Lindemann method), 79toHTML() (rmgpy.kinetics.MultiArrhenius method), 68toHTML() (rmgpy.kinetics.MultiPDepArrhenius

method), 73toHTML() (rmgpy.kinetics.PDepArrhenius method), 72toHTML() (rmgpy.kinetics.PDepKineticsData method),

70toHTML() (rmgpy.kinetics.ThirdBody method), 77toHTML() (rmgpy.kinetics.Troe method), 81toInChI() (rmgpy.molecule.Molecule method), 98toInChIKey() (rmgpy.molecule.Molecule method), 98toNASA() (rmgpy.thermo.ThermoData method), 179toNASA() (rmgpy.thermo.Wilhoit method), 182toRDKitMol() (rmgpy.molecule.Molecule method), 98toSingleBonds() (rmgpy.molecule.Molecule method), 98toSMARTS() (rmgpy.molecule.Molecule method), 98toSMILES() (rmgpy.molecule.Molecule method), 98toThermoData() (rmgpy.thermo.NASA method), 184toThermoData() (rmgpy.thermo.Wilhoit method), 183toWilhoit() (rmgpy.thermo.NASA method), 184toWilhoit() (rmgpy.thermo.ThermoData method), 180TransitionState (class in rmgpy.species), 163Troe (class in rmgpy.kinetics), 79

Uuncertainty (rmgpy.quantity.ArrayQuantity attribute), 139uncertainty (rmgpy.quantity.ScalarQuantity attribute),

138

uncertaintyType (rmgpy.quantity.ArrayQuantity at-tribute), 139

uncertaintyType (rmgpy.quantity.ScalarQuantity at-tribute), 138

uniqueID (rmgpy.qm.molecule.Geometry attribute), 121uniqueID (rmgpy.qm.symmetry.SymmetryJob attribute),

123uniqueIDlong (rmgpy.qm.molecule.Geometry attribute),

121unitDegeneracy() (in module

rmgpy.statmech.schrodinger), 176update() (rmgpy.molecule.Molecule method), 98update() (rmgpy.rmg.pdep.PDepNetwork method), 152updateAtomTypes() (rmgpy.molecule.Molecule method),

99updateCharge() (rmgpy.molecule.Atom method), 92updateConfigurations() (rmgpy.rmg.pdep.PDepNetwork

method), 152updateConnectivityValues()

(rmgpy.molecule.graph.Graph method), 88updateConnectivityValues() (rmgpy.molecule.Group

method), 104updateConnectivityValues() (rmgpy.molecule.Molecule

method), 99updateFingerprint() (rmgpy.molecule.Group method),

104updateLonePairs() (rmgpy.molecule.Molecule method),

99updateMultiplicity() (rmgpy.molecule.Molecule method),

99updateUnimolecularReactionNetworks()


usePolar (rmgpy.qm.mopac.Mopac attribute), 129

Vvalue (rmgpy.quantity.ArrayQuantity attribute), 139value (rmgpy.quantity.ScalarQuantity attribute), 138verifyOutputFile() (rmgpy.qm.gaussian.Gaussian

method), 124verifyOutputFile() (rmgpy.qm.gaussian.GaussianMol

method), 125verifyOutputFile() (rmgpy.qm.gaussian.GaussianMolPM3

method), 127verifyOutputFile() (rmgpy.qm.gaussian.GaussianMolPM6

method), 129verifyOutputFile() (rmgpy.qm.mopac.Mopac method),

129verifyOutputFile() (rmgpy.qm.mopac.MopacMol

method), 131verifyOutputFile() (rmgpy.qm.mopac.MopacMolPM3

method), 132verifyOutputFile() (rmgpy.qm.mopac.MopacMolPM6

method), 134

Index 223


verifyOutputFile() (rmgpy.qm.mopac.MopacMolPM7method), 136

Vertex (class in rmgpy.molecule.graph), 85VF2 (class in rmgpy.molecule.vf2), 88visit() (rmgpy.cantherm.output.PrettifyVisitor method), 7visit_Call() (rmgpy.cantherm.output.PrettifyVisitor

method), 7visit_Dict() (rmgpy.cantherm.output.PrettifyVisitor

method), 7visit_List() (rmgpy.cantherm.output.PrettifyVisitor

method), 7visit_Num() (rmgpy.cantherm.output.PrettifyVisitor

method), 7visit_Str() (rmgpy.cantherm.output.PrettifyVisitor

method), 7visit_Tuple() (rmgpy.cantherm.output.PrettifyVisitor

method), 7

WWigner (class in rmgpy.kinetics), 81Wilhoit (class in rmgpy.thermo), 180writeInputFile() (rmgpy.qm.gaussian.GaussianMol

method), 126writeInputFile() (rmgpy.qm.gaussian.GaussianMolPM3

method), 127writeInputFile() (rmgpy.qm.gaussian.GaussianMolPM6

method), 129writeInputFile() (rmgpy.qm.mopac.MopacMol method),

131writeInputFile() (rmgpy.qm.mopac.MopacMolPM3

method), 133writeInputFile() (rmgpy.qm.mopac.MopacMolPM6

method), 134writeInputFile() (rmgpy.qm.mopac.MopacMolPM7

method), 136writeInputFile() (rmgpy.qm.symmetry.SymmetryJob

method), 123writeKineticsEntry() (in module rmgpy.chemkin), 12writeThermoEntry() (in module rmgpy.chemkin), 12

224 Index

release 2.0.0 william h. green, richard h. west, and the rmg team · 2017-01-12 ·...

Documents