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 run_messrate_task(rate_paths_dct, pes_inf):
""" Run the MESSRATE input file.
First tries to run a well-extended file, then tries to
run the base file if it exists.
Need an overwrite task
"""
path_dct = rate_paths_dct[pes_inf]
for typ in ('wext', 'base'):
path = path_dct[typ]
mess_inp = os.path.join(path, 'mess.inp')
mess_out = os.path.join(path, 'mess.out')
if os.path.exists(mess_inp) and not os.path.exists(mess_out):
ioprinter.obj('vspace')
ioprinter.obj('line_dash')
ioprinter.info_message(f'Found MESS input file at {path}')
ioprinter.running('MESS input file')
autorun.run_script(autorun.SCRIPT_DCT['messrate'], path)
break
def partition_function(spc_name, spc_dct_i, spc_mod_dct_i, pes_mod_dct_i, locs,
locs_path, cnf_fs, run_prefix, save_prefix):
""" collect enthalpies
"""
messpf_inp_str, dat_str_dct, miss_data = messpf_input(
spc_name, spc_dct_i, spc_mod_dct_i, pes_mod_dct_i, locs, locs_path,
cnf_fs, run_prefix, save_prefix)
# Combine the strings together to create full MESS input file string
# tempfile.tempdir = "./messpf_temp"
# file_path = (
# '/home/elliott/projects/AutoMech/RO2QOOH/all_conformers/all/temp')
with tempfile.TemporaryDirectory() as file_path:
autorun.write_input(file_path,
messpf_inp_str,
aux_dct=dat_str_dct,
input_name='pf.inp')
autorun.run_script(autorun.SCRIPT_DCT['messpf'], file_path)
pf_arrays = reader.mess.messpf(file_path)
return (pf_arrays, miss_data)
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 _runlj(nsamp_needed, lj_info, lj_mod_thy_info, tgt_mod_thy_info,
bath_mod_thy_info, tgt_cnf_save_fs, bath_cnf_save_fs, etrans_run_fs,
etrans_locs, etrans_keyword_dct):
""" Run the Lennard-Jones parameters
"""
# Pull stuff from dct
njobs = etrans_keyword_dct['njobs']
smin = etrans_keyword_dct['smin']
smax = etrans_keyword_dct['smax']
conf = etrans_keyword_dct['conf']
# Determine the number of samples per job
nsamp_per_job = nsamp_needed // njobs
# Set the path to the executable
onedmin_exe_path = '/lcrc/project/CMRP/amech/OneDMin/build'
# Obtain the geometry for the target and bath
tgt_geo = geom.get_geometry(tgt_cnf_save_fs, tgt_mod_thy_info, conf=conf)
bath_geo = geom.get_geometry(bath_cnf_save_fs,
bath_mod_thy_info,
conf=conf)
# Set the path to the etrans lead fs
etrans_run_path = etrans_run_fs[-1].path(etrans_locs)
# Build the run directory
onedmin_run_path = lj_runner.build_rundir(etrans_run_path)
# Run an instancw of 1DMin for each processor
for idx in range(njobs):
# Build run directory
onedmin_job_path = lj_runner.make_jobdir(onedmin_run_path, idx)
# Write the input files
xyz1_str, xyz2_str = lj_runner.write_xyz(tgt_geo, bath_geo)
elstruct_inp_str, elstruct_sub_str = lj_runner.write_elstruct_inp(
lj_info, lj_mod_thy_info)
onedmin_str = lj_runner.write_input(nsamp_per_job,
smin=smin,
smax=smax,
target_name='target.xyz',
bath_name='bath.xyz')
input_strs = (xyz1_str, xyz2_str, elstruct_inp_str, elstruct_sub_str,
onedmin_str)
input_names = ('target.xyz', 'bath.xyz', 'qc.mol', 'ene.x',
'input.dat')
inp = tuple(zip(input_strs, input_names))
amech_io.writer.write_files(inp, onedmin_job_path, exe_names=('ene.x'))
# Write the batch submission script for each instance
onedmin_sub_str = lj_runner.write_onedmin_sub(
njobs,
onedmin_run_path,
onedmin_exe_path,
exe_name='onedmin-dd-molpro.x')
sub_inp = ((onedmin_sub_str, 'build.sh'), )
amech_io.writer.write_files(sub_inp,
onedmin_run_path,
exe_names=('build.sh'))
# Submit the all of the OneDMin jobs
ioprinter.info_message('Running each OneDMin job...', newline=2)
run_script(onedmin_sub_str, onedmin_run_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)
def write_messrate_task(pesgrp_num, pes_inf, rxn_lst, tsk_key_dct,
pes_param_dct, spc_dct, thy_dct, pes_model_dct,
spc_model_dct, unstab_chnls, label_dct, rate_paths_dct,
run_prefix, save_prefix):
""" Reads and processes all information in the save filesys for
all species on the PES that are required for MESS rate calculations,
as specified by the model dictionaries built from user input.
:param pes_idx:
:type pes_idx: int
:param rxn_lst:
:type rxn_lst:
:param pes_model: model for PES conditions for rates from user input
:type pes_model: str
:param spc_model: model for partition fxns for rates from user input
:type spc_model: str
:param mess_path: path to write mess file (change since pfx given?)
"""
_, pes_idx, _ = pes_inf
pes_mod = tsk_key_dct['kin_model']
spc_mod = tsk_key_dct['spc_model']
pes_model_dct_i = pes_model_dct[pes_mod]
spc_model_dct_i = spc_model_dct[spc_mod]
# Write the MESS strings for all the PES channels
rxn_chan_str, dats, hot_enes_dct = make_pes_mess_str(
spc_dct, rxn_lst, pes_idx, pesgrp_num, unstab_chnls, run_prefix,
save_prefix, label_dct, tsk_key_dct, pes_param_dct, thy_dct,
pes_model_dct_i, spc_model_dct_i, spc_mod)
# Write the strings for the MESS input file
globkey_str = make_header_str(spc_dct, rxn_lst, pes_idx, pesgrp_num,
pes_param_dct, hot_enes_dct, label_dct,
pes_model_dct_i['rate_temps'],
pes_model_dct_i['pressures'],
tsk_key_dct['float_precision'])
# Write the energy transfer section strings for MESS file
etransfer = pes_model_dct_i['glob_etransfer']
energy_trans_str = make_global_etrans_str(rxn_lst, spc_dct, etransfer)
# Write base MESS input string into the RUN filesystem
mess_inp_str = mess_io.writer.messrates_inp_str(
globkey_str,
rxn_chan_str,
energy_trans_str=energy_trans_str,
well_lump_str=None)
base_mess_path = rate_paths_dct[pes_inf]['base']
ioprinter.obj('line_plus')
ioprinter.writing('MESS input file', base_mess_path)
ioprinter.debug_message('MESS Input:\n\n' + mess_inp_str)
autorun.write_input(base_mess_path,
mess_inp_str,
aux_dct=dats,
input_name='mess.inp')
# Write the second MESS string (well extended), if needed
if use_well_extension(spc_dct, rxn_lst, pes_idx,
tsk_key_dct['use_well_extension']):
print('User requested well extension scheme for rates...')
# Run the base MESSRATE
autorun.run_script(autorun.SCRIPT_DCT['messrate'], base_mess_path)
# Write the well-extended MESSRATE file
print('Reading the input and output from the base MESSRATE run...')
inp_str = ioformat.read_file(base_mess_path, 'mess.inp')
out_str = ioformat.read_file(base_mess_path, 'mess.out')
aux_str = ioformat.read_file(base_mess_path, 'mess.aux')
log_str = ioformat.read_file(base_mess_path, 'mess.log')
print('Setting up the well-extended MESSRATE input...')
wext_mess_inp_str = ratefit.fit.well_lumped_input_file(
inp_str, out_str, aux_str, log_str,
pes_model_dct_i['well_extension_pressure'],
pes_model_dct_i['well_extension_temp'])
wext_mess_path = rate_paths_dct[pes_inf]['wext']
ioprinter.obj('line_plus')
ioprinter.writing('MESS input file', base_mess_path)
ioprinter.debug_message('MESS Input:\n\n' + mess_inp_str)
autorun.write_input(wext_mess_path,
wext_mess_inp_str,
aux_dct=dats,
input_name='mess.inp')