def nasa_polynomial_task(mdriver_path, spc_locs_dct, thm_paths_dct, spc_dct, spc_mod_dct, spc_mods, sort_info_lst, ref_scheme): """ generate the nasa polynomials """ ckin_nasa_str_dct = {} ckin_nasa_str_dct[0] = '' ckin_path = output_path('CKIN', prefix=mdriver_path) for spc_name in spc_locs_dct: for idx, spc_locs in enumerate(spc_locs_dct[spc_name], start=1): if idx not in ckin_nasa_str_dct: ckin_nasa_str_dct[idx] = '' spc_locs = tuple(spc_locs) ioprinter.nasa('calculate', spc_name) # for spc_mod in spc_mods: # ioprinter.message('for: ', spc_locs, spc_mod) # # Write the header describing the models used in thermo calcs # ckin_nasa_str += writer.ckin.model_header( # [spc_mod], spc_mod_dct, refscheme=ref_scheme) # # Build and write NASA polynomial in CHEMKIN-format string # # Call dies if you haven't run "write mess" task # ckin_nasa_str += nasapoly.build_polynomial( # spc_name, spc_dct, # thm_paths_dct[spc_name][tuple(spc_locs)][spc_mod][0], # thm_paths_dct[spc_name][tuple(spc_locs)][spc_mod][1], # spc_locs=spc_locs, spc_mod=spc_mod) # ckin_nasa_str += '\n\n' ioprinter.message('for: ', spc_locs, ' combined models') ckin_nasa_str_dct[idx] += writer.ckin.model_header( spc_mods, spc_mod_dct, sort_info_lst=sort_info_lst, refscheme=ref_scheme) ckin_nasa_str_dct[idx] += nasapoly.build_polynomial( spc_name, spc_dct, thm_paths_dct[spc_name][tuple(spc_locs)]['mod_total'][0], thm_paths_dct[spc_name][tuple(spc_locs)]['mod_total'][1], spc_locs_idx=idx - 1, spc_mod=','.join(spc_mods)) ckin_nasa_str_dct[idx] += '\n\n' ioprinter.info_message('CKIN NASA STR\n') ioprinter.info_message(ckin_nasa_str_dct[idx]) ioprinter.message('for combined rid cids:', spc_locs_dct[spc_name]) ckin_nasa_str_dct[0] += writer.ckin.model_header( spc_mods, spc_mod_dct, sort_info_lst=sort_info_lst, refscheme=ref_scheme) ckin_nasa_str_dct[0] += nasapoly.build_polynomial( spc_name, spc_dct, thm_paths_dct[spc_name]['spc_total'][0], thm_paths_dct[spc_name]['spc_total'][1], spc_locs_idx='final', spc_mod=','.join(spc_mods)) ckin_nasa_str_dct[0] += '\n\n' ioprinter.info_message('CKIN NASA STR\n') ioprinter.info_message(ckin_nasa_str_dct[0]) return ckin_nasa_str_dct, ckin_path
def run_fits_task(pes_grp_rlst, pes_param_dct, rate_paths_dct, mdriver_path, label_dct, pes_mod_dct, spc_mod_dct, thy_dct, tsk_key_dct): """ Run the fits and potentially assume that the rate_paths_dct will come in with all PESs in group """ # Combine all PESs into a string for writing the CKIN file pes_strs = () for pes_inf in pes_grp_rlst.keys(): _inf = (pes_inf[0], str(pes_inf[1] + 1), str(pes_inf[2] + 1)) pes_strs += ('_'.join(_inf), ) tot_fml = '-'.join(pes_strs) # Get the model and sort info from tsk key dct pes_mod = tsk_key_dct['kin_model'] spc_mod = tsk_key_dct['spc_model'] sort_info_lst = filesys.mincnf.sort_info_lst(tsk_key_dct['sort'], thy_dct) ioprinter.obj('vspace') ioprinter.obj('line_dash') # Obtain the rate constants from the MESS files ioprinter.info_message('Reading Rate Constants from MESS outputs', newline=1) rxn_ktp_dct = obtain_multipes_rxn_ktp_dct(rate_paths_dct, pes_param_dct, label_dct, pes_mod_dct, pes_mod) # Fit the rate constants ioprinter.info_message( 'Fitting Rate Constants for PES to Functional Forms', newline=1) ratefit_dct = pes_mod_dct[pes_mod]['rate_fit'] rxn_param_dct, rxn_err_dct = ratefit.fit.fit_rxn_ktp_dct( rxn_ktp_dct, 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'], ) # Write the reactions block header, which contains model info rxn_block_cmt = writer.ckin.model_header( (spc_mod, ), spc_mod_dct, sort_info_lst=sort_info_lst, refscheme=pes_mod_dct[pes_mod]['therm_fit']['ref_scheme']) # Get the comments dct and write the Chemkin string rxn_cmts_dct = chemkin_io.writer.comments.get_rxn_cmts_dct( rxn_err_dct=rxn_err_dct, rxn_block_cmt=rxn_block_cmt) ckin_str = chemkin_io.writer.mechanism.write_chemkin_file( rxn_param_dct=rxn_param_dct, rxn_cmts_dct=rxn_cmts_dct) # Write the file ckin_path = output_path('CKIN', prefix=mdriver_path) ckin_filename = f'{tot_fml}.ckin' ioformat.pathtools.write_file(ckin_str, ckin_path, ckin_filename)
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)