def _run_statmech(self, arkane_spc, arkane_file, output_path=None, use_bac=False, kinetics=False, plot=False): """ A helper function for running an Arkane statmech job. Args: arkane_spc (str): An Arkane species() function representor. arkane_file (str): The path to the Arkane species file (either in .py or YAML form). output_path (str): The path to the folder containing the Arkane output.py file. use_bac (bool): A flag indicating whether or not to use bond additivity corrections (True to use). kinetics (bool) A flag indicating whether this specie is part of a kinetics job. plot (bool): A flag indicating whether to plot a PDF of the calculated thermo properties (True to plot) Returns: bool: Whether the job was successful (True for successful). """ success = True stat_mech_job = StatMechJob(arkane_spc, arkane_file) stat_mech_job.applyBondEnergyCorrections = use_bac and not kinetics and self.sp_level if not kinetics or (kinetics and self.sp_level): # currently we have to use a model chemistry for thermo stat_mech_job.modelChemistry = self.sp_level else: # if this is a kinetics computation and we don't have a valid model chemistry, don't bother about it stat_mech_job.applyAtomEnergyCorrections = False # Use the scaling factor if given, else try determining it from Arkane # (defaults to 1 and prints a warning if not found) stat_mech_job.frequencyScaleFactor = self.freq_scale_factor or assign_frequency_scale_factor(self.freq_level) try: stat_mech_job.execute(output_directory=os.path.join(output_path, 'output.py'), plot=plot) except Exception: success = False return success
def _run_statmech(self, arkane_spc, arkane_file, output_file_path=None, use_bac=False, kinetics=False, plot=False): """ A helper function for running an Arkane statmech job `arkane_spc` is the species() function from Arkane's input.py `arkane_file` is the Arkane species file (either .py or YAML form) `output_file_path` is a path to the Arkane output.py file `use_bac` is a bool flag indicating whether or not to use bond additivity corrections `kinetics` is a bool flag indicating whether this specie sis part of a kinetics job, in which case..?? `plot` is a bool flag indicating whether or not to plot a PDF of the calculated thermo properties """ success = True stat_mech_job = StatMechJob(arkane_spc, arkane_file) stat_mech_job.applyBondEnergyCorrections = use_bac and not kinetics and self.model_chemistry if not kinetics or kinetics and self.model_chemistry: # currently we have to use a model chemistry for thermo stat_mech_job.modelChemistry = self.model_chemistry else: # if this is a klinetics computation and we don't have a valid model chemistry, don't bother about it stat_mech_job.applyAtomEnergyCorrections = False stat_mech_job.frequencyScaleFactor = assign_frequency_scale_factor( self.model_chemistry) try: stat_mech_job.execute(outputFile=output_file_path, plot=plot) except Exception: success = False return success
def test_specifying_absolute_file_paths(self): """Test specifying absolute file paths of statmech files""" h2o2_input = """#!/usr/bin/env python # -*- coding: utf-8 -*- bonds = {{'H-O': 2, 'O-O': 1}} externalSymmetry = 2 spinMultiplicity = 1 opticalIsomers = 1 energy = {{'b3lyp/6-311+g(3df,2p)': Log('{energy}')}} geometry = Log('{freq}') frequencies = Log('{freq}') rotors = [HinderedRotor(scanLog=Log('{scan}'), pivots=[1, 2], top=[1, 3], symmetry=1, fit='fourier')] """ abs_arkane_path = os.path.abspath(os.path.dirname( __file__)) # this is the absolute path to `.../RMG-Py/arkane` energy_path = os.path.join('arkane', 'data', 'H2O2', 'sp_a19032.out') freq_path = os.path.join('arkane', 'data', 'H2O2', 'freq_a19031.out') scan_path = os.path.join('arkane', 'data', 'H2O2', 'scan_a19034.out') h2o2_input = h2o2_input.format(energy=energy_path, freq=freq_path, scan=scan_path) h2o2_path = os.path.join(abs_arkane_path, 'data', 'H2O2', 'H2O2.py') if not os.path.exists(os.path.dirname(h2o2_path)): os.makedirs(os.path.dirname(h2o2_path)) with open(h2o2_path, 'w') as f: f.write(h2o2_input) h2o2 = Species(label='H2O2', smiles='OO') self.assertIsNone(h2o2.conformer) statmech_job = StatMechJob(species=h2o2, path=h2o2_path) statmech_job.modelChemistry = 'b3lyp/6-311+g(3df,2p)' statmech_job.load(pdep=False, plot=False) self.assertAlmostEqual(h2o2.conformer.E0.value_si, -146031.49933673252) os.remove(h2o2_path)
def process(self): """Process ARC outputs and generate thermo and kinetics""" # Thermo: species_list_for_thermo_parity = list() species_for_thermo_lib = list() for species in self.species_dict.values(): if not species.is_ts and 'ALL converged' in self.output[ species.label]['status']: species_for_thermo_lib.append(species) output_file_path = self._generate_arkane_species_file(species) arkane_spc = arkane_species(str(species.label), species.arkane_file) if species.mol_list: arkane_spc.molecule = species.mol_list stat_mech_job = StatMechJob(arkane_spc, species.arkane_file) stat_mech_job.applyBondEnergyCorrections = self.use_bac stat_mech_job.modelChemistry = self.model_chemistry stat_mech_job.frequencyScaleFactor = assign_frequency_scale_factor( self.model_chemistry) stat_mech_job.execute(outputFile=output_file_path, plot=False) if species.generate_thermo: thermo_job = ThermoJob(arkane_spc, 'NASA') thermo_job.execute(outputFile=output_file_path, plot=False) species.thermo = arkane_spc.getThermoData() plotter.log_thermo(species.label, path=output_file_path) species.rmg_species = Species(molecule=[species.mol]) species.rmg_species.reactive = True if species.mol_list: species.rmg_species.molecule = species.mol_list # add resonance structures for thermo determination try: species.rmg_thermo = self.rmgdb.thermo.getThermoData( species.rmg_species) except ValueError: logging.info( 'Could not retrieve RMG thermo for species {0}, possibly due to missing 2D structure ' '(bond orders). Not including this species in the parity plots.' .format(species.label)) else: if species.generate_thermo: species_list_for_thermo_parity.append(species) # Kinetics: rxn_list_for_kinetics_plots = list() arkane_spc_dict = dict() # a dictionary with all species and the TSs for rxn in self.rxn_list: logging.info('\n\n') species = self.species_dict[rxn.ts_label] # The TS if 'ALL converged' in self.output[ species.label]['status'] and rxn.check_ts(): self.copy_freq_output_for_ts(species.label) success = True rxn_list_for_kinetics_plots.append(rxn) output_file_path = self._generate_arkane_species_file(species) arkane_ts = arkane_transition_state(str(species.label), species.arkane_file) arkane_spc_dict[species.label] = arkane_ts stat_mech_job = StatMechJob(arkane_ts, species.arkane_file) stat_mech_job.applyBondEnergyCorrections = False if not self.model_chemistry: stat_mech_job.modelChemistry = self.model_chemistry else: stat_mech_job.applyAtomEnergyCorrections = False stat_mech_job.frequencyScaleFactor = assign_frequency_scale_factor( self.model_chemistry) stat_mech_job.execute(outputFile=None, plot=False) for spc in rxn.r_species + rxn.p_species: if spc.label not in arkane_spc_dict.keys(): # add an extra character to the arkane_species label to distinguish between species calculated # for thermo and species calculated for kinetics (where we don't want to use BAC) arkane_spc = arkane_species(str(spc.label + '_'), spc.arkane_file) stat_mech_job = StatMechJob(arkane_spc, spc.arkane_file) arkane_spc_dict[spc.label] = arkane_spc stat_mech_job.applyBondEnergyCorrections = False if not self.model_chemistry: stat_mech_job.modelChemistry = self.model_chemistry else: stat_mech_job.applyAtomEnergyCorrections = False stat_mech_job.frequencyScaleFactor = assign_frequency_scale_factor( self.model_chemistry) stat_mech_job.execute(outputFile=None, plot=False) # thermo_job = ThermoJob(arkane_spc, 'NASA') # thermo_job.execute(outputFile=None, plot=False) # arkane_spc.thermo = arkane_spc.getThermoData() rxn.dh_rxn298 = sum([product.thermo.getEnthalpy(298) for product in arkane_spc_dict.values() if product.label in rxn.products])\ - sum([reactant.thermo.getEnthalpy(298) for reactant in arkane_spc_dict.values() if reactant.label in rxn.reactants]) arkane_rxn = arkane_reaction( label=str(rxn.label), reactants=[ str(label + '_') for label in arkane_spc_dict.keys() if label in rxn.reactants ], products=[ str(label + '_') for label in arkane_spc_dict.keys() if label in rxn.products ], transitionState=rxn.ts_label, tunneling='Eckart') kinetics_job = KineticsJob(reaction=arkane_rxn, Tmin=self.t_min, Tmax=self.t_max, Tcount=self.t_count) logging.info('Calculating rate for reaction {0}'.format( rxn.label)) try: kinetics_job.execute(outputFile=output_file_path, plot=False) except ValueError as e: """ ValueError: One or both of the barrier heights of -9.35259 and 62.6834 kJ/mol encountered in Eckart method are invalid. """ logging.error( 'Failed to generate kinetics for {0} with message:\n{1}' .format(rxn.label, e)) success = False if success: rxn.kinetics = kinetics_job.reaction.kinetics plotter.log_kinetics(species.label, path=output_file_path) rxn.rmg_reactions = rmgdb.determine_rmg_kinetics( rmgdb=self.rmgdb, reaction=rxn.rmg_reaction, dh_rxn298=rxn.dh_rxn298) logging.info('\n\n') output_dir = os.path.join(self.project_directory, 'output') if species_list_for_thermo_parity: plotter.draw_thermo_parity_plots(species_list_for_thermo_parity, path=output_dir) libraries_path = os.path.join(output_dir, 'RMG libraries') # species_list = [spc for spc in self.species_dict.values()] plotter.save_thermo_lib(species_for_thermo_lib, path=libraries_path, name=self.project, lib_long_desc=self.lib_long_desc) if rxn_list_for_kinetics_plots: plotter.draw_kinetics_plots(rxn_list_for_kinetics_plots, path=output_dir, t_min=self.t_min, t_max=self.t_max, t_count=self.t_count) libraries_path = os.path.join(output_dir, 'RMG libraries') plotter.save_kinetics_lib(rxn_list=rxn_list_for_kinetics_plots, path=libraries_path, name=self.project, lib_long_desc=self.lib_long_desc) self.clean_output_directory()