def make_header_str(spc_dct, temps, pressures): """ makes the standard header and energy transfer sections for MESS input file """ ioprinter.messpf('global_header') keystr1 = ( 'EnergyStepOverTemperature, ExcessEnergyOverTemperature, ' + 'ModelEnergyLimit' ) keystr2 = ( 'CalculationMethod, WellCutoff, ' + 'ChemicalEigenvalueMax, ReductionMethod, AtomDistanceMin' ) ioprinter.debug_message(' {}'.format(keystr1)) ioprinter.debug_message(' {}'.format(keystr2)) if is_abstraction(spc_dct): well_extend = None else: well_extend = 'auto' ioprinter.debug_message('Including WellExtend in MESS input') header_str = mess_io.writer.global_rates_input( temps, pressures, excess_ene_temp=None, well_extend=well_extend) return header_str
def run_messpf_task(run_messpf_tsk, spc_locs_dct, spc_dct, thm_paths_dct): """ Run messpf input file """ ioprinter.messpf('run_header') spc_mods, _ = parser.models.extract_models(run_messpf_tsk) for spc_name in spc_locs_dct: ioprinter.therm_paths_messpf_run_locations(spc_name, spc_locs_dct[spc_name], spc_mods, thm_paths_dct) # Run MESSPF for all requested models, combine the PFS at the end ioprinter.message(f'Run MESSPF: {spc_name}', newline=1) _locs_pfs = [] for spc_locs in spc_locs_dct[spc_name]: _mod_pfs = [] for spc_mod in spc_mods: autorun.run_script( autorun.SCRIPT_DCT['messpf'], thm_paths_dct[spc_name][tuple(spc_locs)][spc_mod][0]) _mod_pfs.append( reader.mess.messpf( thm_paths_dct[spc_name][tuple(spc_locs)][spc_mod][0])) # Unpack the the pf model combination information spc_mod_info = parser.models.split_model(spc_mod) _spc_mods, coeffs, operators = spc_mod_info final_pf = thermfit.pf.combine(_mod_pfs, coeffs, operators) writer.mess.output( fstring(spc_dct[spc_name]['inchi']), final_pf, thm_paths_dct[spc_name][tuple(spc_locs)]['mod_total'][0], filename='pf.dat') _locs_pfs.append(final_pf)
def produce_boltzmann_weighted_conformers_pf(run_messpf_tsk, spc_locs_dct, spc_dct, thm_paths_dct): """ Combine PFs into final pf """ ioprinter.messpf('run_header') spc_mods, _ = parser.models.extract_models(run_messpf_tsk) print('starting produce_boltz...') for spc_name in spc_locs_dct: ioprinter.message(f'Run MESSPF: {spc_name}', newline=1) locs_pfs_arrays = [] hf_array = [] for idx, spc_locs in enumerate(spc_locs_dct[spc_name]): locs_pfs_arrays.append( reader.mess.messpf( thm_paths_dct[spc_name][tuple(spc_locs)]['mod_total'][0])) hf_val = 0. for spc_mod in spc_mods: hf_val += (spc_dct[spc_name]['Hfs'][idx][spc_mod][0] / len(spc_mods)) hf_array.append(hf_val) final_pf = thermfit.pf.boltzmann_pf_combination( locs_pfs_arrays, hf_array) writer.mess.output(fstring(spc_dct[spc_name]['inchi']), final_pf, thm_paths_dct[spc_name]['spc_total'][0], filename='pf.dat') spc_dct[spc_name]['Hfs']['final'] = [min(hf_array)] return spc_dct
def write_messpf_task(write_messpf_tsk, spc_locs_dct, spc_dct, pes_mod_dct, spc_mod_dct, run_prefix, save_prefix, thm_paths_dct): """ Write messpf input file """ ioprinter.messpf('write_header') spc_mods, pes_mod = parser.models.extract_models(write_messpf_tsk) for spc_name in spc_locs_dct: ioprinter.therm_paths_messpf_write_locations(spc_name, spc_locs_dct[spc_name], spc_mods, thm_paths_dct) for spc_locs in spc_locs_dct[spc_name]: for spc_mod in spc_mods: messpf_inp_str, dat_dct = qt.make_messpf_str( pes_mod_dct[pes_mod]['therm_temps'], spc_dct, spc_name, spc_locs, pes_mod_dct[pes_mod], spc_mod_dct[spc_mod], run_prefix, save_prefix) ioprinter.messpf('input_string') ioprinter.info_message(messpf_inp_str) autorun.write_input( thm_paths_dct[spc_name][tuple(spc_locs)][spc_mod][0], messpf_inp_str, aux_dct=dat_dct, input_name='pf.inp')
def write_mess_output(formulastr, final_pf, mess_path, filename='pf.dat'): """ Write a mess output file for a pf file """ mess_out_str = mess_io.writer.pf_output(formulastr, *final_pf) ioprinter.messpf('write_output', mess_path) if not os.path.exists(mess_path): os.makedirs(mess_path) with open(os.path.join(mess_path, filename), 'w') as mess_file: mess_file.write(mess_out_str)
def make_header_str(spc_dct, rxn_lst, pes_idx, pesgrp_num, pes_param_dct, hot_enes_dct, label_dct, temps, pressures, float_type): """ Built the head of the MESS input file that contains various global keywords used for running rate calculations. Function determines certain input parameters for the well-extension methodology based on the reaction type stored in spc_dct. :param spc_dct: :type spc_dct: dict[] :param temps: temperatures for the rate calculations (in K) :type temps: tuple(float) :param pressures: pressures for the rate calculations (in atm) :type pressures: tuple(float) :rtype: str """ ioprinter.messpf('global_header') keystr1 = ('EnergyStepOverTemperature, ExcessEnergyOverTemperature, ' + 'ModelEnergyLimit') keystr2 = ('CalculationMethod, WellCutoff, ' + 'ChemicalEigenvalueMax, ReductionMethod, AtomDistanceMin') ioprinter.debug_message(f' {keystr1}') ioprinter.debug_message(f' {keystr2}') # Set the well extension energy thresh if is_abstraction_pes(spc_dct, rxn_lst, pes_idx): well_extend = None else: well_extend = 'auto' ioprinter.debug_message('Including WellExtend in MESS input') # Set other parameters # Need the PES number to pull the correct params out of lists ped_spc_lst, hot_enes_dct, micro_out_params = energy_dist_params( pesgrp_num, pes_param_dct, hot_enes_dct, label_dct) header_str = mess_io.writer.global_rates_input( temps, pressures, calculation_method='direct', well_extension=well_extend, ped_spc_lst=ped_spc_lst, hot_enes_dct=hot_enes_dct, excess_ene_temp=None, micro_out_params=micro_out_params, float_type=float_type) return header_str
def make_global_etrans_str(rxn_lst, spc_dct, etrans_dct): """ Writes a string with defining global energy transfer parameters used for all wells on the PES that do not have parameters defined in their respective sections. As a default, the function will obtain parameters for the first well that appears on the PES. """ ioprinter.messpf('transfer_section') # Determine the species for which you ioprinter.messpf('well_section') well_info = etrans.set_etrans_well(rxn_lst, spc_dct) # Determine the bath ioprinter.messpf('bath_section') bath_info = etrans.set_bath(spc_dct, etrans_dct) # Write the MESS energy transfer strings edown_str, collid_str = etrans.make_energy_transfer_strs( well_info, bath_info, etrans_dct) energy_trans_str = mess_io.writer.global_energy_transfer_input( edown_str, collid_str) return energy_trans_str
def make_header_str(spc_dct, temps, pressures): """ Built the head of the MESS input file that contains various global keywords used for running rate calculations. Function determines certain input parameters for the well-extension methodology based on the reaction type stored in spc_dct. :param spc_dct: :type spc_dct: dict[] :param temps: temperatures for the rate calculations (in K) :type temps: tuple(float) :param pressures: pressures for the rate calculations (in atm) :type pressures: tuple(float) :rtype: str """ ioprinter.messpf('global_header') keystr1 = ('EnergyStepOverTemperature, ExcessEnergyOverTemperature, ' + 'ModelEnergyLimit') keystr2 = ('CalculationMethod, WellCutoff, ' + 'ChemicalEigenvalueMax, ReductionMethod, AtomDistanceMin') ioprinter.debug_message(' {}'.format(keystr1)) ioprinter.debug_message(' {}'.format(keystr2)) if is_abstraction_pes(spc_dct): well_extend = None else: well_extend = 'auto' ioprinter.debug_message('Including WellExtend in MESS input') header_str = mess_io.writer.global_rates_input(temps, pressures, excess_ene_temp=None, well_extend=well_extend) return header_str
def make_global_etrans_str(rxn_lst, spc_dct, etrans_dct): """ Makes the standard header and energy transfer sections for MESS input file """ ioprinter.messpf('transfer_section') # Determine the species for which you ioprinter.messpf('well_section') well_info = etrans.set_etrans_well(rxn_lst, spc_dct) # Determine the bath ioprinter.messpf('bath_section') bath_info = etrans.set_bath(spc_dct, etrans_dct) # Write the MESS energy transfer strings edown_str, collid_str = etrans.make_energy_transfer_strs( well_info, bath_info, etrans_dct) energy_trans_str = mess_io.writer.global_energy_transfer_input( edown_str, collid_str) return energy_trans_str
def make_pes_mess_str(spc_dct, rxn_lst, pes_idx, pesgrp_num, unstable_chnls, run_prefix, save_prefix, label_dct, tsk_key_dct, pes_param_dct, thy_dct, pes_model_dct_i, spc_model_dct_i, spc_model): """ Write all the MESS input file strings for the reaction channels """ ioprinter.messpf('channel_section') # Initialize data carrying objects and empty MESS strings basis_energy_dct = {} basis_energy_dct[spc_model] = {} full_well_str, full_bi_str, full_ts_str = '', '', '' full_dat_str_dct = {} # Set the energy and model for the first reference species ioprinter.info_message('\nCalculating reference energy for PES') ref_ene, model_basis_energy_dct = set_reference_ene( rxn_lst, spc_dct, tsk_key_dct, basis_energy_dct[spc_model], thy_dct, pes_model_dct_i, spc_model_dct_i, run_prefix, save_prefix, ref_idx=0) basis_energy_dct[spc_model].update(model_basis_energy_dct) print('basis energy dct') print(basis_energy_dct) # Loop over all the channels and write the MESS strings written_labels = [] for rxn in rxn_lst: chnl_idx, (reacs, prods) = rxn ioprinter.obj('vspace') ioprinter.reading('PES electronic structure data') ioprinter.channel(chnl_idx + 1, reacs, prods) # Get the names for all of the configurations of the TS tsname = base_tsname(pes_idx, chnl_idx) tsname_allconfigs = tsnames_in_dct(pes_idx, chnl_idx, spc_dct) # Pass in full ts class chnl_infs, chn_basis_ene_dct = get_channel_data( reacs, prods, tsname_allconfigs, spc_dct, tsk_key_dct, basis_energy_dct[spc_model], thy_dct, pes_model_dct_i, spc_model_dct_i, run_prefix, save_prefix) basis_energy_dct[spc_model].update(chn_basis_ene_dct) # Calculate the relative energies of all spc on the channel chnl_enes = sum_channel_enes(chnl_infs, ref_ene) # Set the hot energies using the relative enes that will be # written into the global key section of MESS input later hot_enes_dct = set_hot_enes(pesgrp_num, reacs, prods, chnl_enes, pes_param_dct, ene_range=None) # Write the mess strings for all spc on the channel mess_strs, dat_str_dct, written_labels = _make_channel_mess_strs( tsname, reacs, prods, pesgrp_num, spc_dct, label_dct, written_labels, pes_param_dct, chnl_infs, chnl_enes, spc_model_dct_i, unstable_chnl=(chnl_idx in unstable_chnls)) # Append to full MESS strings [well_str, bi_str, ts_str] = mess_strs full_well_str += well_str full_bi_str += bi_str full_ts_str += ts_str full_dat_str_dct.update(dat_str_dct) # Combine all the reaction channel strings; remove empty lines rxn_chan_str = '\n'.join([full_well_str, full_bi_str, full_ts_str]) rxn_chan_str = ioformat.remove_empty_lines(rxn_chan_str) return rxn_chan_str, full_dat_str_dct, hot_enes_dct
def make_pes_mess_str(spc_dct, rxn_lst, pes_idx, run_prefix, save_prefix, label_dct, pes_model_dct_i, spc_model_dct_i, spc_model, thy_dct): """ Write all the MESS input file strings for the reaction channels """ ioprinter.messpf('channel_section') # Initialize empty MESS strings full_well_str, full_bi_str, full_ts_str = '', '', '' full_dat_str_dct = {} pes_ene_dct = {} conn_lst = tuple() # Set the energy and model for the first reference species ioprinter.info_message('\nCalculating reference energy for PES') ref_ene = set_reference_ene( rxn_lst, spc_dct, thy_dct, pes_model_dct_i, spc_model_dct_i, run_prefix, save_prefix, ref_idx=0) # Loop over all the channels and write the MESS strings written_labels = [] basis_energy_dct = {} for rxn in rxn_lst: chnl_idx, (reacs, prods) = rxn ioprinter.obj('vspace') ioprinter.reading('PES electrion structure data') ioprinter.channel(chnl_idx, reacs, prods) # Set the TS name and channel model tsname = 'ts_{:g}_{:g}'.format(pes_idx+1, chnl_idx+1) # Obtain all of the species data if spc_model not in basis_energy_dct: basis_energy_dct[spc_model] = {} # Pass in full ts class chnl_infs, chn_basis_ene_dct = get_channel_data( reacs, prods, tsname, spc_dct, basis_energy_dct[spc_model], pes_model_dct_i, spc_model_dct_i, run_prefix, save_prefix) basis_energy_dct[spc_model].update(chn_basis_ene_dct) # Calculate the relative energies of all spc on the channel chnl_enes = sum_channel_enes(chnl_infs, ref_ene) # Write the mess strings for all spc on the channel mess_strs, dat_str_dct, written_labels = _make_channel_mess_strs( tsname, reacs, prods, spc_dct, label_dct, written_labels, chnl_infs, chnl_enes, spc_model_dct_i) # Append to full MESS strings [well_str, bi_str, ts_str] = mess_strs full_well_str += well_str full_bi_str += bi_str full_ts_str += ts_str full_dat_str_dct.update(dat_str_dct) ioprinter.debug_message('rxn', rxn) ioprinter.debug_message('enes', chnl_enes) ioprinter.debug_message('label dct', label_dct) ioprinter.debug_message('written labels', written_labels) # Combine all the reaction channel strings rxn_chan_str = '\n'.join([full_well_str, full_bi_str, full_ts_str]) return rxn_chan_str, full_dat_str_dct, pes_ene_dct, conn_lst
def run(pes_rlst, ktp_tsk_lst, spc_dct, glob_dct, thy_dct, pes_mod_dct, spc_mod_dct, run_prefix, save_prefix): """ main driver for generation of full set of rate constants on a single PES """ # --------------------------------------- # # LOOP OVER ALL OF THE SUBPES in PES_RLST # # --------------------------------------- # for pes_inf, rxn_lst in pes_rlst.items(): # ---------------------------------------------- # # PREPARE INFORMATION TO PASS TO KTPDRIVER TASKS # # ---------------------------------------------- # # Set objects pes_formula, pes_idx, subpes_idx = pes_inf label_dct = None # Print PES Channels that are being run ioprinter.runlst(pes_inf, rxn_lst) # Set paths where files will be written and read mess_path = job_path(run_prefix, 'MESS', 'RATE', pes_formula, locs_idx=subpes_idx) # --------------------------------- # # RUN THE REQUESTED KTPDRIVER TASKS # # --------------------------------- # # Write the MESS file write_rate_tsk = parser.run.extract_task('write_mess', ktp_tsk_lst) if write_rate_tsk is not None: # Get all the info for the task tsk_key_dct = write_rate_tsk[-1] pes_mod = tsk_key_dct['kin_model'] spc_mod = tsk_key_dct['spc_model'] spc_dct, rxn_lst, label_dct = _process(pes_idx, rxn_lst, ktp_tsk_lst, spc_mod_dct, spc_mod, thy_dct, spc_dct, glob_dct, run_prefix, save_prefix) ioprinter.messpf('write_header') mess_inp_str, dats = ktproutines.rates.make_messrate_str( pes_idx, rxn_lst, pes_mod, spc_mod, spc_dct, thy_dct, pes_mod_dct, spc_mod_dct, label_dct, mess_path, run_prefix, save_prefix) autorun.write_input(mess_path, mess_inp_str, aux_dct=dats, input_name='mess.inp') # Run mess to produce rates (currently nothing from tsk lst keys used) run_rate_tsk = parser.run.extract_task('run_mess', ktp_tsk_lst) if run_rate_tsk is not None: ioprinter.obj('vspace') ioprinter.obj('line_dash') ioprinter.running('MESS for the input file', mess_path) autorun.run_script(autorun.SCRIPT_DCT['messrate'], mess_path) # Fit rate output to modified Arrhenius forms, print in ChemKin format run_fit_tsk = parser.run.extract_task('run_fits', ktp_tsk_lst) if run_fit_tsk is not None: # Get all the info for the task tsk_key_dct = run_fit_tsk[-1] spc_mod = tsk_key_dct['spc_model'] pes_mod = tsk_key_dct['kin_model'] ratefit_dct = pes_mod_dct[pes_mod]['rate_fit'] if label_dct is None: spc_dct, rxn_lst, label_dct = _process(pes_idx, rxn_lst, ktp_tsk_lst, spc_mod_dct, spc_mod, thy_dct, spc_dct, run_prefix, save_prefix) ioprinter.obj('vspace') ioprinter.obj('line_dash') ioprinter.info_message( 'Fitting Rate Constants for PES to Functional Forms', newline=1) # Read and fit rates; write to ckin string ratefit_dct = pes_mod_dct[pes_mod]['rate_fit'] ckin_dct = ratefit.fit.fit_ktp_dct( mess_path=mess_path, inp_fit_method=ratefit_dct['fit_method'], pdep_dct=ratefit_dct['pdep_fit'], arrfit_dct=ratefit_dct['arrfit_fit'], chebfit_dct=ratefit_dct['chebfit_fit'], troefit_dct=ratefit_dct['troefit_fit'], label_dct=label_dct, fit_temps=pes_mod_dct[pes_mod]['rate_temps'], fit_pressures=pes_mod_dct[pes_mod]['pressures'], fit_tunit=pes_mod_dct[pes_mod]['temp_unit'], fit_punit=pes_mod_dct[pes_mod]['pressure_unit']) # Write the header part ckin_dct.update( {'header': writer.ckin.model_header((spc_mod, ), spc_mod_dct)}) ckin_path = output_path('CKIN') writer.ckin.write_rxn_file(ckin_dct, pes_formula, ckin_path)
def run(spc_rlst, therm_tsk_lst, pes_mod_dct, spc_mod_dct, spc_dct, run_prefix, save_prefix): """ main driver for thermo run """ # Print Header fo ioprinter.info_message('Calculating Thermochem:') ioprinter.runlst(('SPC', 0, 0), spc_rlst) # ------------------------------------------------ # # PREPARE INFORMATION TO PASS TO THERMDRIVER TASKS # # ------------------------------------------------ # # Build a list of the species to calculate thermochem for loops below spc_mods = list(spc_mod_dct.keys()) # hack split_spc_lst = split_unstable_spc(spc_rlst, spc_dct, spc_mod_dct[spc_mods[0]], save_prefix) spc_queue = parser.rlst.spc_queue('spc', tuple(split_spc_lst.values())[0]) # Build the paths [(messpf, nasa)], models and levels for each spc thm_paths = thermo_paths(spc_dct, spc_queue, spc_mods, run_prefix) # ----------------------------------- # # RUN THE REQUESTED THERMDRIVER TASKS # # ----------------------------------- # # Write and Run MESSPF inputs to generate the partition functions write_messpf_tsk = parser.run.extract_task('write_mess', therm_tsk_lst) if write_messpf_tsk is not None: ioprinter.messpf('write_header') spc_mods, pes_mod = parser.models.extract_models(write_messpf_tsk) for idx, spc_name in enumerate(spc_queue): print('write test {}'.format(spc_name)) for spc_mod in spc_mods: messpf_inp_str = thmroutines.qt.make_messpf_str( pes_mod_dct[pes_mod]['therm_temps'], spc_dct, spc_name, pes_mod_dct[pes_mod], spc_mod_dct[spc_mod], run_prefix, save_prefix) ioprinter.messpf('input_string') ioprinter.info_message(messpf_inp_str) autorun.write_input(thm_paths[idx][spc_mod][0], messpf_inp_str, input_name='pf.inp') # Run the MESSPF files that have been written run_messpf_tsk = parser.run.extract_task('run_mess', therm_tsk_lst) if run_messpf_tsk is not None: spc_mod, pes_mod = parser.models.extract_models(run_messpf_tsk) spc_mods = parser.models.split_model(spc_mod[0]) ioprinter.messpf('run_header') for idx, spc_name in enumerate(spc_queue): _spc_mods, coeffs, operators = spc_mods # Run MESSPF for all requested models, combine the PFS at the end ioprinter.message('Run MESSPF: {}'.format(spc_name), newline=1) _pfs = [] for spc_mod in _spc_mods: autorun.run_script(autorun.SCRIPT_DCT['messpf'], thm_paths[idx][spc_mod][0]) _pfs.append( pfrunner.mess.read_messpf(thm_paths[idx][spc_mod][0])) final_pf = pfrunner.mess.combine_pfs(_pfs, coeffs, operators) # need to clean thm path build tot_idx = len(spc_mods) spc_info = sinfo.from_dct(spc_dct[spc_name]) spc_fml = automol.inchi.formula_string(spc_info[0]) thm_prefix = [spc_fml, automol.inchi.inchi_key(spc_info[0])] thm_paths[idx]['final'] = (job_path(run_prefix, 'MESS', 'PF', thm_prefix, locs_idx=tot_idx), job_path(run_prefix, 'THERM', 'NASA', thm_prefix, locs_idx=tot_idx)) pfrunner.mess.write_mess_output(fstring( spc_dct[spc_name]['inchi']), final_pf, thm_paths[idx]['final'][0], filename='pf.dat') # Use MESS partition functions to compute thermo quantities run_fit_tsk = parser.run.extract_task('run_fits', therm_tsk_lst) if run_fit_tsk is not None: spc_mods, pes_mod = parser.models.extract_models(run_fit_tsk) pes_mod_dct_i = pes_mod_dct[pes_mod] ioprinter.nasa('header') chn_basis_ene_dct = {} for idx, spc_name in enumerate(spc_queue): # Take species model and add it to the chn_basis_ene dct spc_mod = spc_mods[0] spc_mod_dct_i = spc_mod_dct[spc_mod] if spc_mod not in chn_basis_ene_dct: chn_basis_ene_dct[spc_mod] = {} # Get the reference scheme and energies (ref in different place) ref_scheme = pes_mod_dct_i['therm_fit']['ref_scheme'] ref_enes = pes_mod_dct_i['therm_fit']['ref_enes'] # Determine info about the basis species used in thermochem calcs basis_dct, uniref_dct = thmroutines.basis.prepare_refs( ref_scheme, spc_dct, [[spc_name, None]], run_prefix, save_prefix) # Get the basis info for the spc of interest spc_basis, coeff_basis = basis_dct[spc_name] # Get the energies for the spc and its basis ene_basis = [] energy_missing = False for spc_basis_i in spc_basis: if spc_basis_i in chn_basis_ene_dct[spc_mod]: ioprinter.message( 'Energy already found for basis species: ' + spc_basis_i) ene_basis.append(chn_basis_ene_dct[spc_mod][spc_basis_i]) else: ioprinter.message( 'Energy will be determined for basis species: ' + spc_basis_i) energy_missing = True if not energy_missing: pf_filesystems = filesys.models.pf_filesys(spc_dct[spc_name], spc_mod_dct_i, run_prefix, save_prefix, saddle=False) ene_spc = ene.read_energy(spc_dct[spc_name], pf_filesystems, spc_mod_dct_i, run_prefix, read_ene=True, read_zpe=True, saddle=False) else: ene_spc, ene_basis = thmroutines.basis.basis_energy( spc_name, spc_basis, uniref_dct, spc_dct, spc_mod_dct_i, run_prefix, save_prefix) for spc_basis_i, ene_basis_i in zip(spc_basis, ene_basis): chn_basis_ene_dct[spc_mod][spc_basis_i] = ene_basis_i # Calculate and store the 0 K Enthalpy hf0k = thmroutines.heatform.calc_hform_0k(ene_spc, ene_basis, spc_basis, coeff_basis, ref_set=ref_enes) spc_dct[spc_name]['Hfs'] = [hf0k] # Write the NASA polynomials in CHEMKIN format ckin_nasa_str = '' ckin_path = output_path('CKIN') for idx, spc_name in enumerate(spc_queue): ioprinter.nasa('calculate', spc_name) # Write the header describing the models used in thermo calcs ckin_nasa_str += writer.ckin.model_header(spc_mods, spc_mod_dct) # Build and write the NASA polynomial in CHEMKIN-format string # Call dies if you haven't run "write mess" task ckin_nasa_str += thmroutines.nasapoly.build_polynomial( spc_name, spc_dct, thm_paths[idx]['final'][0], thm_paths[idx]['final'][1]) ckin_nasa_str += '\n\n' print(ckin_nasa_str) nasa7_params_all = chemkin_io.parser.thermo.create_spc_nasa7_dct( ckin_nasa_str) # print('ckin_nasa_str test', ckin_nasa_str) ioprinter.info_message( 'SPECIES H(0 K) H(298 K) S(298 K) Cp(300 K) Cp(500 K) Cp(1000 K) Cp(1500 K)\n' ) ioprinter.info_message( ' kcal/mol kcal/mol cal/(mol K) ... \n') for spc_name in nasa7_params_all: nasa7_params = nasa7_params_all[spc_name] whitespace = 18 - len(spc_name) h0 = spc_dct[spc_name]['Hfs'][0] h298 = mechanalyzer.calculator.thermo.enthalpy( nasa7_params, 298.15) / 1000. s298 = mechanalyzer.calculator.thermo.entropy(nasa7_params, 298.15) cp300 = mechanalyzer.calculator.thermo.heat_capacity( nasa7_params, 300) cp500 = mechanalyzer.calculator.thermo.heat_capacity( nasa7_params, 500) cp1000 = mechanalyzer.calculator.thermo.heat_capacity( nasa7_params, 1000) cp1500 = mechanalyzer.calculator.thermo.heat_capacity( nasa7_params, 1500) whitespace = whitespace * ' ' ioprinter.info_message( '{}{}{:>7.2f}{:>9.2f}{:>9.2f}{:>9.2f}{:>9.2f}{:>9.2f}{:>9.2f}'. format(spc_name, whitespace, h0, h298, s298, cp300, cp500, cp1000, cp1500)) # Write all of the NASA polynomial strings writer.ckin.write_nasa_file(ckin_nasa_str, ckin_path)
def run(pes_rlst, spc_rlst, therm_tsk_lst, pes_mod_dct, spc_mod_dct, spc_dct, run_prefix, save_prefix): """ Executes all thermochemistry tasks. :param pes_rlst: species from PESs to run [(PES formula, PES idx, SUP-PES idx) (CHANNEL idx, (REACS, PRODS)) :type pes_rlst: tuple(dict[str: dict]) :param spc_rlst: lst of species to run :type spc_rlst: tuple(dict[str: dict]) :param es_tsk_lst: list of the electronic structure tasks tuple(tuple(obj, tsk, keyword_dict)) :type es_tsk_lst: tuple(tuple(str, str, dict)) :param spc_dct: species information dict[spc_name: spc_information] :type spc_dct: dict[str:dict] :param glob_dct: global information for all species dict[spc_name: spc_information] :type glob_dct: dict[str: dict] :param thy_dct: all of the theory information dict[thy name: inf] :type thy_dct: dict[str:dict] :param run_prefix: root-path to the run-filesystem :type run_prefix: str :param save_prefix: root-path to the save-filesystem :type save_prefix: str """ # Print Header ioprinter.info_message('Calculating Thermochem:') ioprinter.runlst(('SPC', 0, 0), spc_rlst) # ------------------------------------------------ # # PREPARE INFORMATION TO PASS TO THERMDRIVER TASKS # # ------------------------------------------------ # # Build a list of the species to calculate thermochem for loops below spc_mods = list(spc_mod_dct.keys()) # hack spc_mod_dct_i = spc_mod_dct[spc_mods[0]] split_rlst = split_unstable_full( pes_rlst, spc_rlst, spc_dct, spc_mod_dct_i, save_prefix) spc_queue = parser.rlst.spc_queue( tuple(split_rlst.values())[0], 'SPC') # Build the paths [(messpf, nasa)], models and levels for each spc thm_paths = thermo_paths(spc_dct, spc_queue, spc_mods, run_prefix) # ----------------------------------- # # RUN THE REQUESTED THERMDRIVER TASKS # # ----------------------------------- # # Write and Run MESSPF inputs to generate the partition functions write_messpf_tsk = parser.run.extract_task('write_mess', therm_tsk_lst) if write_messpf_tsk is not None: ioprinter.messpf('write_header') spc_mods, pes_mod = parser.models.extract_models(write_messpf_tsk) for idx, spc_name in enumerate(spc_queue): print('write test {}'.format(spc_name)) for spc_mod in spc_mods: messpf_inp_str = thmroutines.qt.make_messpf_str( pes_mod_dct[pes_mod]['therm_temps'], spc_dct, spc_name, pes_mod_dct[pes_mod], spc_mod_dct[spc_mod], run_prefix, save_prefix) ioprinter.messpf('input_string') ioprinter.info_message(messpf_inp_str) autorun.write_input( thm_paths[idx][spc_mod][0], messpf_inp_str, input_name='pf.inp') # Run the MESSPF files that have been written run_messpf_tsk = parser.run.extract_task('run_mess', therm_tsk_lst) if run_messpf_tsk is not None: spc_mod, pes_mod = parser.models.extract_models(run_messpf_tsk) spc_mods = parser.models.split_model(spc_mod[0]) ioprinter.messpf('run_header') for idx, spc_name in enumerate(spc_queue): _spc_mods, coeffs, operators = spc_mods # Run MESSPF for all requested models, combine the PFS at the end ioprinter.message('Run MESSPF: {}'.format(spc_name), newline=1) _pfs = [] for spc_mod in _spc_mods: autorun.run_script( autorun.SCRIPT_DCT['messpf'], thm_paths[idx][spc_mod][0]) _pfs.append( reader.mess.messpf(thm_paths[idx][spc_mod][0])) final_pf = thermfit.pf.combine(_pfs, coeffs, operators) # need to clean thm path build tdx = len(spc_mods) spc_info = sinfo.from_dct(spc_dct[spc_name]) spc_fml = automol.inchi.formula_string(spc_info[0]) thm_prefix = [spc_fml, automol.inchi.inchi_key(spc_info[0])] thm_paths[idx]['final'] = ( job_path(run_prefix, 'MESS', 'PF', thm_prefix, locs_idx=tdx), job_path(run_prefix, 'THERM', 'NASA', thm_prefix, locs_idx=tdx) ) writer.mess.output( fstring(spc_dct[spc_name]['inchi']), final_pf, thm_paths[idx]['final'][0], filename='pf.dat') # Use MESS partition functions to compute thermo quantities run_fit_tsk = parser.run.extract_task('run_fits', therm_tsk_lst) if run_fit_tsk is not None: spc_mods, pes_mod = parser.models.extract_models(run_fit_tsk) pes_mod_dct_i = pes_mod_dct[pes_mod] ioprinter.nasa('header') chn_basis_ene_dct = {} for idx, spc_name in enumerate(spc_queue): # Take species model and add it to the chn_basis_ene dct spc_mod = spc_mods[0] spc_mod_dct_i = spc_mod_dct[spc_mod] if spc_mod not in chn_basis_ene_dct: chn_basis_ene_dct[spc_mod] = {} # Get the reference scheme and energies (ref in different place) ref_scheme = pes_mod_dct_i['therm_fit']['ref_scheme'] ref_enes = pes_mod_dct_i['therm_fit']['ref_enes'] # Determine info about the basis species used in thermochem calcs basis_dct, uniref_dct = thermfit.prepare_refs( ref_scheme, spc_dct, (spc_name,)) # Get the basis info for the spc of interest spc_basis, coeff_basis = basis_dct[spc_name] # Get the energies for the spc and its basis ene_basis = [] energy_missing = False for spc_basis_i in spc_basis: if spc_basis_i in chn_basis_ene_dct[spc_mod]: ioprinter.message( 'Energy already found for basis species: ' + spc_basis_i) ene_basis.append(chn_basis_ene_dct[spc_mod][spc_basis_i]) else: ioprinter.message( 'Energy will be determined for basis species: ' + spc_basis_i) energy_missing = True if not energy_missing: pf_filesystems = filesys.models.pf_filesys( spc_dct[spc_name], spc_mod_dct_i, run_prefix, save_prefix, saddle=False) ene_spc = ene.read_energy( spc_dct[spc_name], pf_filesystems, spc_mod_dct_i, run_prefix, read_ene=True, read_zpe=True, saddle=False) else: ene_spc, ene_basis = thmroutines.basis.basis_energy( spc_name, spc_basis, uniref_dct, spc_dct, spc_mod_dct_i, run_prefix, save_prefix) for spc_basis_i, ene_basis_i in zip(spc_basis, ene_basis): chn_basis_ene_dct[spc_mod][spc_basis_i] = ene_basis_i # Calculate and store the 0 K Enthalpy hf0k = thermfit.heatform.calc_hform_0k( ene_spc, ene_basis, spc_basis, coeff_basis, ref_set=ref_enes) spc_dct[spc_name]['Hfs'] = [hf0k] # Write the NASA polynomials in CHEMKIN format ckin_nasa_str = '' ckin_path = output_path('CKIN') for idx, spc_name in enumerate(spc_queue): ioprinter.nasa('calculate', spc_name) # Write the header describing the models used in thermo calcs ckin_nasa_str += writer.ckin.model_header(spc_mods, spc_mod_dct) # Build and write the NASA polynomial in CHEMKIN-format string # Call dies if you haven't run "write mess" task ckin_nasa_str += thmroutines.nasapoly.build_polynomial( spc_name, spc_dct, thm_paths[idx]['final'][0], thm_paths[idx]['final'][1]) ckin_nasa_str += '\n\n' print('CKIN NASA STR\n') print(ckin_nasa_str) nasa7_params_all = chemkin_io.parser.thermo.create_spc_nasa7_dct( ckin_nasa_str) ioprinter.info_message( 'SPECIES\t\tH(0 K)[kcal/mol]\tH(298 K)[kcal/mol]\t' + 'S(298 K)[cal/mol K]\n') for spc_name in nasa7_params_all: nasa7_params = nasa7_params_all[spc_name] ht0 = spc_dct[spc_name]['Hfs'][0] ht298 = mechanalyzer.calculator.thermo.enthalpy( nasa7_params, 298.15) st298 = mechanalyzer.calculator.thermo.entropy( nasa7_params, 298.15) ioprinter.info_message( '{}\t{:3.2f}\t{:3.2f}\t{:3.2f}'.format( spc_name, ht0, ht298/1000., st298)) # Write all of the NASA polynomial strings writer.ckin.write_nasa_file(ckin_nasa_str, ckin_path)
def run(pes_rlst, ktp_tsk_lst, spc_dct, glob_dct, pes_mod_dct, spc_mod_dct, run_prefix, save_prefix): """ Executes all kinetics tasks. :param pes_rlst: species from PESs to run [(PES formula, PES idx, SUP-PES idx) (CHANNEL idx, (REACS, PRODS)) :type pes_rlst: tuple(dict[str: dict]) :param spc_rlst: lst of species to run :type spc_rlst: tuple(dict[str: dict]) :param es_tsk_lst: list of the electronic structure tasks tuple(tuple(obj, tsk, keyword_dict)) :type es_tsk_lst: tuple(tuple(str, str, dict)) :param spc_dct: species information dict[spc_name: spc_information] :type spc_dct: dict[str:dict] :param glob_dct: global information for all species dict[spc_name: spc_information] :type glob_dct: dict[str: dict] :param thy_dct: all of the theory information dict[thy name: inf] :type thy_dct: dict[str:dict] :param run_prefix: root-path to the run-filesystem :type run_prefix: str :param save_prefix: root-path to the save-filesystem :type save_prefix: str """ # --------------------------------------- # # LOOP OVER ALL OF THE SUBPES in PES_RLST # # --------------------------------------- # for pes_inf, rxn_lst in pes_rlst.items(): # ---------------------------------------------- # # PREPARE INFORMATION TO PASS TO KTPDRIVER TASKS # # ---------------------------------------------- # # Set objects pes_formula, pes_idx, subpes_idx = pes_inf label_dct = None # Print PES Channels that are being run ioprinter.runlst(pes_inf, rxn_lst) # Set paths where files will be written and read mess_path = job_path(run_prefix, 'MESS', 'RATE', pes_formula, locs_idx=subpes_idx) # --------------------------------- # # RUN THE REQUESTED KTPDRIVER TASKS # # --------------------------------- # # Write the MESS file write_rate_tsk = parser.run.extract_task('write_mess', ktp_tsk_lst) if write_rate_tsk is not None: # Get all the info for the task tsk_key_dct = write_rate_tsk[-1] pes_mod = tsk_key_dct['kin_model'] spc_mod = tsk_key_dct['spc_model'] spc_dct, rxn_lst, instab_chnls, label_dct = _process( pes_idx, rxn_lst, ktp_tsk_lst, spc_mod_dct, spc_mod, spc_dct, glob_dct, run_prefix, save_prefix) ioprinter.messpf('write_header') # Doesn't give full string mess_inp_str, dats = ktproutines.rates.make_messrate_str( pes_idx, rxn_lst, pes_mod, spc_mod, spc_dct, pes_mod_dct, spc_mod_dct, instab_chnls, label_dct, mess_path, run_prefix, save_prefix, make_lump_well_inp=tsk_key_dct['lump_wells']) autorun.write_input(mess_path, mess_inp_str, aux_dct=dats, input_name='mess.inp') # Run mess to produce rates (currently nothing from tsk lst keys used) run_rate_tsk = parser.run.extract_task('run_mess', ktp_tsk_lst) if run_rate_tsk is not None: ioprinter.obj('vspace') ioprinter.obj('line_dash') ioprinter.running('MESS for the input file', mess_path) autorun.run_script(autorun.SCRIPT_DCT['messrate'], mess_path) # Fit rate output to modified Arrhenius forms, print in ChemKin format run_fit_tsk = parser.run.extract_task('run_fits', ktp_tsk_lst) if run_fit_tsk is not None: # Get all the info for the task tsk_key_dct = run_fit_tsk[-1] spc_mod = tsk_key_dct['spc_model'] pes_mod = tsk_key_dct['kin_model'] ratefit_dct = pes_mod_dct[pes_mod]['rate_fit'] if label_dct is None: spc_dct, rxn_lst, _, label_dct = _process( pes_idx, rxn_lst, ktp_tsk_lst, spc_mod_dct, spc_mod, spc_dct, glob_dct, run_prefix, save_prefix) ioprinter.obj('vspace') ioprinter.obj('line_dash') ioprinter.info_message( 'Fitting Rate Constants for PES to Functional Forms', newline=1) # Read and fit rates; write to ckin string ratefit_dct = pes_mod_dct[pes_mod]['rate_fit'] ckin_dct = ratefit.fit.fit_ktp_dct( mess_path=mess_path, inp_fit_method=ratefit_dct['fit_method'], pdep_dct=ratefit_dct['pdep_fit'], arrfit_dct=ratefit_dct['arrfit_fit'], chebfit_dct=ratefit_dct['chebfit_fit'], troefit_dct=ratefit_dct['troefit_fit'], label_dct=label_dct, fit_temps=pes_mod_dct[pes_mod]['rate_temps'], fit_pressures=pes_mod_dct[pes_mod]['pressures'], fit_tunit=pes_mod_dct[pes_mod]['temp_unit'], fit_punit=pes_mod_dct[pes_mod]['pressure_unit']) # Write the header part ckin_dct.update( {'header': writer.ckin.model_header((spc_mod, ), spc_mod_dct)}) ckin_path = output_path('CKIN') writer.ckin.write_rxn_file(ckin_dct, pes_formula, ckin_path)