def main():
initializeLog(logging.INFO,'treegen.log')
dbdir = settings['database.directory']
familyName, nprocs = parse_arguments()
database = RMGDatabase()
database.load(
path=dbdir,
thermoLibraries=['Klippenstein_Glarborg2016', 'BurkeH2O2', 'thermo_DFT_CCSDTF12_BAC', 'DFT_QCI_thermo',
'primaryThermoLibrary', 'primaryNS', 'NitrogenCurran', 'NOx2018', 'FFCM1(-)',
'SulfurLibrary', 'SulfurGlarborgH2S'],
transportLibraries=[],
reactionLibraries=[],
seedMechanisms=[],
kineticsFamilies=[familyName],
kineticsDepositories=['training'],
# frequenciesLibraries = self.statmechLibraries,
depository=False, # Don't bother loading the depository information, as we don't use it
)
family = database.kinetics.families[familyName]
family.cleanTree(database.thermo)
family.generateTree(thermoDatabase=database.thermo, nprocs=min(4, nprocs))
family.checkTree()
family.regularize()
templateRxnMap = family.getReactionMatches(thermoDatabase=database.thermo, removeDegeneracy=True, getReverse=True, fixLabels=True)
family.makeBMRulesFromTemplateRxnMap(templateRxnMap, nprocs=min(6, nprocs))
family.checkTree()
family.save(os.path.join(dbdir,'kinetics','families',familyName))
def setUp(self):
rmg_database = RMGDatabase()
rmg_database.load(
rmgpy.settings['database.directory'],
kinetics_families=[
"R_Addition_MultipleBond",
"H_Abstraction",
"intra_H_migration"
],
transport_libraries=[],
reaction_libraries=[],
seed_mechanisms=[],
thermo_libraries=[
'primaryThermoLibrary',
'thermo_DFT_CCSDTF12_BAC',
'CBS_QB3_1dHR'],
solvation=False,
)
self.rmg_database = rmg_database
ts_database = TransitionStates()
path = os.path.join(autotst.settings["tst_database_path"], "H_Abstraction")
global_context = {'__builtins__': None}
local_context = {'DistanceData': DistanceData}
family = self.rmg_database.kinetics.families["H_Abstraction"]
ts_database.family = family
ts_database.load(path, local_context, global_context)
self.ts_database = ts_database
def convertPrIMe(family):
print 'Loading kinetics families...'
database = RMGDatabase()
database.kinetics = KineticsDatabase()
database.kinetics.loadFamilies('input/kinetics/families')
database.loadForbiddenStructures('input/forbiddenStructures.py')
for depository in database.kinetics.families[family].depositories:
if depository.label == '{0}/PrIMe'.format(family):
break
else:
raise Exception(
'Could not find PrIMe depository in {0} family.'.format(family))
entries = []
print 'Determining unique list of reactions...'
for entry0 in depository.entries.values():
for entry in entries:
if entry.item.isIsomorphic(entry0.item):
break
else:
entries.append(entry0)
print 'Found {0:d} unique reactions out of {1:d} entries.'.format(
len(entries), len(depository.entries))
print 'Sorting unique reactions...'
entries.sort(key=lambda entry: sum([
1 for r in entry.item.reactants for a in r.atoms if a.isNonHydrogen()
]))
print 'Saving reactions...'
for index, entry in enumerate(entries):
label = entry.label
reaction = entry.item
# Determine degeneracy in both directions
reactions = database.kinetics.generateReactionsFromFamilies(
reaction.reactants, reaction.products, only_families=[family])
if len(reactions) != 1:
print 'Warning: could not determine forward degeneracy for reaction #{0:d}.'.format(
index + 1)
forwardDegeneracy = 1
else:
forwardDegeneracy = reactions[0].degeneracy
reactions = database.kinetics.generateReactionsFromFamilies(
reaction.products, reaction.reactants, only_families=[family])
if len(reactions) != 1:
print 'Warning: could not determine reverse degeneracy for reaction #{0:d}.'.format(
index + 1)
reverseDegeneracy = 1
else:
reverseDegeneracy = reactions[0].degeneracy
saveReaction(
'input/kinetics/families/{0}/training/{0}.py'.format(
family, index + 1), index + 1, label, reaction,
forwardDegeneracy, reverseDegeneracy)
def setUpClass(cls):
"""This method is run once before all tests in this class."""
test_dir = rmgpy.settings['test_data.directory']
data_dir = os.path.join(test_dir, 'testing_database')
chem_dir = os.path.join(test_dir, 'parsing_data')
chemkin_file = os.path.join(chem_dir, 'chem_annotated.inp')
spc_dict = os.path.join(chem_dir, 'species_dictionary.txt')
cls.uncertainty = Uncertainty(outputDirectory='chemDir')
cls.uncertainty.loadModel(chemkin_file, spc_dict)
# load database properly
cls.uncertainty.database = RMGDatabase()
cls.uncertainty.database.load(
data_dir,
kineticsFamilies='all',
kineticsDepositories=['training'],
thermoLibraries=['primaryThermoLibrary'],
reactionLibraries=['GRI-Mech3.0'],
)
# Prepare the database by loading training reactions and averaging the rate rules verbosely
for family in cls.uncertainty.database.kinetics.families.itervalues():
family.addKineticsRulesFromTrainingSet(
thermoDatabase=cls.uncertainty.database.thermo)
family.fillKineticsRulesByAveragingUp(verbose=True)
def loadDatabase(self, kineticsFamilies='all',kineticsDepositories=None,thermoLibraries=None, reactionLibraries=None):
"""
This function loads a single copy of the RMGDatabase with full verbose averaging
of the rate rule to trace kinetics sources.
By default, this function loads all the kinetics families, only the training kinetics depository,
the primaryThermoLibrary, and no reaction libraries.
"""
from rmgpy.data.rmg import RMGDatabase
from rmgpy import settings
if not kineticsDepositories:
kineticsDepositories = ['training']
if not thermoLibraries:
thermoLibraries = ['primaryThermoLibrary']
if not reactionLibraries:
reactionLibraries = []
self.database = RMGDatabase()
self.database.load(settings['database.directory'],
kineticsFamilies=kineticsFamilies,
kineticsDepositories=kineticsDepositories,
thermoLibraries=thermoLibraries,
reactionLibraries=reactionLibraries,
)
# Prepare the database by loading training reactions but not averaging the rate rules
for familyLabel, family in self.database.kinetics.families.iteritems():
family.addKineticsRulesFromTrainingSet(thermoDatabase=self.database.thermo)
family.fillKineticsRulesByAveragingUp(verbose=True)
def setUpModule():
"""A function that is run ONCE before all unit tests in this module."""
global database
database = RMGDatabase()
database.load(
path=os.path.join(settings['test_data.directory'], 'testing_database'),
thermoLibraries=['primaryThermoLibrary'],
reactionLibraries=['GRI-Mech3.0'],
kineticsFamilies=[
'R_Recombination', 'Disproportionation', 'R_Addition_MultipleBond',
'H_Abstraction'
],
testing=True,
depository=False,
solvation=False,
)
#load empty forbidden structures to avoid any dependence on forbidden structures
#for these tests
for family in database.kinetics.families.values():
family.forbidden = ForbiddenStructures()
database.forbiddenStructures = ForbiddenStructures()
# Prepare the database by loading training reactions and averaging the rate rules
for family in database.kinetics.families.values():
family.addKineticsRulesFromTrainingSet(thermoDatabase=database.thermo)
family.fillKineticsRulesByAveragingUp(verbose=True)
def simple_react(n_cp, n_iter):
# load RMG database to create reactions
database = RMGDatabase()
database.load(
path=settings['database.directory'],
thermoLibraries=['primaryThermoLibrary'
], # can add others if necessary
kineticsFamilies='all',
reactionLibraries=[],
kineticsDepositories='')
kinetics_db = database.kinetics
mol0 = Molecule().fromSMILES('CCCCCCCCC1CCCc2ccccc21')
mol1 = Molecule().fromSMILES('CCCCCCCCC1CCCC2C=CC=CC=21')
mol_tuple = (mol0, mol1)
reactions = []
for i in range(n_iter):
mol_tuples = [mol_tuple] * n_cp
results = map_(react_molecules_wrapper, mol_tuples)
reactions_iter = itertools.chain.from_iterable(results)
print "{0} iter: {1} reactions.".format(i, len(list(reactions_iter)))
def setUpClass(cls):
"""A function run ONCE before all unit tests in this class."""
# Set up a dummy database
cls.database = RMGDatabase()
cls.database.load(
path=os.path.join(settings['test_data.directory'], 'testing_database'),
thermo_libraries=[],
reaction_libraries=[],
kinetics_families=[],
depository=False,
solvation=False,
testing=True,
)
cls.database.load_forbidden_structures()
cls.thermoDatabase = ThermoDatabase() # the real full Thermo Database
cls.thermoDatabase.load(path=os.path.join(settings['database.directory'], 'thermo'),
libraries=['primaryThermoLibrary'])
cls.kineticsDatabase = KineticsDatabase()
cls.kineticsDatabase.load_families(
path=os.path.join(settings['test_data.directory'], 'testing_database/kinetics/families'),
families=[
'Singlet_Carbene_Intra_Disproportionation',
],
)
cls.family = cls.kineticsDatabase.families['Singlet_Carbene_Intra_Disproportionation']
cls.treerxns = cls.family.get_training_set(thermo_database=cls.thermoDatabase, remove_degeneracy=True,
estimate_thermo=True, fix_labels=True, get_reverse=True)
def setUpClass(cls):
"""
Load the database before running the tests.
"""
databaseDirectory = settings['database.directory']
cls.database = RMGDatabase()
cls.database.load(databaseDirectory, kineticsFamilies='all')
def setUpClass(cls):
"""This method is run once before all tests in this class."""
test_dir = rmgpy.settings['test_data.directory']
data_dir = os.path.join(test_dir, 'testing_database')
chem_dir = os.path.join(test_dir, 'parsing_data')
chemkin_file = os.path.join(chem_dir, 'chem_annotated.inp')
spc_dict = os.path.join(chem_dir, 'species_dictionary.txt')
cls.uncertainty = Uncertainty(outputDirectory='chemDir')
cls.uncertainty.loadModel(chemkin_file, spc_dict)
# load database properly
cls.uncertainty.database = RMGDatabase()
cls.uncertainty.database.load(
data_dir,
kineticsFamilies=[
'1,2_shiftC', '6_membered_central_C-C_shift',
'Disproportionation', 'H_Abstraction', 'Intra_ene_reaction',
'intra_H_migration', 'Intra_R_Add_Exo_scission',
'intra_substitutionS_isomerization', 'R_Addition_MultipleBond',
'R_Recombination'
],
kineticsDepositories=['training'],
thermoLibraries=['primaryThermoLibrary'],
reactionLibraries=['GRI-Mech3.0'],
)
# Prepare the database by loading training reactions and averaging the rate rules verbosely
for family in cls.uncertainty.database.kinetics.families.itervalues():
family.addKineticsRulesFromTrainingSet(
thermoDatabase=cls.uncertainty.database.thermo)
family.fillKineticsRulesByAveragingUp(verbose=True)
def load():
tearDown()
rmg = RMG()#for solvent
database = RMGDatabase()
database.loadThermo(os.path.join(settings['database.directory'], 'thermo'))
database.loadTransport(os.path.join(settings['database.directory'], 'transport'))
database.loadSolvation(os.path.join(settings['database.directory'], 'solvation'))
def main():
initialize_log(logging.INFO, 'treegen.log')
dbdir = settings['database.directory']
family_name = parse_arguments()
database = RMGDatabase()
database.load(
path=dbdir,
thermo_libraries=['Klippenstein_Glarborg2016', 'BurkeH2O2', 'thermo_DFT_CCSDTF12_BAC', 'DFT_QCI_thermo',
'primaryThermoLibrary', 'primaryNS', 'NitrogenCurran', 'NOx2018', 'FFCM1(-)',
'SulfurLibrary', 'SulfurGlarborgH2S', 'SABIC_aromatics'],
transport_libraries=[],
reaction_libraries=[],
seed_mechanisms=[],
kinetics_families=[family_name],
kinetics_depositories=['training'],
# frequenciesLibraries = self.statmechLibraries,
depository=False, # Don't bother loading the depository information, as we don't use it
)
family = database.kinetics.families[family_name]
num_training_rxns = len(family.get_training_depository().entries)
max_batch_size = 800
family.clean_tree()
if (num_training_rxns/max_batch_size > 1) and (num_training_rxns/max_batch_size <= 1.3):
family.generate_tree(thermo_database=database.thermo, nprocs=1, max_batch_size=num_training_rxns)
else:
family.generate_tree(thermo_database=database.thermo, nprocs=1)
family.check_tree()
family.regularize()
template_rxn_map = family.get_reaction_matches(thermo_database=database.thermo, remove_degeneracy=True,
get_reverse=True, fix_labels=True)
family.make_bm_rules_from_template_rxn_map(template_rxn_map, nprocs=1)
family.check_tree()
family.save(os.path.join(dbdir, 'kinetics', 'families', family_name))
def setUpClass(cls):
"""A function run ONCE before all unit tests in this class."""
# Set up a dummy database
cls.database = RMGDatabase()
cls.database.load(
path=os.path.join(settings['test_data.directory'],
'testing_database'),
thermoLibraries=[],
reactionLibraries=[],
kineticsFamilies=[],
depository=False,
solvation=False,
testing=True,
)
cls.database.loadForbiddenStructures()
cls.thermoDatabase = ThermoDatabase() #the real full Thermo Database
cls.thermoDatabase.load(path=os.path.join(
settings['database.directory'], 'thermo'),
libraries=['primaryThermoLibrary'])
cls.kineticsDatabase = KineticsDatabase()
cls.kineticsDatabase.loadFamilies(
path=os.path.join(settings['test_data.directory'],
'testing_database/kinetics/families'),
families=[
'Singlet_Carbene_Intra_Disproportionation',
],
)
cls.family = cls.kineticsDatabase.families[
'Singlet_Carbene_Intra_Disproportionation']
def testGetRingGroupsFromComments(self):
"""
Test that getRingGroupsFromComments method works for fused polycyclics.
"""
from rmgpy.thermo.thermoengine import generateThermoData
# set-up RMG object
rmg = RMG()
# load kinetic database and forbidden structures
rmg.database = RMGDatabase()
path = os.path.join(settings['database.directory'])
# forbidden structure loading
rmg.database.loadThermo(os.path.join(path, 'thermo'))
smi = 'C12C(C3CCC2C3)C4CCC1C4' #two norbornane rings fused together
spc = Species().fromSMILES(smi)
spc.thermo = generateThermoData(spc)
thermodb = rmg.database.thermo
thermodb.getRingGroupsFromComments(spc.thermo)
import rmgpy.data.rmg
rmgpy.data.rmg.database = None
def loadDatabase():
print 'Loading RMG database...'
from rmgpy.data.rmg import RMGDatabase
database = RMGDatabase()
database.load(settings['database.directory'],
kineticsFamilies='all',
kineticsDepositories='all')
return database
def database(
thermoLibraries = None,
transportLibraries = None,
reactionLibraries = None,
frequenciesLibraries = None,
kineticsFamilies = 'default',
kineticsDepositories = 'default',
kineticsEstimator = 'rate rules',
):
if isinstance(thermoLibraries, str):
thermoLibraries = [thermoLibraries]
if isinstance(transportLibraries, str):
transportLibraries = [transportLibraries]
if isinstance(reactionLibraries, str):
reactionLibraries = [reactionLibraries]
if isinstance(frequenciesLibraries, str):
frequenciesLibraries = [frequenciesLibraries]
databaseDirectory = settings['database.directory']
thermoLibraries = thermoLibraries or []
transportLibraries = transportLibraries
reactionLibraries = reactionLibraries or []
kineticsEstimator = kineticsEstimator
if kineticsDepositories == 'default':
kineticsDepositories = ['training']
elif kineticsDepositories == 'all':
kineticsDepositories = None
else:
if not isinstance(kineticsDepositories,list):
raise InputError("kineticsDepositories should be either 'default', 'all', or a list of names eg. ['training','PrIMe'].")
kineticsDepositories = kineticsDepositories
if kineticsFamilies in ('default', 'all', 'none'):
kineticsFamilies = kineticsFamilies
else:
if not isinstance(kineticsFamilies,list):
raise InputError("kineticsFamilies should be either 'default', 'all', 'none', or a list of names eg. ['H_Abstraction','R_Recombination'] or ['!Intra_Disproportionation'].")
kineticsFamilies = kineticsFamilies
database = getDB() or RMGDatabase()
database.load(
path = databaseDirectory,
thermoLibraries = thermoLibraries,
transportLibraries = transportLibraries,
reactionLibraries = reactionLibraries,
seedMechanisms = [],
kineticsFamilies = kineticsFamilies,
kineticsDepositories = kineticsDepositories,
depository = False, # Don't bother loading the depository information, as we don't use it
)
for family in database.kinetics.families.values(): #load training
family.addKineticsRulesFromTrainingSet(thermoDatabase=database.thermo)
for family in database.kinetics.families.values():
family.fillKineticsRulesByAveragingUp(verbose=True)
def TS_Database_Update(families, path=None, auto_save=False):
"""
Expects list of reaction families
Loads RMG Databse,
Creaes instance of TS_updater for each reaction family in families,
Return dictionary of family:family's instance of the updater
"""
assert isinstance(
families, list
), "Families must be a list. If singular family, still keep it in list"
acceptable_families = os.listdir(
os.path.join(os.path.expandvars("$RMGpy"), "..", "AutoTST",
"database"))
for family in families:
assert isinstance(family,
str), "Family names must be provided as strings"
if family.upper() not in (family.upper()
for family in acceptable_families):
logging.warning(
'"{}" is not a known Kinetics Family'.format(family))
families.remove(family)
logging.info("Loading RMG Database...")
rmg_database = RMGDatabase()
database_path = os.path.join(os.path.expandvars('$RMGpy'), "..",
'RMG-database', 'input')
try:
rmg_database.load(
database_path,
# kineticsFamilies=['H_Abstraction'],
kineticsFamilies=families,
transportLibraries=[],
reactionLibraries=[],
seedMechanisms=[],
thermoLibraries=[
'primaryThermoLibrary', 'thermo_DFT_CCSDTF12_BAC',
'CBS_QB3_1dHR'
],
solvation=False,
)
except:
logging.error(
"Failed to Load RMG Database at {}".format(database_path))
Databases = {
family: TS_Updater(family, rmg_database, path=path)
for family in families
}
if auto_save == True:
save_all_individual_databases(Databases)
return Databases
def make_rmg_database_object():
"""
Make a clean RMGDatabase object.
Returns: RMGDatabase
A clean RMG database object.
"""
rmgdb = RMGDatabase()
return rmgdb
def main(dictionary):
database = RMGDatabase()
database.loadTransport(path=os.path.join(settings['database.directory'],
'transport'),
transportLibraries=None)
speciesDict = loadSpeciesDictionary(dictionary)
saveTransportFile('tran.dat', speciesDict.values())
def database(thermoLibraries=None,
transportLibraries=None,
reactionLibraries=None,
frequenciesLibraries=None,
kineticsFamilies='default',
kineticsDepositories='default',
kineticsEstimator='rate rules'):
"""Load the RMG database"""
thermo_libraries = as_list(thermoLibraries, default=[])
transport_libraries = as_list(transportLibraries, default=None)
reaction_libraries = as_list(reactionLibraries, default=[])
database_directory = settings['database.directory']
if kineticsDepositories == 'default':
kinetics_depositories = ['training']
elif kineticsDepositories == 'all':
kinetics_depositories = None
else:
if not isinstance(kineticsDepositories, list):
raise InputError(
"kinetics_depositories should be either 'default', 'all', or a list of names eg. ['training','PrIMe']."
)
kinetics_depositories = kineticsDepositories
if kineticsFamilies in ('default', 'all', 'none'):
kinetics_families = kineticsFamilies
else:
if not isinstance(kineticsFamilies, list):
raise InputError(
"kineticsFamilies should be either 'default', 'all', 'none', or a list of names eg. "
"['H_Abstraction','R_Recombination'] or ['!Intra_Disproportionation']."
)
kinetics_families = kineticsFamilies
rmg_database = get_db() or RMGDatabase()
rmg_database.load(
path=database_directory,
thermo_libraries=thermo_libraries,
transport_libraries=transport_libraries,
reaction_libraries=reaction_libraries,
seed_mechanisms=[],
kinetics_families=kinetics_families,
kinetics_depositories=kinetics_depositories,
depository=
False, # Don't bother loading the depository information, as we don't use it
)
for family in rmg_database.kinetics.families.values(): # load training
if not family.auto_generated:
family.add_rules_from_training(thermo_database=rmg_database.thermo)
for family in rmg_database.kinetics.families.values():
family.fill_rules_by_averaging_up(verbose=True)
def __init__(self):
self.database = RMGDatabase()
self.database.kinetics = KineticsDatabase()
self.database.thermo = ThermoDatabase()
self.database.transport = TransportDatabase()
self.database.statmech = StatmechDatabase()
self.database.solvation = SolvationDatabase()
self.database.load_forbidden_structures(
os.path.join(rmgweb.settings.DATABASE_PATH,
'forbiddenStructures.py'))
self.timestamps = {}
def loadDatabase(args):
print 'Loading RMG database...'
from rmgpy.data.rmg import RMGDatabase
rmgDatabase = RMGDatabase()
rmgDatabase.load('/Users/belinda/Code/RMG-database/input',
kineticsFamilies=args.family)
rxnFamily = rmgDatabase.kinetics.families[args.family[0]]
database = rxnFamily.solvationCorrections
return database, rmgDatabase
def setUpClass(cls):
"""
A method that is run before each unit test in this class.
"""
# set-up RMG object
cls.rmg = RMG()
# load kinetic database and forbidden structures
cls.rmg.database = RMGDatabase()
path = os.path.join(settings['database.directory'])
# forbidden structure loading
cls.rmg.database.load_thermo(os.path.join(path, 'thermo'))
def export(input, output, database=None):
print 'Loading the new RMG-Py database...'
if not database:
database = RMGDatabase()
database.load(input)
print 'Constructing additional rate rules from kinetics depository...'
for family in database.kinetics.families.values():
generateRules(family, database)
print 'Saving old RMG-Java database...'
database.saveOld(output)
def setUpClass(cls):
"""A function run ONCE before all unit tests in this class."""
# Set up a dummy database
cls.database = RMGDatabase()
cls.database.load(
path=os.path.join(settings['test_data.directory'], 'testing_database'),
thermoLibraries=[],
reactionLibraries=[],
kineticsFamilies=['H_Abstraction'],
depository=False,
solvation=False,
testing=True,
)
cls.database.loadForbiddenStructures()
def test_to_wilhoit(self):
"""
Test if the entropy computed from other thermo implementations is close to what Wilhoit computes.
"""
from rmgpy import settings
from rmgpy.data.rmg import RMGDatabase
from rmgpy.species import Species
# Load databases
database = RMGDatabase()
database.load_thermo(os.path.join(settings['database.directory'],
'thermo'),
thermo_libraries=['Narayanaswamy'])
database.load_solvation(
os.path.join(settings['database.directory'], 'solvation'))
spc = Species().from_smiles('CC')
spc.get_thermo_data()
T = 1350. # not 298K!
# nasa to wilhoit
nasa = spc.thermo
s_nasa = nasa.get_entropy(T)
nasa_to_wh = nasa.to_wilhoit()
s_nasa_to_wh = nasa_to_wh.get_entropy(T)
self.assertAlmostEqual(s_nasa, s_nasa_to_wh, -1)
self.assertEqual(nasa.comment, nasa_to_wh.comment)
# wilhoit to nasa conversion done in nasaTest.py
# thermo data to wilhoit:
td = nasa.to_thermo_data()
s_td = td.get_entropy(T)
wilhoit = td.to_wilhoit(B=1000.)
s_wh = wilhoit.get_entropy(T)
self.assertAlmostEqual(s_td, s_wh, -1)
self.assertEqual(td.comment, wilhoit.comment)
# wilhoit back to thermodata
td = wilhoit.to_thermo_data()
s_td = td.get_entropy(T)
self.assertAlmostEqual(s_td, s_wh, -1)
self.assertEqual(td.comment, wilhoit.comment)
def database_setup():
# load RMG database to create reactions
database = RMGDatabase()
database.load(
path = settings['database.directory'],
thermoLibraries = ['primaryThermoLibrary'], # can add others if necessary
kineticsFamilies = 'all',
reactionLibraries = [],
kineticsDepositories = ''
)
thermodb = database.thermo
print thermodb.libraries.keys()
def setUpClass(cls):
"""A function run ONCE before all unit tests in this class."""
# Set up a dummy database
cls.database = RMGDatabase()
cls.database.load(
path=os.path.join(settings['test_data.directory'], 'testing_database'),
thermoLibraries=[],
reactionLibraries=[],
kineticsFamilies=['H_Abstraction', 'R_Addition_MultipleBond', 'Singlet_Val6_to_triplet', 'R_Recombination',
'Baeyer-Villiger_step1_cat', 'Surface_Adsorption_Dissociative', 'Surface_Dissociation_vdW'],
depository=False,
solvation=False,
testing=True,
)
cls.database.loadForbiddenStructures()
def export(input, output, database=None):
print 'Loading the new RMG-Py database...'
if not database:
database = RMGDatabase()
database.load(input, kineticsFamilies='all', kineticsDepositories='all')
print 'Constructing additional rate rules from kinetics depository...'
for family in database.kinetics.families.values():
family.addKineticsRulesFromTrainingSet(thermoDatabase=database.thermo)
print "Deleting thermo library entries with atoms RMG-Java can't understand..."
database.thermo.pruneHeteroatoms(allowed=['C', 'H', 'O', 'S'])
print 'Saving old RMG-Java database...'
database.saveOld(output)
print "Done!"
def loadDatabase(component='', section=''):
"""
Load the requested `component` of the RMG database if modified since last loaded.
"""
global database
if not database:
database = RMGDatabase()
database.thermo = ThermoDatabase()
database.kinetics = KineticsDatabase()
database.loadForbiddenStructures(os.path.join(settings.DATABASE_PATH, 'forbiddenStructures.py'))
if component in ['thermo', '']:
if section in ['depository', '']:
dirpath = os.path.join(settings.DATABASE_PATH, 'thermo', 'depository')
if isDirModified(dirpath):
database.thermo.loadDepository(dirpath)
resetDirTimestamps(dirpath)
if section in ['libraries', '']:
dirpath = os.path.join(settings.DATABASE_PATH, 'thermo', 'libraries')
if isDirModified(dirpath):
database.thermo.loadLibraries(dirpath)
# put them in our preferred order, so that when we look up thermo in order to estimate kinetics,
# we use our favourite values first.
preferred_order = ['primaryThermoLibrary','DFT_QCI_thermo','GRI-Mech3.0','CBS_QB3_1dHR','KlippensteinH2O2']
new_order = [i for i in preferred_order if i in database.thermo.libraryOrder]
for i in database.thermo.libraryOrder:
if i not in new_order: new_order.append(i)
database.thermo.libraryOrder = new_order
resetDirTimestamps(dirpath)
if section in ['groups', '']:
dirpath = os.path.join(settings.DATABASE_PATH, 'thermo', 'groups')
if isDirModified(dirpath):
database.thermo.loadGroups(dirpath)
resetDirTimestamps(dirpath)
if component in ['kinetics', '']:
if section in ['libraries', '']:
dirpath = os.path.join(settings.DATABASE_PATH, 'kinetics', 'libraries')
if isDirModified(dirpath):
database.kinetics.loadLibraries(dirpath)
resetDirTimestamps(dirpath)
if section in ['families', '']:
dirpath = os.path.join(settings.DATABASE_PATH, 'kinetics', 'families')
if isDirModified(dirpath):
database.kinetics.loadFamilies(dirpath)
resetDirTimestamps(dirpath)
return database
