def set_model_filesys(thy_save_fs, spc_info, level, saddle=False):
""" Gets filesystem objects for torsional calculations
"""
# Set the level for the model
levelp = level[0:3]
levelp.append(fsorb.orbital_restriction(spc_info, level))
# Get the save fileystem path
save_path = thy_save_fs.leaf.path(levelp[1:4])
if saddle:
save_fs = autofile.fs.ts(save_path)
save_fs.trunk.create()
save_path = save_fs.trunk.path()
# Get the fs object and the locs
cnf_save_fs = autofile.fs.conformer(save_path)
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
# Get the save path for the conformers
if min_cnf_locs:
cnf_save_path = cnf_save_fs.leaf.path(min_cnf_locs)
else:
cnf_save_path = ''
return cnf_save_fs, cnf_save_path, min_cnf_locs, save_path
def assess_pf_convergence(save_prefix, temps=(300., 500., 750., 1000., 1500.)):
""" Determine how much the partition function has converged
"""
# Get the energy of the mininimum-energy conformer
cnf_save_fs = autofile.fs.conformer(save_prefix)
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
if min_cnf_locs:
ene_ref = cnf_save_fs.leaf.file.energy.read(min_cnf_locs)
# Calculate sigma values at various temperatures for the PF
tau_save_fs = autofile.fs.tau(save_prefix)
for temp in temps:
sumq = 0.
sum2 = 0.
idx = 0
print('integral convergence for T = ', temp)
for locs in tau_save_fs.leaf.existing():
idx += 1
ene = tau_save_fs.leaf.file.energy.read(locs)
ene = (ene - ene_ref) * phycon.EH2KCAL
tmp = numpy.exp(-ene*349.7/(0.695*temp))
sumq = sumq + tmp
sum2 = sum2 + tmp**2
sigma = numpy.sqrt(
(abs(sum2/float(idx)-(sumq/float(idx))**2))/float(idx))
print(sumq/float(idx), sigma, 100.*sigma*float(idx)/sumq, idx)
def geometry_analysis(tsk,
thy_level,
ini_filesys,
spc,
overwrite,
saddle=False,
selection='min'):
""" run the specified electronic structure task
for a set of geometries
"""
params = {}
spc_info = finf.get_spc_info(spc)
print('Task:', tsk)
if 'conf' in tsk:
run_dir = ini_filesys[2]
save_dir = ini_filesys[3]
elif 'tau' in tsk:
run_dir = ini_filesys[4]
save_dir = ini_filesys[5]
elif 'hr' in tsk:
run_dir = ini_filesys[6]
save_dir = ini_filesys[7]
if saddle:
params['frm_bnd_key'] = spc['frm_bnd_key']
params['brk_bnd_key'] = spc['brk_bnd_key']
print('key test in ts_geom anal:', params['frm_bnd_key'],
params['brk_bnd_key'])
else:
return
if isinstance(selection, str):
if selection == 'all':
locs_lst = save_dir.leaf.existing()
elif selection == 'min':
locs_lst = [fsmin.min_energy_conformer_locators(save_dir)]
else:
locs_lst = selection
sp_script_str, _, kwargs, _ = runpar.run_qchem_par(*thy_level[0:2])
params['spc_info'] = spc_info
params['thy_level'] = thy_level
params['script_str'] = sp_script_str
params['overwrite'] = overwrite
# cycle over the locations
if tsk in ES_TSKS:
task_call = eval(ES_TSKS[tsk])
for locs in locs_lst:
if locs:
params['geo_run_fs'] = run_dir
params['geo_save_fs'] = save_dir
params['locs'] = locs
task_call(params, kwargs)
else:
print('No initial geometry available for {} on {}'.format(
spc_info[0], '/'.join(thy_level[1:3])))
def get_high_level_energy(spc_info,
thy_low_level,
thy_high_level,
save_prefix,
saddle=False):
""" get high level energy at low level optimized geometry
"""
if saddle:
spc_save_path = save_prefix
else:
spc_save_fs = autofile.fs.species(save_prefix)
spc_save_fs.leaf.create(spc_info)
spc_save_path = spc_save_fs.leaf.path(spc_info)
orb_restr = fsorb.orbital_restriction(spc_info, thy_low_level)
thy_low_level = thy_low_level[1:3]
thy_low_level.append(orb_restr)
ll_save_fs = autofile.fs.theory(spc_save_path)
ll_save_path = ll_save_fs.leaf.path(thy_low_level)
if saddle:
ll_save_fs = autofile.fs.ts(ll_save_path)
ll_save_fs.trunk.create()
ll_save_path = ll_save_fs.trunk.path()
cnf_save_fs = autofile.fs.conformer(ll_save_path)
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
if not min_cnf_locs:
print('ERROR: No minimum conformer geometry for ',
'this species {}'.format(spc_info[0]))
return 0.0
cnf_save_path = cnf_save_fs.leaf.path(min_cnf_locs)
orb_restr = fsorb.orbital_restriction(spc_info, thy_high_level)
thy_high_level = thy_high_level[1:3]
thy_high_level.append(orb_restr)
sp_save_fs = autofile.fs.single_point(cnf_save_path)
sp_save_fs.leaf.create(thy_high_level)
if os.path.exists(sp_save_fs.leaf.path(thy_high_level)):
min_ene = sp_save_fs.leaf.file.energy.read(thy_high_level)
else:
print('No energy at path')
min_ene = None
return min_ene
def reagent_energies(save_prefix, rgt_ichs, rgt_chgs, rgt_muls, thy_level):
""" reagent energies """
enes = []
for rgt_ich, rgt_chg, rgt_mul in zip(rgt_ichs, rgt_chgs, rgt_muls):
spc_save_fs = autofile.fs.species(save_prefix)
rgt_info = [rgt_ich, rgt_chg, rgt_mul]
spc_save_path = spc_save_fs.leaf.path(rgt_info)
orb_restr = fsorb.orbital_restriction(rgt_info, thy_level)
thy_lvl = thy_level[0:3]
thy_lvl.append(orb_restr)
thy_save_fs = autofile.fs.theory(spc_save_path)
thy_save_path = thy_save_fs.leaf.path(thy_lvl[1:4])
cnf_save_fs = autofile.fs.conformer(thy_save_path)
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
ene = cnf_save_fs.leaf.file.energy.read(min_cnf_locs)
enes.append(ene)
return enes
def check_filesys_for_ts(ts_dct, ts_zma, cnf_save_fs, overwrite, typ,
dist_info, dist_name, bkp_ts_class_data):
""" Check if TS is in filesystem and matches original guess
"""
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
if min_cnf_locs and not overwrite:
cnf_path = cnf_save_fs.trunk.path()
print('Found TS at {}'.format(cnf_path))
zma = cnf_save_fs.leaf.file.zmatrix.read(min_cnf_locs)
chk_bkp = check_ts_zma(zma, ts_zma, ts_dct)
# Check if TS is in filesystem and matches original guess
is_bkp = False
if chk_bkp and bkp_ts_class_data:
[bkp_typ, bkp_ts_zma, _, _, bkp_tors_names, _] = bkp_ts_class_data
is_bkp = check_ts_zma(zma, bkp_ts_zma, ts_dct)
# Set information in ts_dct as needed
if not chk_bkp:
print("TS is type {}".format(typ))
elif is_bkp:
print('updating reaction class to {}'.format(bkp_typ))
ts_dct['class'] = bkp_typ
ts_dct['original_zma'] = bkp_ts_zma
ts_dct['tors_names'] = bkp_tors_names
print("TS is backup type {}".format(bkp_typ))
else:
print("TS may not be original type or backup type")
print("Some part of the z-matrices have changed")
print('class test:', ts_dct['class'])
vals = automol.zmatrix.values(zma)
final_dist = vals[dist_name]
dist_info[1] = final_dist
print('dist_info is being set at end of backup checking', dist_info[1],
final_dist)
# Add an angle check which is added to spc dct for TS
angle = lts.check_angle(ts_dct['original_zma'], ts_dct['dist_info'],
ts_dct['class'])
ts_dct['dist_info'][1] = final_dist
ts_dct['dist_info'].append(angle)
return ts_dct
def get_geos(
spcs, spc_dct, ini_thy_info, save_prefix, run_prefix, kickoff_size,
kickoff_backward, projrot_script_str):
"""get geos for reactants and products using the initial level of theory
"""
spc_geos = []
cnf_save_fs_lst = []
for spc in spcs:
spc_info = [spc_dct[spc]['ich'],
spc_dct[spc]['chg'],
spc_dct[spc]['mul']]
orb_restr = fsorb.orbital_restriction(spc_info, ini_thy_info)
ini_thy_level = ini_thy_info[0:3]
ini_thy_level.append(orb_restr)
spc_save_fs = autofile.fs.species(save_prefix)
spc_save_fs.leaf.create(spc_info)
spc_save_path = spc_save_fs.leaf.path(spc_info)
spc_run_fs = autofile.fs.species(run_prefix)
spc_run_fs.leaf.create(spc_info)
spc_run_path = spc_run_fs.leaf.path(spc_info)
ini_thy_save_fs = autofile.fs.theory(spc_save_path)
ini_thy_save_path = ini_thy_save_fs.leaf.path(ini_thy_level[1:4])
ini_thy_run_fs = autofile.fs.theory(spc_run_path)
ini_thy_run_path = ini_thy_run_fs.leaf.path(ini_thy_level[1:4])
cnf_save_fs = autofile.fs.conformer(ini_thy_save_path)
cnf_save_fs_lst.append(cnf_save_fs)
cnf_run_fs = autofile.fs.conformer(ini_thy_run_path)
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
if min_cnf_locs:
geo = cnf_save_fs.leaf.file.geometry.read(min_cnf_locs)
else:
run_fs = autofile.fs.run(ini_thy_run_path)
run_fs.trunk.create()
tmp_ini_fs = [None, ini_thy_save_fs]
tmp_fs = [spc_save_fs, spc_run_fs, ini_thy_save_fs, ini_thy_run_fs,
cnf_save_fs, cnf_run_fs, run_fs]
geo = geom.reference_geometry(
spc_dct[spc], ini_thy_level, ini_thy_level, tmp_fs, tmp_ini_fs,
kickoff_size, kickoff_backward, projrot_script_str,
overwrite=False)
spc_geos.append(geo)
return spc_geos, cnf_save_fs_lst
def write_tau_data_str(name, save_prefix, gradient=False, hessian=False):
""" Write out data fle for partition function evaluation
"""
cnf_save_fs = autofile.fs.conformer(save_prefix)
min_cnf_locs = fmin.min_energy_conformer_locators(cnf_save_fs)
if min_cnf_locs:
ene_ref = cnf_save_fs.leaf.file.energy.read(min_cnf_locs)
tau_save_fs = autofile.fs.tau(save_prefix)
evr = name + '\n'
# cycle through saved tau geometries
idx = 0
for locs in tau_save_fs.leaf.existing():
geo = tau_save_fs.leaf.file.geometry.read(locs)
ene = tau_save_fs.leaf.file.energy.read(locs)
ene = (ene - ene_ref) * phycon.EH2KCAL
ene_str = autofile.file.write.energy(ene)
geo_str = autofile.file.write.geometry(geo)
idx += 1
idx_str = str(idx)
evr += 'Sampling point' + idx_str + '\n'
evr += 'Energy' + '\n'
evr += ene_str + '\n'
evr += 'Geometry' + '\n'
evr += geo_str + '\n'
if gradient:
grad = tau_save_fs.leaf.file.gradient.read(locs)
grad_str = autofile.file.write.gradient(grad)
evr += 'Gradient' + '\n'
evr += grad_str
if hessian:
hess = tau_save_fs.leaf.file.hessian.read(locs)
hess_str = autofile.file.write.hessian(hess)
evr += 'Hessian' + '\n'
evr += hess_str + '\n'
return evr
def check_save(save_fs, tsk, obj):
""" check if information exists in a save directory for
conformers, tau, scan
"""
print('save fs leaf exist')
print(save_fs.leaf.existing())
print(save_fs.leaf.existing()[0])
print([save_fs.leaf.existing()[0]])
assert obj in ('conf', 'tau', 'scan')
avail = True
if obj == 'conf':
save_locs = fsmin.min_energy_conformer_locators(save_fs)
# Doesn't work well for tau since there are multipole tau we wish to comp
elif obj == 'tau':
save_locs = save_fs.leaf.existing()[0]
else:
save_locs = [save_fs.leaf.existing()[0]]
if not save_locs:
printmsg.ini_info_noavail_msg(tsk)
avail = False
elif not save_fs.leaf.file.geometry.exists(save_locs):
printmsg.ini_info_noavail_msg(tsk)
avail = False
return avail
def find_ts(spc_dct,
ts_dct,
ts_zma,
ini_thy_info,
thy_info,
run_prefix,
save_prefix,
overwrite,
rad_rad_ts='vtst'):
""" find the ts geometry
"""
# Set various TS information using the dictionary
typ = ts_dct['class']
dist_info = ts_dct['dist_info']
grid = ts_dct['grid']
bkp_ts_class_data = ts_dct['bkp_data']
rad_rad = ('radical radical' in typ)
low_spin = ('low spin' in typ)
print('prepping ts scan for:', typ)
[_, _, rxn_run_path, rxn_save_path] = ts_dct['rxn_fs']
ts_info = (ts_dct['ich'], ts_dct['chg'], ts_dct['mul'])
_, opt_script_str, _, opt_kwargs = runpar.run_qchem_par(*thy_info[0:2])
orb_restr = fsorb.orbital_restriction(ts_info, thy_info)
ref_level = thy_info[0:3]
ref_level.append(orb_restr)
thy_run_fs = autofile.fs.theory(rxn_run_path)
thy_run_fs.leaf.create(ref_level[1:4])
thy_run_path = thy_run_fs.leaf.path(ref_level[1:4])
thy_save_fs = autofile.fs.theory(rxn_save_path)
thy_save_fs.leaf.create(ref_level[1:4])
thy_save_path = thy_save_fs.leaf.path(ref_level[1:4])
scn_run_fs = autofile.fs.scan(thy_run_path)
scn_save_fs = autofile.fs.scan(thy_save_path)
ts_run_fs = autofile.fs.ts(thy_run_path)
ts_run_fs.trunk.create()
ts_run_path = ts_run_fs.trunk.path()
run_fs = autofile.fs.run(ts_run_path)
ts_save_fs = autofile.fs.ts(thy_save_path)
ts_save_fs.trunk.create()
ts_save_path = ts_save_fs.trunk.path()
cnf_run_fs = autofile.fs.conformer(ts_run_path)
cnf_save_fs = autofile.fs.conformer(ts_save_path)
cnf_save_fs.trunk.create()
# Unpack the dist info
dist_name, _, update_guess, brk_name = dist_info
# Get TS from filesys or get it from some procedure
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
if min_cnf_locs and not overwrite:
check_filesys_for_ts(ts_dct, ts_zma, cnf_save_fs, overwrite, typ,
dist_info, dist_name, bkp_ts_class_data)
else:
filesys = [
None, None, ts_run_fs, ts_save_fs, cnf_run_fs, cnf_save_fs, None,
None, scn_run_fs, scn_save_fs, run_fs
]
print('running ts scan:')
if rad_rad and low_spin and 'elimination' not in ts_dct['class']:
print('Running Scan for Barrierless TS:')
find_barrierless_transition_state(
ts_info, ts_zma, ts_dct, spc_dct, grid, dist_name,
rxn_run_path, rxn_save_path, rad_rad_ts, ini_thy_info,
thy_info, run_prefix, save_prefix, scn_run_fs, scn_save_fs,
opt_script_str, overwrite, update_guess, **opt_kwargs)
# Have code analyze the path and switch to a sadpt finder if needed
else:
print('Running Scan for Fixed TS:')
max_zma = run_sadpt_scan(typ, grid, dist_name, brk_name, ts_zma,
ts_info, ref_level, scn_run_fs,
scn_save_fs, opt_script_str, overwrite,
update_guess, **opt_kwargs)
geo, zma, final_dist = find_sadpt_transition_state(
opt_script_str, run_fs, max_zma, ts_info, ref_level, overwrite,
ts_save_path, ts_save_fs, dist_name, dist_info, filesys,
**opt_kwargs)
return geo, zma, final_dist
def set_fs(spc_dct, spc, thy_info,
run_prefix, save_prefix,
setfs_chk=True, ini_fs=False):
""" set up filesystem """
# Build the species filesys objs
[spc_info,
spc_run_fs, spc_save_fs,
spc_run_path, spc_save_path] = set_spc_fs(
spc_dct, spc, run_prefix, save_prefix)
# Initialize the filesystems
thy_run_fs = None
thy_run_path = None
thy_save_fs = None
thy_save_path = None
cnf_run_fs = None
cnf_save_fs = None
tau_run_fs = None
tau_save_fs = None
thy_level = thy_info
scn_run_fs = None
scn_save_fs = None
# Build the theory filesys obj
thy_level = thy_info
orb_restr = fsorb.orbital_restriction(
spc_info, thy_info)
thy_level = thy_info[0:3]
thy_level.append(orb_restr)
thy_run_fs = autofile.fs.theory(spc_run_path)
thy_save_fs = autofile.fs.theory(spc_save_path)
if setfs_chk:
if 'ts_' in spc:
thy_run_fs.leaf.create(thy_level[1:4])
thy_run_path = thy_run_fs.leaf.path(thy_level[1:4])
thy_save_fs.leaf.create(thy_level[1:4])
thy_save_path = thy_save_fs.leaf.path(thy_level[1:4])
thy_run_fs = autofile.fs.ts(thy_run_path)
thy_run_fs.trunk.create()
thy_run_path = thy_run_fs.trunk.path()
thy_save_fs = autofile.fs.ts(thy_save_path)
thy_save_fs.trunk.create()
thy_save_path = thy_save_fs.trunk.path()
else:
thy_run_fs.leaf.create(thy_level[1:4])
thy_run_path = thy_run_fs.leaf.path(thy_level[1:4])
thy_save_fs.leaf.create(thy_level[1:4])
thy_save_path = thy_save_fs.leaf.path(thy_level[1:4])
cnf_run_fs = autofile.fs.conformer(thy_run_path)
cnf_save_fs = autofile.fs.conformer(thy_save_path)
tau_run_fs = autofile.fs.tau(thy_run_path)
tau_save_fs = autofile.fs.tau(thy_save_path)
min_cnf_locs = fsmin.min_energy_conformer_locators(
cnf_save_fs)
if min_cnf_locs:
min_cnf_run_path = cnf_run_fs.leaf.path(min_cnf_locs)
min_cnf_save_path = cnf_save_fs.leaf.path(min_cnf_locs)
scn_run_fs = autofile.fs.conformer(min_cnf_run_path)
scn_save_fs = autofile.fs.conformer(min_cnf_save_path)
# filesys = [spc_run_fs, spc_save_fs, thy_run_fs, thy_save_fs,
# cnf_run_fs, cnf_save_fs, tau_run_fs, tau_save_fs,
# scn_run_fs, scn_save_fs]
# Add run fs if needed
if not ini_fs:
filesys = [spc_run_fs, spc_save_fs,
thy_run_fs, thy_save_fs,
cnf_run_fs, cnf_save_fs,
tau_run_fs, tau_save_fs,
scn_run_fs, scn_save_fs]
run_fs = autofile.fs.run(thy_run_path)
run_fs.trunk.create()
filesys.append(run_fs)
else:
filesys = [thy_run_fs, thy_save_fs,
cnf_run_fs, cnf_save_fs,
tau_run_fs, tau_save_fs,
scn_run_fs, scn_save_fs]
return filesys, thy_level
def conformer_sampling(spc_info,
thy_level,
thy_save_fs,
cnf_run_fs,
cnf_save_fs,
script_str,
overwrite,
saddle=False,
nsamp_par=(False, 3, 3, 1, 50, 50),
tors_names='',
dist_info=(),
two_stage=False,
rxn_class='',
**kwargs):
""" Find the minimum energy conformer by optimizing from nsamp random
initial torsional states
"""
ich = spc_info[0]
coo_names = []
if not saddle:
geo = thy_save_fs.leaf.file.geometry.read(thy_level[1:4])
tors_names = automol.geom.zmatrix_torsion_coordinate_names(geo)
zma = automol.geom.zmatrix(geo)
else:
geo = thy_save_fs.trunk.file.geometry.read()
zma = thy_save_fs.trunk.file.zmatrix.read()
coo_names.append(tors_names)
tors_ranges = tuple((0, 2 * numpy.pi) for tors in tors_names)
tors_range_dct = dict(zip(tors_names, tors_ranges))
if not saddle:
gra = automol.inchi.graph(ich)
ntaudof = len(
automol.graph.rotational_bond_keys(gra, with_h_rotors=False))
nsamp = util.nsamp_init(nsamp_par, ntaudof)
else:
ntaudof = len(tors_names)
nsamp = util.nsamp_init(nsamp_par, ntaudof)
save_conformers(cnf_run_fs=cnf_run_fs,
cnf_save_fs=cnf_save_fs,
saddle=saddle,
dist_info=dist_info,
rxn_class=rxn_class)
run_conformers(
zma=zma,
spc_info=spc_info,
thy_level=thy_level,
nsamp=nsamp,
tors_range_dct=tors_range_dct,
cnf_run_fs=cnf_run_fs,
cnf_save_fs=cnf_save_fs,
script_str=script_str,
overwrite=overwrite,
saddle=saddle,
two_stage=two_stage,
**kwargs,
)
save_conformers(cnf_run_fs=cnf_run_fs,
cnf_save_fs=cnf_save_fs,
saddle=saddle,
dist_info=dist_info,
rxn_class=rxn_class)
# save information about the minimum energy conformer in top directory
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
if min_cnf_locs:
geo = cnf_save_fs.leaf.file.geometry.read(min_cnf_locs)
zma = cnf_save_fs.leaf.file.zmatrix.read(min_cnf_locs)
if not saddle:
assert automol.zmatrix.almost_equal(zma, automol.geom.zmatrix(geo))
thy_save_fs.leaf.file.geometry.write(geo, thy_level[1:4])
thy_save_fs.leaf.file.zmatrix.write(zma, thy_level[1:4])
else:
thy_save_fs.trunk.file.geometry.write(geo)
thy_save_fs.trunk.file.zmatrix.write(zma)
def hindered_rotor_scans(spc_info,
thy_level,
cnf_run_fs,
cnf_save_fs,
script_str,
overwrite,
scan_increment=30.0,
saddle=False,
run_tors_names=(),
frm_bnd_key=(),
brk_bnd_key=(),
tors_model=('1dhr', False),
**opt_kwargs):
""" Perform 1d scans over each of the torsional coordinates
"""
# Unpack tors model
ndim_tors, freeze_all_tors = tors_model
# Run with the old code
min_cnf_locs = fsmin.min_energy_conformer_locators(cnf_save_fs)
if min_cnf_locs:
min_cnf_run_path = cnf_run_fs.leaf.path(min_cnf_locs)
min_cnf_save_path = cnf_save_fs.leaf.path(min_cnf_locs)
scn_run_fs = autofile.fs.scan(min_cnf_run_path)
scn_save_fs = autofile.fs.scan(min_cnf_save_path)
geo = cnf_save_fs.leaf.file.geometry.read(min_cnf_locs)
zma = cnf_save_fs.leaf.file.zmatrix.read(min_cnf_locs)
run_tors_names, run_tors_grids = hr_prep(zma,
geo,
run_tors_names=(),
scan_increment=scan_increment,
ndim_tors=ndim_tors,
saddle=saddle,
frm_bnd_key=frm_bnd_key,
brk_bnd_key=brk_bnd_key)
print('TEST: run_tors_names')
print(run_tors_names)
print(run_tors_grids)
# import sys
# sys.exit()
print('TEST: in loop')
# for tors_name, tors_grid in zip(tors_names, tors_grids):
for tors_names, tors_grids in zip(run_tors_names, run_tors_grids):
# Get the dictionary for the torsional modes
print(tors_names)
print(tors_grids)
if not tors_names:
continue
grid_dct = dict(zip(tors_names, tors_grids))
# Get a list of the other tors coords to freeze
print('freeze variable', freeze_all_tors)
if freeze_all_tors:
alt_constraints = [
name for name_lst in run_tors_names for name in name_lst
]
else:
alt_constraints = ()
print('alt_constraints')
print(alt_constraints)
# Perform the scans
save_scan(
scn_run_fs=scn_run_fs,
scn_save_fs=scn_save_fs,
coo_names=tors_names,
)
run_scan(
zma=zma,
spc_info=spc_info,
thy_level=thy_level,
grid_dct=grid_dct,
scn_run_fs=scn_run_fs,
scn_save_fs=scn_save_fs,
script_str=script_str,
overwrite=overwrite,
saddle=saddle,
alt_constraints=alt_constraints,
**opt_kwargs,
)
save_scan(
scn_run_fs=scn_run_fs,
scn_save_fs=scn_save_fs,
coo_names=tors_names,
)
def infinite_separation_energy(spc_1_info,
spc_2_info,
ts_info,
high_mul,
ref_zma,
ini_thy_info,
thy_info,
multi_info,
run_prefix,
save_prefix,
scn_run_fs,
scn_save_fs,
locs,
overwrite=False,
num_act_elc=None,
num_act_orb=None):
""" Obtain the infinite separation energy from the multireference energy
at a given reference point, the high-spin low-spin splitting at that
reference point, and the high level energy for the high spin state
at the reference geometry and for the fragments
"""
# Initialize infinite sep energy
inf_sep_ene = -1.0e12
# set up all the file systems for the TS
# start with the geo and reference theory info
geo_run_path = scn_run_fs.leaf.path(locs)
geo_save_path = scn_save_fs.leaf.path(locs)
geo = scn_save_fs.leaf.file.geometry.read(locs)
sp_run_fs = autofile.fs.single_point(geo_run_path)
sp_save_fs = autofile.fs.single_point(geo_save_path)
# get the multi reference ene for low spin state for the ref point on scan
# file system for low spin multireference calculation
multi_info[0] = 'molpro2015'
multi_info[1] = 'caspt2'
# ultimately the above should be properly passed
prog = multi_info[0]
method = multi_info[1]
# get the multi reference energy for high spin state for ref point on scan
hs_info = (ts_info[0], ts_info[1], high_mul)
orb_restr = fsorb.orbital_restriction(hs_info, multi_info)
multi_lvl = multi_info[0:3]
multi_lvl.append(orb_restr)
hs_run_fs = autofile.fs.high_spin(geo_run_path)
hs_save_fs = autofile.fs.high_spin(geo_save_path)
hs_run_fs.leaf.create(multi_lvl[1:4])
hs_save_fs.leaf.create(multi_lvl[1:4])
hs_mr_run_path = hs_run_fs.leaf.path(multi_lvl[1:4])
hs_mr_save_path = hs_save_fs.leaf.path(multi_lvl[1:4])
run_mr_fs = autofile.fs.run(hs_mr_run_path)
mr_script_str, _, mr_kwargs, _ = runpar.run_qchem_par(prog, method)
if num_act_elc is None and num_act_orb is None:
num_act_elc = high_mul
num_act_orb = num_act_elc
ts_formula = automol.geom.formula(automol.zmatrix.geometry(ref_zma))
cas_opt, _ = ts.cas_options_2(hs_info, ts_formula, num_act_elc,
num_act_orb, high_mul)
guess_str = ts.multiref_wavefunction_guess(high_mul, ref_zma, hs_info,
multi_lvl, [cas_opt])
guess_lines = guess_str.splitlines()
mr_kwargs['casscf_options'] = cas_opt
mr_kwargs['mol_options'] = ['nosym']
mr_kwargs['gen_lines'] = {1: guess_lines}
ret = driver.read_job(
job='energy',
run_fs=run_mr_fs,
)
if ret:
print(" - Reading high spin multi reference energy from output...")
inf_obj, inp_str, out_str = ret
ene = elstruct.reader.energy(inf_obj.prog, inf_obj.method, out_str)
hs_save_fs.leaf.file.energy.write(ene, multi_lvl[1:4])
hs_save_fs.leaf.file.input.write(inp_str, multi_lvl[1:4])
hs_save_fs.leaf.file.info.write(inf_obj, multi_lvl[1:4])
if not hs_save_fs.leaf.file.energy.exists(multi_lvl[1:4]) or overwrite:
print(" - Running high spin multi reference energy ...")
driver.run_job(
job='energy',
script_str=mr_script_str,
run_fs=run_mr_fs,
geom=geo,
spc_info=hs_info,
thy_level=multi_lvl,
overwrite=overwrite,
**mr_kwargs,
)
ret = driver.read_job(
job='energy',
run_fs=run_mr_fs,
)
if ret is not None:
inf_obj, inp_str, out_str = ret
print(" - Reading high spin multi reference energy from output...")
hs_mr_ene = elstruct.reader.energy(inf_obj.prog, inf_obj.method,
out_str)
print(" - Saving high spin multi reference energy...")
print(" - Save path: {}".format(hs_mr_save_path))
hs_save_fs.leaf.file.energy.write(hs_mr_ene, multi_lvl[1:4])
hs_save_fs.leaf.file.input.write(inp_str, multi_lvl[1:4])
hs_save_fs.leaf.file.info.write(inf_obj, multi_lvl[1:4])
else:
print('ERROR: high spin multi reference energy job fails: ',
'Energy is needed to evaluate infinite separation energy')
return inf_sep_ene
else:
hs_mr_ene = hs_save_fs.leaf.file.energy.read(multi_lvl[1:4])
# file system for high spin single ireference calculation
thy_info = ['molpro2015', 'ccsd(t)-f12', 'cc-pvdz-f12', 'RR']
orb_restr = fsorb.orbital_restriction(hs_info, thy_info)
thy_lvl = thy_info[0:3]
thy_lvl.append(orb_restr)
hs_run_fs.leaf.create(thy_lvl[1:4])
hs_save_fs.leaf.create(thy_lvl[1:4])
hs_sr_run_path = hs_run_fs.leaf.path(thy_lvl[1:4])
hs_sr_save_path = hs_save_fs.leaf.path(thy_lvl[1:4])
run_sr_fs = autofile.fs.run(hs_sr_run_path)
sp_script_str, _, kwargs, _ = runpar.run_qchem_par(*thy_lvl[0:2])
ret = driver.read_job(
job='energy',
run_fs=run_sr_fs,
)
if ret:
print(" - Reading high spin single reference energy from output...")
inf_obj, inp_str, out_str = ret
ene = elstruct.reader.energy(inf_obj.prog, inf_obj.method, out_str)
hs_save_fs.leaf.file.energy.write(ene, thy_lvl[1:4])
hs_save_fs.leaf.file.input.write(inp_str, thy_lvl[1:4])
hs_save_fs.leaf.file.info.write(inf_obj, thy_lvl[1:4])
if not hs_save_fs.leaf.file.energy.exists(thy_lvl[1:4]) or overwrite:
print(" - Running high spin single reference energy ...")
errors, options_mat = runpar.set_molpro_options_mat(hs_info, geo)
driver.run_job(
job='energy',
script_str=sp_script_str,
run_fs=run_sr_fs,
geom=geo,
spc_info=hs_info,
thy_level=thy_lvl,
errors=errors,
options_mat=options_mat,
overwrite=overwrite,
**kwargs,
)
ret = driver.read_job(
job='energy',
run_fs=run_sr_fs,
)
if ret is not None:
inf_obj, inp_str, out_str = ret
print(" - Reading high spin single ref energy from output...")
hs_sr_ene = elstruct.reader.energy(inf_obj.prog, inf_obj.method,
out_str)
print(" - Saving high spin single reference energy...")
print(" - Save path: {}".format(hs_sr_save_path))
hs_save_fs.leaf.file.energy.write(hs_sr_ene, thy_lvl[1:4])
hs_save_fs.leaf.file.input.write(inp_str, thy_lvl[1:4])
hs_save_fs.leaf.file.info.write(inf_obj, thy_lvl[1:4])
else:
print('ERROR: High spin single reference energy job fails: ',
'Energy is needed to evaluate infinite separation energy')
return inf_sep_ene
else:
hs_sr_ene = hs_save_fs.leaf.file.energy.read(thy_lvl[1:4])
# get the single reference energy for each of the reactant configurations
spc_ene = []
spc_infos = [spc_1_info, spc_2_info]
for spc_info in spc_infos:
# set up the file systems for the reactants one by one
spc_run_fs = autofile.fs.species(run_prefix)
spc_run_fs.leaf.create(spc_info)
spc_run_path = spc_run_fs.leaf.path(spc_info)
spc_save_fs = autofile.fs.species(save_prefix)
spc_save_fs.leaf.create(spc_info)
spc_save_path = spc_save_fs.leaf.path(spc_info)
orb_restr = fsorb.orbital_restriction(spc_info, ini_thy_info)
ini_thy_lvl = ini_thy_info[0:3]
ini_thy_lvl.append(orb_restr)
orb_restr = fsorb.orbital_restriction(spc_info, thy_info)
thy_lvl = thy_info[0:3]
thy_lvl.append(orb_restr)
ini_thy_run_fs = autofile.fs.theory(spc_run_path)
ini_thy_run_fs.leaf.create(ini_thy_lvl[1:4])
ini_thy_run_path = ini_thy_run_fs.leaf.path(ini_thy_lvl[1:4])
ini_thy_save_fs = autofile.fs.theory(spc_save_path)
ini_thy_save_fs.leaf.create(ini_thy_lvl[1:4])
ini_thy_save_path = ini_thy_save_fs.leaf.path(ini_thy_lvl[1:4])
ini_cnf_run_fs = autofile.fs.conformer(ini_thy_run_path)
ini_cnf_save_fs = autofile.fs.conformer(ini_thy_save_path)
min_cnf_locs = fsmin.min_energy_conformer_locators(ini_cnf_save_fs)
min_cnf_run_path = ini_cnf_run_fs.leaf.path(min_cnf_locs)
min_cnf_save_path = ini_cnf_save_fs.leaf.path(min_cnf_locs)
thy_run_fs = autofile.fs.theory(spc_run_path)
thy_run_fs.leaf.create(thy_lvl[1:4])
thy_save_fs = autofile.fs.theory(spc_save_path)
thy_save_fs.leaf.create(thy_lvl[1:4])
geo = ini_cnf_save_fs.leaf.file.geometry.read(min_cnf_locs)
sp_run_fs = autofile.fs.single_point(min_cnf_run_path)
sp_run_fs.leaf.create(thy_lvl[1:4])
sp_save_fs = autofile.fs.single_point(min_cnf_save_path)
sp_save_fs.leaf.create(thy_lvl[1:4])
sp_sr_run_path = sp_run_fs.leaf.path(thy_lvl[1:4])
sp_sr_save_path = sp_save_fs.leaf.path(thy_lvl[1:4])
print('sp_sr_run_path')
print(sp_sr_run_path)
run_sr_fs = autofile.fs.run(sp_sr_run_path)
ret = driver.read_job(
job='energy',
run_fs=run_sr_fs,
)
if ret:
print(" - Reading single reference energy for",
"{} from output...".format(spc_info[0]))
inf_obj, inp_str, out_str = ret
ene = elstruct.reader.energy(inf_obj.prog, inf_obj.method, out_str)
sp_save_fs.leaf.file.energy.write(ene, thy_lvl[1:4])
sp_save_fs.leaf.file.input.write(inp_str, thy_lvl[1:4])
sp_save_fs.leaf.file.info.write(inf_obj, thy_lvl[1:4])
if not sp_save_fs.leaf.file.energy.exists(thy_lvl[1:4]) or overwrite:
print(" - Running single reference energy for",
"{} from output...".format(spc_info[0]))
driver.run_job(
job='energy',
script_str=sp_script_str,
run_fs=run_sr_fs,
geom=geo,
spc_info=spc_info,
thy_level=thy_lvl,
overwrite=overwrite,
**kwargs,
)
ret = driver.read_job(
job='energy',
run_fs=run_sr_fs,
)
if ret is not None:
inf_obj, inp_str, out_str = ret
print(" - Reading single reference energy for ",
"{} from output...".format(spc_info[0]))
sp_sr_ene = elstruct.reader.energy(inf_obj.prog,
inf_obj.method, out_str)
print(" - Saving single reference energy for ",
"{} from output...".format(spc_info[0]))
print(" - Save path: {}".format(sp_sr_save_path))
sp_save_fs.leaf.file.energy.write(sp_sr_ene, thy_lvl[1:4])
sp_save_fs.leaf.file.input.write(inp_str, thy_lvl[1:4])
sp_save_fs.leaf.file.info.write(inf_obj, thy_lvl[1:4])
else:
print('ERROR: Single reference energy job fails',
'for {}: '.format(spc_info[0]),
'Energy needed to evaluate infinite separation energy')
return inf_sep_ene
else:
sp_sr_ene = sp_save_fs.leaf.file.energy.read(thy_lvl[1:4])
spc_ene.append(sp_sr_ene)
inf_sep_ene = spc_ene[0] + spc_ene[1] - hs_sr_ene + hs_mr_ene
return inf_sep_ene