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 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(spc_dct,
pes_model_dct,
spc_model_dct,
thy_dct,
rxn_lst,
run_inp_dct,
write_messpf=True,
run_messpf=True,
run_nasa=True):
""" main driver for thermo run
"""
# Pull stuff from dcts for now
save_prefix = run_inp_dct['save_prefix']
run_prefix = run_inp_dct['run_prefix']
# Build a list of the species to calculate thermochem for loops below
# Set reaction list with unstable species broken apart
# print('Checking stability of all species...')
# rxn_lst = instab.break_all_unstable2(
# rxn_lst, spc_dct, spc_model_dct, thy_dct, save_prefix)
spc_queue = parser.species.build_queue(rxn_lst)
spc_queue = parser.species.split_queue(spc_queue)
# Build the paths [(messpf, nasa)], models and levels for each spc
starting_path = os.getcwd()
ckin_path = os.path.join(starting_path, 'ckin')
thm_paths = []
for spc_name, (_, mods, _, _) in spc_queue:
thm_path = {}
for idx, mod in enumerate(mods):
thm_path[mod] = pfrunner.thermo_paths(spc_dct[spc_name],
run_prefix, idx)
thm_paths.append(thm_path)
pf_levels = {}
pf_models = {}
for _, (_, mods, _, _) in spc_queue:
for mod in mods:
pf_levels[mod] = pf_level_info(spc_model_dct[mod]['es'], thy_dct)
pf_models[mod] = pf_model_info(spc_model_dct[mod]['pf'])
pf_models[mod]['ref_scheme'] = (
spc_model_dct[mod]['options']['ref_scheme']
if 'ref_scheme' in spc_model_dct[mod]['options'] else 'none')
pf_models[mod]['ref_enes'] = (
spc_model_dct[mod]['options']['ref_enes']
if 'ref_enes' in spc_model_dct[mod]['options'] else 'none')
# Write and Run MESSPF inputs to generate the partition functions
if write_messpf:
print(('\n\n------------------------------------------------' +
'--------------------------------------'))
print('\nPreparing MESSPF input files for all species')
pf_paths = {}
for idx, (spc_name, (pes_model, spc_models, _,
_)) in enumerate(spc_queue):
pf_paths[idx] = {}
for spc_model in spc_models:
print('spc_model', spc_model)
global_pf_str = thmroutines.qt.make_pf_header(
pes_model_dct[pes_model]['therm_temps'])
spc_str, dat_str_dct = thmroutines.qt.make_spc_mess_str(
spc_dct, spc_name, pf_models[spc_model],
pf_levels[spc_model], run_prefix, save_prefix)
messpf_inp_str = thmroutines.qt.make_messpf_str(
global_pf_str, spc_str)
print('\n\n')
print('MESSPF Input String:\n')
print('\n\n')
pfrunner.mess.write_mess_file(messpf_inp_str,
dat_str_dct,
thm_paths[idx][spc_model][0],
filename='pf.inp')
# Write MESS file into job directory
cpy_path = pfrunner.write_cwd_pf_file(
messpf_inp_str, spc_dct[spc_name]['inchi'])
pf_paths[idx][spc_model] = cpy_path
# Run the MESSPF files that have been written
if run_messpf:
print(('\n\n------------------------------------------------' +
'--------------------------------------'))
print('\nRunning MESSPF calculations for all species')
for idx, (spc_name, (pes_model, spc_models, coeffs,
operators)) in enumerate(spc_queue):
print('\n{}'.format(spc_name))
for midx, spc_model in enumerate(spc_models):
pfrunner.run_pf(thm_paths[idx][spc_model][0])
temps, logq, dq_dt, d2q_dt2 = pfrunner.mess.read_messpf(
thm_paths[idx][spc_model][0])
if midx == 0:
coeff = coeffs[midx]
final_pf = [temps, logq, dq_dt, d2q_dt2]
else:
pf2 = temps, logq, dq_dt, d2q_dt2
coeff = coeffs[midx]
operator = operators[midx - 1]
if coeff < 0:
coeff = abs(coeff)
if operator == 'multiply':
operator = 'divide'
if operator == 'divide':
pfrunner.mess.divide_pfs(final_pf, pf2, coeff)
elif operator == 'multiply':
pfrunner.mess.multiply_pfs(final_pf, pf2, coeff)
thm_paths[idx]['final'] = pfrunner.thermo_paths(
spc_dct[spc_name], run_prefix, len(spc_models))
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
if run_nasa:
print(('\n\n------------------------------------------------' +
'--------------------------------------'))
print('\nRunning Thermochemistry calculations for all species')
chn_basis_ene_dct = {}
for idx, (spc_name, (pes_model, spc_models, _,
_)) in enumerate(spc_queue):
print('\n{}'.format(spc_name))
spc_model = spc_models[0]
if not spc_model in chn_basis_ene_dct:
chn_basis_ene_dct[spc_model] = {}
# Get the reference scheme and energies
ref_scheme = spc_model_dct[spc_model]['options']['ref_scheme']
ref_enes = spc_model_dct[spc_model]['options']['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]])
# 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_model]:
print('Energy already found for basis species: ',
spc_basis_i)
ene_basis.append(chn_basis_ene_dct[spc_model][spc_basis_i])
else:
print('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],
pf_levels[spc_model],
run_prefix,
save_prefix,
saddle=False)
ene_spc = ene.read_energy(spc_dct[spc_name],
pf_filesystems,
pf_models[spc_model],
pf_levels[spc_model],
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,
pf_levels[spc_model], pf_models[spc_model], run_prefix,
save_prefix)
for spc_basis_i, ene_basis_i in zip(spc_basis, ene_basis):
chn_basis_ene_dct[spc_model][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 = os.path.join(starting_path, 'ckin')
for idx, (spc_name, (pes_model, spc_models, _,
_)) in enumerate(spc_queue):
print("\n\nStarting NASA polynomials calculation for ", spc_name)
# Read the temperatures from the pf.dat file, check if viable
temps = pfrunner.read_messpf_temps(thm_paths[idx]['final'][0])
thmroutines.nasapoly.print_nasa_temps(temps)
# Write the NASA polynomial in CHEMKIN-format string
ref_scheme = spc_model_dct[spc_model]['options']['ref_scheme']
for spc_model in spc_models:
ckin_nasa_str += writer.ckin.model_header(pf_levels[spc_model],
pf_models[spc_model],
refscheme=ref_scheme)
# Build POLY
ckin_nasa_str += thmroutines.nasapoly.build_polynomial(
spc_name, spc_dct, temps, thm_paths[idx]['final'][0],
thm_paths[idx]['final'][1], starting_path)
ckin_nasa_str += '\n\n'
# Write all of the NASA polynomial strings
writer.ckin.write_nasa_file(ckin_nasa_str, 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)