def set_model_filesys(spc_dct_i, level, run_prefix, save_prefix, saddle, name=None, rings='all'): """ Gets filesystem objects for reading many calculations """ # Set the spc_info if saddle: rxn_info = spc_dct_i['rxn_info'] spc_info = rinfo.ts_info(rxn_info) else: spc_info = sinfo.from_dct(spc_dct_i) print('level', level) levelp = tinfo.modify_orb_label(level, spc_info) _root = root_locs(spc_dct_i, saddle=saddle, name=name) cnf_run_fs, cnf_save_fs = build_fs( run_prefix, save_prefix, 'CONFORMER', thy_locs=levelp[1:], **_root) if rings == 'min': min_rngs_locs, min_rngs_path = mincnf.min_energy_conformer_locators( cnf_save_fs, levelp) cnf_run_fs[-1].create(min_rngs_locs) else: min_rngs_locs, min_rngs_path = mincnf.conformer_locators( cnf_save_fs, levelp, cnf_range='r100') for min_locs in min_rngs_locs: cnf_run_fs[-1].create(min_locs) print('model filesys', min_rngs_locs, min_rngs_path) # Create run fs if that directory has been deleted to run the jobs return [cnf_save_fs, min_rngs_path, min_rngs_locs, '', cnf_run_fs]
def reactions(rxn_info, ini_thy_info, zma_locs, save_prefix): """ Check if reaction exists in the filesystem and has been identified """ zrxns, zmas = (), () sort_rxn_info = rinfo.sort(rxn_info, scheme='autofile') ts_info = rinfo.ts_info(rxn_info) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, ts_info) rxn_fs = autofile.fs.reaction(save_prefix) if rxn_fs[-1].exists(sort_rxn_info): _, ts_save_fs = build_fs(save_prefix, save_prefix, 'TRANSITION STATE', rxn_locs=sort_rxn_info, thy_locs=mod_ini_thy_info[1:]) for ts_locs in ts_save_fs[-1].existing(): zrxn, zma = reaction(rxn_info, ini_thy_info, zma_locs, save_prefix, ts_locs=ts_locs) if zrxn is not None: zrxns += (zrxn, ) zmas += (zma, ) if not zrxns: zrxns, zmas = None, None return zrxns, zmas
def calc_vrctst_flux(ts_dct, thy_inf_dct, thy_method_dct, mref_params, es_keyword_dct, runfs_dct, savefs_dct): """ Set up n VRC-TST calculations to get the flux file """ # Build VRC-TST stuff vrc_fs = runfs_dct['vrctst'] vrc_path = vrc_fs[-1].create((0,)) vrc_path = vrc_fs[-1].path((0,)) vrc_dct = autorun.varecof.VRC_DCT # need code to input one machine_dct = {'bxxx': 10} # how to do this when on a node # Get a bunch of info that describes the grid scan_inf_dct = _scan_inf_dct(ts_dct, savefs_dct) # Calculate the correction potential along the MEP inf_sep_ene, npot, zma_for_inp = _build_correction_potential( ts_dct, scan_inf_dct, thy_inf_dct, thy_method_dct, mref_params, es_keyword_dct, runfs_dct, savefs_dct, vrc_dct, vrc_path) # Write the VaReCoF input files inp_strs = autorun.varecof.write_input( vrc_path, zma_for_inp, scan_inf_dct['rct_zmas'], npot, scan_inf_dct['rxn_bond_keys'], machine_dct, vrc_dct) rxn_info = ts_dct['rxn_info'] ts_info = rinfo.ts_info(rxn_info) mod_var_sp1_thy_info = thy_inf_dct['mod_var_splvl1'] cas_kwargs = mref_params['var_scnlvl'] molp_tmpl_str = varecof_io.writer.molpro_template( ts_info, mod_var_sp1_thy_info, inf_sep_ene, cas_kwargs) inp_strs.update({'run.tml': molp_tmpl_str}) # Run VaReCoF to generate flux file running(f'VaReCoF at {vrc_path}') flux_str = autorun.varecof.flux_file( autorun.SCRIPT_DCT['varecof'], autorun.SCRIPT_DCT['mcflux'], vrc_path, inp_strs) # Read the corr pot file to send to save pot_corr_str = ioformat.pathtools.read_file( vrc_path, 'run_corr.f') # Save the flux file if flux_str is not None: filesys.save.flux(flux_str, pot_corr_str, inp_strs, savefs_dct['vrctst'], vrc_locs=(0,)) success = True else: success = False return success
def set_model_filesys(spc_dct_i, level, run_prefix, save_prefix, saddle, name=None, cnf_range='min', spc_locs=None, nprocs=1): """ Gets filesystem objects for reading many calculations """ # Set the spc_info if saddle: rxn_info = spc_dct_i['rxn_info'] spc_info = rinfo.ts_info(rxn_info) else: spc_info = sinfo.from_dct(spc_dct_i) levelp = tinfo.modify_orb_label(level, spc_info) _root = root_locs(spc_dct_i, saddle=saddle, name=name) cnf_run_fs, cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=levelp[1:], **_root) hbond_cutoffs = spc_dct_i['hbond_cutoffs'] if cnf_range == 'specified': min_rngs_locs = spc_locs min_rngs_path = cnf_save_fs[-1].path(min_rngs_locs) cnf_run_fs[-1].create(min_rngs_locs) elif cnf_range == 'min': min_rngs_locs, min_rngs_path = min_energy_conformer_locators( cnf_save_fs, levelp, hbond_cutoffs=hbond_cutoffs) cnf_run_fs[-1].create(min_rngs_locs) else: min_rngs_locs_lst, min_rngs_path_lst = conformer_locators( cnf_save_fs, levelp, cnf_range=cnf_range, hbond_cutoffs=hbond_cutoffs, nprocs=nprocs) for min_locs in min_rngs_locs_lst: cnf_run_fs[-1].create(min_locs) min_rngs_locs = min_rngs_locs_lst[0] min_rngs_path = min_rngs_path_lst[0] ioprinter.warning_message('Only returning first location in this list') # Create run fs if that directory has been deleted to run the jobs return [cnf_save_fs, min_rngs_path, min_rngs_locs, '', cnf_run_fs]
def search(ini_zma, spc_dct, tsname, thy_inf_dct, thy_method_dct, mref_dct, es_keyword_dct, runfs_dct, savefs_dct): """ Attempt to locate and optimize a proper transition state. """ # CHECK _ = thy_inf_dct # Initialize success variable to False success = False # Build ts dct for functions ts_dct = spc_dct[tsname] if ini_zma is not None: # Use the zma from the ini level as a guess guess_zmas = (ini_zma, ) else: # Generate a guess zma by scanning along rxncoord and finding max guess_zmas = rpath.internal_coordinates_scan( ts_zma=ts_dct['zma'], zrxn=ts_dct['zrxn'], ts_info=rinfo.ts_info(ts_dct['rxn_info']), rxn_class=ts_dct['class'], method_dct=thy_method_dct['runlvl'], mref_params=mref_dct['runlvl'], scn_run_fs=runfs_dct['runlvl_scn'], scn_save_fs=savefs_dct['runlvl_scn'], es_keyword_dct=es_keyword_dct) # Optimize guess and check if saddle point good to save if guess_zmas is not None: cnf_locs = (autofile.schema.generate_new_ring_id(), autofile.schema.generate_new_conformer_id()) opt_ret, hess_ret = optimize_saddle_point(guess_zmas, ts_dct, thy_method_dct['runlvl'], mref_dct['runlvl'], runfs_dct, es_keyword_dct, cnf_locs) status = assess_saddle_point(opt_ret, hess_ret, ts_dct, runfs_dct, cnf_locs) if status == 'save': save_saddle_point(opt_ret, hess_ret, ts_dct, thy_method_dct['runlvl'], savefs_dct, cnf_locs) success = True # print the saddle point return success
def electronic_energy(spc_dct_i, pf_filesystems, spc_model_dct_i, conf=None): """ get high level energy at low level optimized geometry """ ioprinter.info_message('- Calculating electronic energy') # spc_dct_i = spc_dct[spc_name] rxn_info = spc_dct_i.get('rxn_info', None) if rxn_info is not None: spc_info = rinfo.ts_info(rxn_info) else: spc_info = sinfo.from_dct(spc_dct_i) # Get the harmonic filesys information if conf: cnf_path = conf[1] else: [_, cnf_path, _, _, _] = pf_filesystems['harm'] # Get the electronic energy levels ene_levels = tuple(val[1] for key, val in spc_model_dct_i['ene'].items() if 'lvl' in key) print('ene levels', ene_levels) # Read the energies from the filesystem e_elec = None if os.path.exists(cnf_path): e_elec = 0.0 # ioprinter.info_message('lvls', ene_levels) for (coeff, level) in ene_levels: # Build SP filesys mod_thy_info = tinfo.modify_orb_label(level, spc_info) sp_save_fs = autofile.fs.single_point(cnf_path) sp_save_fs[-1].create(mod_thy_info[1:4]) # Read the energy sp_path = sp_save_fs[-1].path(mod_thy_info[1:4]) if os.path.exists(sp_path): ioprinter.reading('Energy', sp_path) ene = sp_save_fs[-1].file.energy.read(mod_thy_info[1:4]) e_elec += (coeff * ene) else: ioprinter.warning_message('No energy at path') e_elec = None break else: ioprinter.warning_message('No conformer to calculate the energy') return e_elec
def reaction(rxn_info, ini_thy_info, zma_locs, save_prefix, ts_locs=(0, ), hbond_cutoffs=None): """ Check if reaction exists in the filesystem and has been identified """ zrxn, zma = None, None sort_rxn_info = rinfo.sort(rxn_info, scheme='autofile') ts_info = rinfo.ts_info(rxn_info) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, ts_info) rxn_fs = autofile.fs.reaction(save_prefix) if rxn_fs[-1].exists(sort_rxn_info): _, cnf_save_fs = build_fs(save_prefix, save_prefix, 'CONFORMER', rxn_locs=sort_rxn_info, thy_locs=mod_ini_thy_info[1:], ts_locs=ts_locs) _, ini_min_cnf_path = min_energy_conformer_locators( cnf_save_fs, mod_ini_thy_info, hbond_cutoffs=hbond_cutoffs) if ini_min_cnf_path: zma_fs = autofile.fs.zmatrix(ini_min_cnf_path) if zma_fs[-1].file.reaction.exists(zma_locs): zrxn = zma_fs[-1].file.reaction.read(zma_locs) zma = zma_fs[-1].file.zmatrix.read(zma_locs) # For barrierless reactions with no conformer if zrxn is None: _, zma_fs = build_fs(save_prefix, save_prefix, 'ZMATRIX', rxn_locs=sort_rxn_info, ts_locs=ts_locs, thy_locs=mod_ini_thy_info[1:]) if zma_fs[-1].file.reaction.exists(zma_locs): zrxn = zma_fs[-1].file.reaction.read(zma_locs) zma = zma_fs[-1].file.zmatrix.read(zma_locs) return zrxn, zma
def _read_from_filesys(rxn_info, ini_thy_info, zma_locs, save_prefix): """ Check if reaction exists in the filesystem and has been identified """ zrxn, zma = None, None sort_rxn_info = rinfo.sort(rxn_info, scheme='autofile') ts_info = rinfo.ts_info(rxn_info) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, ts_info) rxn_fs = autofile.fs.reaction(save_prefix) if rxn_fs[-1].exists(sort_rxn_info): _, cnf_save_fs = build_fs( save_prefix, save_prefix, 'CONFORMER', rxn_locs=sort_rxn_info, thy_locs=mod_ini_thy_info[1:], # this needs to be fixed for any case with more than one TS ts_locs=(0, )) _, ini_min_cnf_path = filesys.mincnf.min_energy_conformer_locators( cnf_save_fs, mod_ini_thy_info) if ini_min_cnf_path: zma_fs = autofile.fs.zmatrix(ini_min_cnf_path) if zma_fs[-1].file.reaction.exists(zma_locs): zrxn = zma_fs[-1].file.reaction.read(zma_locs) zma = zma_fs[-1].file.zmatrix.read(zma_locs) ts_locs = (0, ) if zrxn is None: _, zma_fs = build_fs('', save_prefix, 'ZMATRIX', rxn_locs=sort_rxn_info, ts_locs=ts_locs, thy_locs=mod_ini_thy_info[1:]) if zma_fs[-1].file.reaction.exists(zma_locs): zrxn = zma_fs[-1].file.reaction.read(zma_locs) zma = zma_fs[-1].file.zmatrix.read(zma_locs) return zrxn, zma
def save_saddle_point(opt_ret, hess_ret, ts_dct, method_dct, savefs_dct, cnf_locs): """ Given the saddle point guess structure, obtain a proper saddle point """ # Pull info from the dictionaries to save zrxn = ts_dct['zrxn'] runlvl_cnf_save_fs, _ = savefs_dct['runlvl_cnf_tuple'] ts_info = rinfo.ts_info(ts_dct['rxn_info']) mod_thy_info = tinfo.modify_orb_label(tinfo.from_dct(method_dct), ts_info) # Save initial saddle point conformer filesys.save.conformer(opt_ret, hess_ret, runlvl_cnf_save_fs, mod_thy_info[1:], zrxn=zrxn, rng_locs=(cnf_locs[0], ), tors_locs=(cnf_locs[1], ), zma_locs=None)
def _build_correction_potential(ts_dct, scan_inf_dct, thy_inf_dct, thy_method_dct, mref_params, es_keyword_dct, runfs_dct, savefs_dct, vrc_dct, vrc_path): """ use the MEP potentials to compile the correction potential .so file """ rxn_info = ts_dct['rxn_info'] ts_info = rinfo.ts_info(rxn_info) # Run the constrained and full opt potential scans _run_potentials(ts_info, scan_inf_dct, thy_inf_dct, thy_method_dct, mref_params, es_keyword_dct, runfs_dct, savefs_dct) # Obtain the energy at infinite separation inf_sep_ene = rpath.inf_sep_ene( ts_dct, thy_inf_dct, thy_method_dct, mref_params, savefs_dct, runfs_dct, es_keyword_dct) # Read the values for the correction potential from filesystem potentials, pot_labels, zma_for_inp = _read_potentials( scan_inf_dct, thy_inf_dct, savefs_dct) # Build correction potential .so file used by VaReCoF autorun.varecof.compile_potentials( vrc_path, scan_inf_dct['full_grid'], potentials, scan_inf_dct['rxn_bond_keys'], vrc_dct['fortran_compiler'], dist_restrict_idxs=(), pot_labels=pot_labels, pot_file_names=[vrc_dct['spc_name']], spc_name=vrc_dct['spc_name']) # Set zma if needed if zma_for_inp is None: zma_for_inp = ts_dct['zma'] return inf_sep_ene, len(potentials), zma_for_inp
def _get_prop_fs(spc_model_dct_i, spc_dct_i, prop, sort_info_lst, run_prefix, save_prefix, saddle=False, name=None): """ Get filesystem info for a property in the spc model dct """ if saddle: rxn_info = spc_dct_i['rxn_info'] spc_info = rinfo.ts_info(rxn_info) else: spc_info = sinfo.from_dct(spc_dct_i) level = spc_model_dct_i[prop]['geolvl'][1][1] levelp = tinfo.modify_orb_label(level, spc_info) mod_info_lst = [] if sort_info_lst is not None: for info in sort_info_lst[:2]: if info is not None: mod_info_lst.append(tinfo.modify_orb_label(info, spc_info)) else: mod_info_lst.append(info) for info in sort_info_lst[2:]: mod_info_lst.append(info) _root = root_locs(spc_dct_i, saddle=saddle, name=name) cnf_run_fs, cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=levelp[1:], **_root) return cnf_run_fs, cnf_save_fs, levelp, mod_info_lst
def inf_sep_ene(ts_dct, thy_inf_dct, thy_method_dct, mref_params, savefs_dct, runfs_dct, es_keyword_dct): """ Determine the total electronic energy of two reacting species that at infinite separation. """ ioprinter.info_message('Calculating the Infinite Separation Energy...') ioprinter.info_message('') # Get info from the reactants rct_info = thy_inf_dct['rct_info'] overwrite = es_keyword_dct['overwrite'] # Get thy_inf_dct stuff thy_info = thy_inf_dct['runlvl'] var_scn_thy_info = thy_inf_dct['var_scnlvl'] var_sp1_thy_info = thy_inf_dct['var_splvl1'] var_sp2_thy_info = thy_inf_dct['var_splvl2'] hs_var_sp1_thy_info = thy_inf_dct['hs_var_splvl1'] hs_var_sp2_thy_info = thy_inf_dct['hs_var_splvl2'] vscn_method_dct = thy_method_dct['var_scnlvl'] var_sp1_method_dct = thy_method_dct['var_splvl1'] var_sp2_method_dct = thy_method_dct['var_splvl2'] # Get the filesys stuff rcts_cnf_fs = savefs_dct['rcts_cnf'] vscnlvl_scn_run_fs = runfs_dct['vscnlvl_scn'] vscnlvl_scn_save_fs = savefs_dct['vscnlvl_scn'] run_prefix = runfs_dct['prefix'] # Get kwargs for the calculation rxn_class = ts_dct['class'] var = (automol.par.is_radrad(rxn_class) and automol.par.is_low_spin(rxn_class)) if var: ts_zma, zrxn = ts_dct['zma'], ts_dct['zrxn'] rxn_info = ts_dct['rxn_info'] ts_info = rinfo.ts_info(rxn_info) high_mult = rinfo.ts_mult(rxn_info, rxn_mul='high') hs_ts_info = (ts_info[0], ts_info[1], high_mult) # Build grid and names appropriate for reaction type names, _, grids, _ = automol.reac.build_scan_info(zrxn, ts_zma, var=var) inf_locs = (names, (grids[1][-1], )) cas_kwargs = mref_params['var_scnlvl'] _inf_sep_ene = _multiref_inf_sep_ene(hs_ts_info, ts_zma, rct_info, rcts_cnf_fs, run_prefix, thy_info, var_scn_thy_info, var_sp1_thy_info, var_sp2_thy_info, hs_var_sp1_thy_info, hs_var_sp2_thy_info, var_sp1_method_dct, var_sp2_method_dct, vscnlvl_scn_run_fs, vscnlvl_scn_save_fs, inf_locs, overwrite=overwrite, **cas_kwargs) else: vscn_thy_info = thy_inf_dct['var_scnlvl'] _inf_sep_ene = _singleref_inf_sep_ene(rct_info, thy_info, vscn_thy_info, rcts_cnf_fs, run_prefix, vscn_method_dct, overwrite) if _inf_sep_ene is not None: ioprinter.energy(_inf_sep_ene) else: ioprinter.warning_message('Infinite separation ene not computed') return _inf_sep_ene
def thy_dcts(tsname, ts_dct, thy_dct, es_keyword_dct, run_prefix, save_prefix): """ set the theory """ # Get transition state info ts_zma = ts_dct['zma'] aspace = ts_dct['active'] # Set reaction info rxn_info = ts_dct['rxn_info'] ts_info = rinfo.ts_info(rxn_info) rct_info = rinfo.rgt_info(rxn_info, 'reacs') rxn_info_sort = rinfo.sort(rxn_info) # Set the high-sping ts info high_mult = rinfo.ts_mult(rxn_info, rxn_mul='high') hs_info = (ts_info[0], ts_info[1], high_mult) # Set the filesystem locs ts_locs = (int(tsname.split('_')[-1]),) zma_locs = (ts_dct.get('zma_idx', 0),) # Initialize the theory objects ini_thy_info, mod_ini_thy_info = None, None thy_info, mod_thy_info = None, None vscnlvl_thy_info, mod_vscnlvl_thy_info = None, None vsp1lvl_thy_info, mod_vsp1lvl_thy_info = None, None vsp2lvl_thy_info, mod_vsp2lvl_thy_info = None, None hs_vscnlvl_thy_info = None hs_vsp1lvl_thy_info = None hs_vsp2lvl_thy_info = None hs_thy_info = None # Method dicts ini_method_dct = None run_method_dct = None vscn_method_dct = None vsp1_method_dct = None vsp2_method_dct = None # Multireference Params inplvl_mref_params = {} runlvl_mref_params = {} vscn_mref_params = {} vsp1_mref_params = {} vsp2_mref_params = {} # Initialize the necessary run filesystem runlvl_scn_run_fs = None runlvl_cscn_run_fs = None vscnlvl_ts_run_fs = None vscnlvl_scn_run_fs = None vscnlvl_cscn_run_fs = None vrctst_run_fs = None # Initialize the necessary save filesystem inplvl_cnf_save_fs = None runlvl_scn_save_fs = None # above cnf filesys, for search scans runlvl_cscn_save_fs = None # above cnf filesys, for search scans runlvl_cnf_save_fs = None vscnlvl_scn_save_fs = None vscnlvl_cscn_save_fs = None vrctst_save_fs = None if es_keyword_dct.get('inplvl', None) is not None: ini_method_dct = thy_dct.get(es_keyword_dct['inplvl']) ini_thy_info = tinfo.from_dct(ini_method_dct) mod_ini_thy_info = tinfo.modify_orb_label( ini_thy_info, ts_info) # Conformer Layer for saddle point structures _, inplvl_cnf_save_fs = build_fs( run_prefix, save_prefix, 'CONFORMER', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_ini_thy_info[1:]) inplvl_loc_info = filesys.mincnf.min_energy_conformer_locators( inplvl_cnf_save_fs, mod_thy_info) inplvl_min_cnf_locs, _ = inplvl_loc_info inplvl_cnf_save_tuple = (inplvl_cnf_save_fs, inplvl_min_cnf_locs) if elstruct.par.Method.is_multiref(ini_thy_info[1]): inplvl_mref_params = multireference_calculation_parameters( ts_zma, ts_info, hs_info, aspace, mod_ini_thy_info, rxn_info=rxn_info) if es_keyword_dct.get('runlvl', None) is not None: run_method_dct = thy_dct.get(es_keyword_dct['runlvl']) thy_info = tinfo.from_dct(run_method_dct) mod_thy_info = tinfo.modify_orb_label( thy_info, ts_info) hs_thy_info = tinfo.modify_orb_label( thy_info, hs_info) # Conformer Layer for saddle point structures runlvl_cnf_run_fs, runlvl_cnf_save_fs = build_fs( run_prefix, save_prefix, 'CONFORMER', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_thy_info[1:]) runlvl_loc_info = filesys.mincnf.min_energy_conformer_locators( runlvl_cnf_save_fs, mod_thy_info) runlvl_min_cnf_locs, _ = runlvl_loc_info runlvl_cnf_save_tuple = (runlvl_cnf_save_fs, runlvl_min_cnf_locs) # TS/IDX/Z Layer used for coordinate scans (perhaps for guesses) _, runlvl_z_save_fs = build_fs( run_prefix, save_prefix, 'ZMATRIX', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_thy_info[1:]) runlvl_scn_run_fs, runlvl_scn_save_fs = build_fs( run_prefix, save_prefix, 'SCAN', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_thy_info[1:], zma_locs=zma_locs) runlvl_cscn_run_fs, runlvl_cscn_save_fs = build_fs( run_prefix, save_prefix, 'CSCAN', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_thy_info[1:], zma_locs=zma_locs) if elstruct.par.Method.is_multiref(thy_info[1]): runlvl_mref_params = multireference_calculation_parameters( ts_zma, ts_info, hs_info, aspace, mod_thy_info, rxn_info=rxn_info) if es_keyword_dct.get('var_scnlvl', None) is not None: vscn_method_dct = thy_dct.get(es_keyword_dct['var_scnlvl']) vscnlvl_thy_info = tinfo.from_dct(vscn_method_dct) mod_vscnlvl_thy_info = tinfo.modify_orb_label( vscnlvl_thy_info, ts_info) hs_vscnlvl_thy_info = tinfo.modify_orb_label( vscnlvl_thy_info, hs_info) vscnlvl_scn_run_fs, vscnlvl_scn_save_fs = build_fs( run_prefix, save_prefix, 'SCAN', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_vscnlvl_thy_info[1:], zma_locs=zma_locs) vscnlvl_cscn_run_fs, vscnlvl_cscn_save_fs = build_fs( run_prefix, save_prefix, 'CSCAN', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_vscnlvl_thy_info[1:], zma_locs=zma_locs) vrctst_run_fs, vrctst_save_fs = build_fs( run_prefix, save_prefix, 'VRCTST', rxn_locs=rxn_info_sort, ts_locs=ts_locs, thy_locs=mod_vscnlvl_thy_info[1:]) if elstruct.par.Method.is_multiref(vscnlvl_thy_info[1]): vscn_mref_params = multireference_calculation_parameters( ts_zma, ts_info, hs_info, aspace, mod_vscnlvl_thy_info, rxn_info=rxn_info) if es_keyword_dct.get('var_splvl1', None) is not None: vsp1_method_dct = thy_dct.get(es_keyword_dct['var_splvl1']) vsp1lvl_thy_info = tinfo.from_dct(vsp1_method_dct) mod_vsp1lvl_thy_info = tinfo.modify_orb_label( vsp1lvl_thy_info, ts_info) hs_vsp1lvl_thy_info = tinfo.modify_orb_label( vsp1lvl_thy_info, hs_info) if elstruct.par.Method.is_multiref(vsp1lvl_thy_info[1]): vsp1_mref_params = multireference_calculation_parameters( ts_zma, ts_info, hs_info, aspace, mod_vsp1lvl_thy_info, rxn_info=rxn_info) if es_keyword_dct.get('var_splvl2', None) is not None: vsp2_method_dct = thy_dct.get(es_keyword_dct['var_splvl2']) vsp2lvl_thy_info = tinfo.from_dct(vsp2_method_dct) mod_vsp2lvl_thy_info = tinfo.modify_orb_label( vsp2lvl_thy_info, ts_info) hs_vsp2lvl_thy_info = tinfo.modify_orb_label( vsp2lvl_thy_info, hs_info) if elstruct.par.Method.is_multiref(vsp2lvl_thy_info[1]): vsp2_mref_params = multireference_calculation_parameters( ts_zma, ts_info, hs_info, aspace, mod_vsp2lvl_thy_info, rxn_info=rxn_info) # Get the conformer filesys for the reactants _rcts_cnf_fs = rcts_cnf_fs(rct_info, ini_thy_info, run_prefix, save_prefix) if _rcts_cnf_fs is None: _rcts_cnf_fs = rcts_cnf_fs(rct_info, thy_info, run_prefix, save_prefix) thy_inf_dct = { 'inplvl': ini_thy_info, 'runlvl': thy_info, 'var_scnlvl': vscnlvl_thy_info, 'var_splvl1': vsp1lvl_thy_info, 'var_splvl2': vsp2lvl_thy_info, 'mod_inplvl': mod_ini_thy_info, 'mod_runlvl': mod_thy_info, 'mod_var_scnlvl': mod_vscnlvl_thy_info, 'mod_var_splvl1': mod_vsp1lvl_thy_info, 'mod_var_splvl2': mod_vsp2lvl_thy_info, 'hs_var_scnlvl': hs_vscnlvl_thy_info, 'hs_var_splvl1': hs_vsp1lvl_thy_info, 'hs_var_splvl2': hs_vsp2lvl_thy_info, 'hs_runlvl': hs_thy_info, 'rct_info': rct_info } thy_method_dct = { 'inplvl': ini_method_dct, 'runlvl': run_method_dct, 'var_scnlvl': vscn_method_dct, 'var_splvl1': vsp1_method_dct, 'var_splvl2': vsp2_method_dct, } mref_params_dct = { 'inplvl': inplvl_mref_params, 'runlvl': runlvl_mref_params, 'var_scnlvl': vscn_mref_params, 'var_splvl1': vsp1_mref_params, 'var_splvl2': vsp2_mref_params, } runfs_dct = { 'runlvl_scn': runlvl_scn_run_fs, 'runlvl_cscn': runlvl_cscn_run_fs, 'runlvl_cnf': runlvl_cnf_run_fs, 'vscnlvl_ts': vscnlvl_ts_run_fs, 'vscnlvl_scn': vscnlvl_scn_run_fs, 'vscnlvl_cscn': vscnlvl_cscn_run_fs, 'vrctst': vrctst_run_fs, 'prefix': run_prefix } savefs_dct = { 'runlvl_scn': runlvl_scn_save_fs, 'runlvl_cscn': runlvl_cscn_save_fs, 'runlvl_ts_zma': runlvl_z_save_fs, 'inplvl_cnf_tuple': inplvl_cnf_save_tuple, 'runlvl_cnf_tuple': runlvl_cnf_save_tuple, 'vscnlvl_scn': vscnlvl_scn_save_fs, 'vscnlvl_cscn': vscnlvl_cscn_save_fs, 'vrctst': vrctst_save_fs, 'rcts_cnf': _rcts_cnf_fs, 'prefix': save_prefix } return (thy_inf_dct, thy_method_dct, mref_params_dct, runfs_dct, savefs_dct)
def conformer_tsk(job, spc_dct, spc_name, thy_dct, es_keyword_dct, run_prefix, save_prefix): """ Launch tasks associated with conformers. Scan: Generate a set of conformer geometries and energies via random sampling over torsional coordinates following by optimization SP: Calculate ene, grad, .. """ saddle = bool('ts_' in spc_name) spc_dct_i = spc_dct[spc_name] # Set the spc_info if not saddle: spc_info = sinfo.from_dct(spc_dct_i) else: spc_info = rinfo.ts_info(spc_dct_i['rxn_info']) zrxn = spc_dct_i.get('zrxn', None) overwrite = es_keyword_dct['overwrite'] retryfail = es_keyword_dct['retryfail'] # Modify the theory method_dct = thy_dct.get(es_keyword_dct['runlvl']) ini_method_dct = thy_dct.get(es_keyword_dct['inplvl']) thy_info = tinfo.from_dct(method_dct) ini_thy_info = tinfo.from_dct(ini_method_dct) mod_thy_info = tinfo.modify_orb_label(thy_info, spc_info) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, spc_info) # New filesystem objects _root = root_locs(spc_dct_i, saddle=saddle, name=spc_name) ini_cnf_run_fs, ini_cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_ini_thy_info[1:], **_root) cnf_run_fs, cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_thy_info[1:], **_root) if job == 'samp': # Build the ini zma filesys ini_loc_info = filesys.mincnf.min_energy_conformer_locators( ini_cnf_save_fs, mod_ini_thy_info) ini_locs, ini_min_cnf_path = ini_loc_info ini_min_rid, ini_min_cid = ini_locs ini_zma_save_fs = autofile.fs.zmatrix(ini_min_cnf_path) # Set up the run scripts script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) # Set variables if it is a saddle two_stage = saddle mc_nsamp = spc_dct_i['mc_nsamp'] resave = es_keyword_dct['resave'] # Read the geometry and zma from the ini file system geo = ini_cnf_save_fs[-1].file.geometry.read(ini_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read([0]) # Read the torsions from the ini file sys if ini_zma_save_fs[-1].file.torsions.exists([0]): tors_dct = ini_zma_save_fs[-1].file.torsions.read([0]) rotors = automol.rotor.from_data(zma, tors_dct) tors_names = automol.rotor.names(rotors, flat=True) else: tors_names = () geo_path = ini_cnf_save_fs[-1].path(ini_locs) ioprinter.initial_geom_path('Sampling started', geo_path) # Check runsystem for equal ring CONF make conf_fs # Else make new ring conf directory rid = conformer.rng_loc_for_geo(geo, cnf_run_fs, cnf_save_fs) if rid is None: conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, **kwargs) rid = conformer.rng_loc_for_geo(geo, cnf_run_fs, cnf_save_fs) # Run the sampling conformer.conformer_sampling(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, rid, script_str, overwrite, nsamp_par=mc_nsamp, tors_names=tors_names, zrxn=zrxn, two_stage=two_stage, retryfail=retryfail, resave=resave, **kwargs) elif job == 'pucker': # Build the ini zma filesys ini_loc_info = filesys.mincnf.min_energy_conformer_locators( ini_cnf_save_fs, mod_ini_thy_info) ini_min_locs, ini_min_cnf_path = ini_loc_info ini_min_rid, ini_min_cid = ini_min_locs ini_zma_save_fs = autofile.fs.zmatrix(ini_min_cnf_path) # Set up the run scripts script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) # Set variables if it is a saddle two_stage = saddle mc_nsamp = spc_dct_i['mc_nsamp'] # Read the geometry and zma from the ini file system geo = ini_cnf_save_fs[-1].file.geometry.read(ini_min_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read([0]) # Read the torsions from the ini file sys if ini_zma_save_fs[-1].file.ring_torsions.exists([0]): ring_tors_dct = ini_zma_save_fs[-1].file.ring_torsions.read([0]) else: ring_tors_dct = {} geo_path = ini_cnf_save_fs[-1].path(ini_min_locs) ioprinter.initial_geom_path('Sampling started', geo_path) # Run the sampling conformer.ring_conformer_sampling(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, nsamp_par=mc_nsamp, ring_tors_dct=ring_tors_dct, zrxn=zrxn, two_stage=two_stage, retryfail=retryfail, **kwargs) elif job == 'opt': cnf_range = es_keyword_dct['cnf_range'] ioprinter.debug_message('range', cnf_range) # Set up the run scripts script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) ini_loc_info = filesys.mincnf.min_energy_conformer_locators( ini_cnf_save_fs, mod_ini_thy_info) ini_min_locs, ini_min_cnf_path = ini_loc_info ini_min_rid, ini_min_cid = ini_min_locs rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( cnf_save_fs, mod_thy_info, cnf_range='all') ini_rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( ini_cnf_save_fs, mod_ini_thy_info, cnf_range=cnf_range) # Truncate the list of the ini confs uni_rng_locs_lst, uni_cnf_locs_lst = conformer.unique_fs_ring_confs( cnf_save_fs, rng_cnf_locs_lst, ini_cnf_save_fs, ini_rng_cnf_locs_lst) ioprinter.debug_message('uni lst that has no similar ring', uni_rng_locs_lst) ioprinter.debug_message('uni lst that has similar ring', uni_cnf_locs_lst) for locs in uni_rng_locs_lst: rid, cid = locs # Obtain the zma from ini loc ini_cnf_save_path = ini_cnf_save_fs[-1].path(locs) ini_zma_save_fs = autofile.fs.zmatrix(ini_cnf_save_path) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) # Make the ring filesystem conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, use_locs=locs, **kwargs) for locs in uni_cnf_locs_lst: ini_locs, rid = locs ini_rid, ini_cid = ini_locs # Obtain the zma from ini loc ini_cnf_save_path = ini_cnf_save_fs[-1].path(ini_locs) ini_zma_save_fs = autofile.fs.zmatrix(ini_cnf_save_path) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) # obtain conformer filesystem associated with the ring at the runlevel cid = autofile.schema.generate_new_conformer_id() conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, use_locs=(rid, cid), **kwargs) rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( cnf_save_fs, mod_thy_info, cnf_range=cnf_range) for locs in rng_cnf_locs_lst: geo = cnf_save_fs[-1].file.geometry.read(locs) ioprinter.geometry(geo) elif job in ('energy', 'grad', 'hess', 'vpt2', 'prop'): cnf_range = es_keyword_dct['cnf_range'] ini_rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( ini_cnf_save_fs, mod_ini_thy_info, cnf_range=cnf_range) # Check if locs exist, kill if it doesn't if not ini_rng_cnf_locs_lst: ioprinter.error_message('No min-energy conformer found for level:') sys.exit() # Set up the run scripts script_str, kwargs = qchem_params(method_dct) # Run the job over all the conformers requested by the user for ini_locs in ini_rng_cnf_locs_lst: ini_rid, ini_cid = ini_locs ioprinter.running('task for conformer: ', ini_locs, newline=2) ini_cnf_run_fs[-1].create(ini_locs) geo_run_path = ini_cnf_run_fs[-1].path(ini_locs) geo_save_path = ini_cnf_save_fs[-1].path(ini_locs) ini_zma_save_fs = autofile.fs.zmatrix(geo_save_path) ioprinter.debug_message('reading geometry from ', geo_save_path) geo = ini_cnf_save_fs[-1].file.geometry.read(ini_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) ES_TSKS[job](zma, geo, spc_info, mod_thy_info, ini_cnf_save_fs, geo_run_path, geo_save_path, ini_locs, script_str, overwrite, retryfail=retryfail, **kwargs)
def optimize_saddle_point(guess_zmas, ts_dct, method_dct, mref_kwargs, runfs_dct, es_keyword_dct, cnf_locs): """ Optimize the transition state structure obtained from the grid search """ # Get info (move later) ts_info = rinfo.ts_info(ts_dct['rxn_info']) mod_thy_info = tinfo.modify_orb_label(tinfo.from_dct(method_dct), ts_info) overwrite = es_keyword_dct['overwrite'] ts_info = rinfo.ts_info(ts_dct['rxn_info']) runlvl_cnf_run_fs = runfs_dct['runlvl_cnf'] runlvl_cnf_run_fs[-1].create(cnf_locs) run_fs = autofile.fs.run(runlvl_cnf_run_fs[-1].path(cnf_locs)) ioprinter.info_message( f'There are {len(guess_zmas)} guess Z-Matrices' 'to attempt to find saddle point.', newline=1) # Loop over all the guess zmas to find a TS opt_ret, hess_ret = None, None for idx, zma in enumerate(guess_zmas): ioprinter.info_message(f'\nOptimizing guess Z-Matrix {idx+1}...') # Run the transition state optimization script_str, kwargs = qchem_params(method_dct, job=elstruct.Job.OPTIMIZATION) kwargs.update(mref_kwargs) opt_success, opt_ret = es_runner.execute_job( job='optimization', script_str=script_str, run_fs=run_fs, geo=zma, spc_info=ts_info, thy_info=mod_thy_info, saddle=True, overwrite=overwrite, **kwargs, ) if opt_success: break if opt_success: script_str, kwargs = qchem_params(method_dct) # Obtain geometry from optimization opt_inf_obj, _, opt_out_str = opt_ret opt_prog = opt_inf_obj.prog geo = elstruct.reader.opt_geometry(opt_prog, opt_out_str) # Run a Hessian _, hess_ret = es_runner.execute_job( job='hessian', script_str=script_str, run_fs=run_fs, geo=geo, spc_info=ts_info, thy_info=mod_thy_info, overwrite=overwrite, **kwargs, ) return opt_ret, hess_ret
def scan_for_guess(ts_dct, method_dct, runfs_dct, savefs_dct, es_keyword_dct): """ saddle point scan code """ print(' - No Z-Matrix is found in save filesys.') print('\nRunning scan to generate guess Z-Matrix for opt...') # Get es keyword info overwrite = es_keyword_dct['overwrite'] retryfail = es_keyword_dct['retryfail'] # Get info from the dct ts_zma = ts_dct['zma'] zrxn = ts_dct['zrxn'] # convert to zrxn ts_info = rinfo.ts_info(ts_dct['rxn_info']) scn_save_fs = savefs_dct['runlvl_scn_fs'] # Build grid and names appropriate for reaction type scan_inf = automol.reac.build_scan_info(zrxn, ts_zma) coord_names, constraint_dct, coord_grids, update_guess = scan_inf # Get filesystem information if constraint_dct is None: scn_run_fs = runfs_dct['runlvl_scn_fs'] scn_save_fs = savefs_dct['runlvl_scn_fs'] else: scn_run_fs = runfs_dct['runlvl_cscn_fs'] scn_save_fs = savefs_dct['runlvl_cscn_fs'] # Set up script string and kwargs mod_thy_info = tinfo.modify_orb_label(tinfo.from_dct(method_dct), ts_info) script_str, kwargs = qchem_params(method_dct, job=elstruct.Job.OPTIMIZATION) es_runner.scan.execute_scan( zma=ts_zma, spc_info=ts_info, mod_thy_info=mod_thy_info, coord_names=coord_names, coord_grids=coord_grids, scn_run_fs=scn_run_fs, scn_save_fs=scn_save_fs, scn_typ='relaxed', script_str=script_str, overwrite=overwrite, zrxn=zrxn, update_guess=update_guess, reverse_sweep=False, saddle=False, constraint_dct=constraint_dct, retryfail=retryfail, **kwargs, ) guess_zmas = rxngrid.grid_maximum_zmatrices(zrxn.class_, ts_zma, coord_grids, coord_names, scn_save_fs, mod_thy_info, constraint_dct) return guess_zmas
def parse_user_reaction(insert_dct): smis = insert_dct['smiles'] ichs = insert_dct['inchi'] mults = insert_dct['mult'] chgs = insert_dct['charge'] rxn_class = insert_dct['rxn_class'] # zrxn_file = insert_dct['zrxn_file'] if ichs is None: ichs = [[], []] for smi in smis[0]: ichs[0].append(automol.smiles.inchi(smi)) for smi in smis[1]: ichs[1].append(automol.smiles.inchi(smi)) for idx, ich in enumerate(ichs[0]): if not automol.inchi.is_complete(ich): ich = automol.inchi.add_stereo(ich) ichs[0][idx] = ich for idx, ich in enumerate(ichs[1]): if not automol.inchi.is_complete(ich): ich = automol.inchi.add_stereo(ich) ichs[1][idx] = ich if mults is None: print('Error: user did not specify mults in input') sys.exit() if chgs is None: print('Error: user did not specify charges in input') sys.exit() flat_ichs = sum(ichs, []) if len(flat_ichs) != len(mults): print('Error: number of species does not match number of mults') sys.exit() if len(flat_ichs) != len(chgs): print('Error: number of species does not match number of charges') sys.exit() idx = 0 rxn_muls = [[], []] rxn_chgs = [[], []] for ich in ichs[0]: mults_allowed = automol.graph.possible_spin_multiplicities( automol.inchi.graph(ich, stereo=False)) if mults[idx] not in mults_allowed: print('user specified mult of {}'.format(mults[idx]) + 'is not an allowed multiplicty for inchi {}'.format(ich)) sys.exit() rxn_muls[0].append(mults[idx]) rxn_chgs[0].append(chgs[idx]) idx += 1 for ich in ichs[1]: mults_allowed = automol.graph.possible_spin_multiplicities( automol.inchi.graph(ich, stereo=False)) if mults[idx] not in mults_allowed: print('user specified mult of {}'.format(mults[idx]) + 'is not an allowed multiplicty for inchi {}'.format(ich)) sys.exit() rxn_muls[1].append(mults[idx]) rxn_chgs[1].append(chgs[idx]) idx += 1 ts_mult = insert_dct['ts_mult'] if ts_mult is None: print('Error: user did not specify ts_mul') sys.exit() rxn_info = rinfo.sort((ichs, rxn_chgs, rxn_muls, ts_mult)) ts_info = rinfo.ts_info(rxn_info) # if zrxn_file is not None: # zrxn_str = autofile.io_.read_file(zrxn_file) # zrxns = [automol.reac.from_string(zrxn_str)] # else: # zrxns, _ = _id_reaction(rxn_info) if rxn_class is None: print('Error: user did not specify rxn_class') sys.exit() return rxn_info, ts_info, rxn_class
def rpath_tsk(job, spc_dct, spc_name, thy_inf_dct, thy_method_dct, mref_dct, es_keyword_dct, runfs_dct, savefs_dct): """ run a scan over the specified torsional coordinate :param job: :type job: :param spc_dct: :type spc_dct: :param spc_name: :type spc_name: :param thy_dct: :type thy_dct: :param es_keyword_dct: keyword-value pairs for electronic structure tsk :type es_keyword_dct: dict[str:str] :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 """ # Get dct for specific species task is run for ts_dct = spc_dct[spc_name] ts_info = rinfo.ts_info(ts_dct['rxn_info']) # # Build various thy and filesystem objects # thy_inf_dct, thy_method_dct, mref_dct, runfs_dct, savefs_dct = thy_dcts( # spc_name, spc_dct[spc_name], thy_dct, es_keyword_dct, # run_prefix, save_prefix) mod_thy_info = thy_inf_dct['mod_runlvl'] mod_ini_thy_info = thy_inf_dct['mod_inplvl'] method_dct = thy_method_dct['runlvl'] ini_method_dct = thy_method_dct['inplvl'] mref_params = mref_dct['runlvl'] # Build filesys objects scn_alg, scn_fs, cnf_fs, cnf_locs = rpath_fs( ts_dct, spc_name, mod_ini_thy_info, es_keyword_dct, runfs_dct['prefix'], savefs_dct['prefix']) print('alg set test', scn_alg) # Run job if job == 'scan': if 'irc' in scn_alg: zmas = irc.launch_point_zmatrices( ts_dct, mod_thy_info, scn_alg, scn_fs, cnf_fs, cnf_locs) for zma in zmas: success = irc.execute_irc( zma, ts_info, mod_ini_thy_info, ini_method_dct, scn_fs[0], scn_fs[1], es_keyword_dct) if success: break else: zma, zrxn, rclass, = ts_dct['zma'], ts_dct['zrxn'], ts_dct['class'] _ = rpath.internal_coordinates_scan( zma, zrxn, ts_info, rclass, method_dct, mref_params, scn_fs[0], scn_fs[1], es_keyword_dct) elif job in ('energy', 'grad', 'hess'): # Set run-time options overwrite = es_keyword_dct['overwrite'] script_str, kwargs = qchem_params(method_dct) # Run along the scan and calculate desired quantities ini_scn_run_fs, ini_scn_save_fs = scn_fs for locs in ini_scn_save_fs[-1].existing(): geo = ini_scn_save_fs[-1].file.geometry.read(locs) ini_scn_run_fs[-1].create(locs) ES_TSKS[job]( None, geo, ts_info, mod_thy_info, ini_scn_run_fs, ini_scn_save_fs, locs, script_str, overwrite, **kwargs) ioprinter.obj('vspace') elif job == 'infene': rpath.inf_sep_ene( ts_dct, thy_inf_dct, mref_dct, savefs_dct, runfs_dct, es_keyword_dct)
def hr_tsk(job, spc_dct, spc_name, thy_dct, es_keyword_dct, run_prefix, save_prefix): """ Prepares and executes all electronic structure tasks that generate information for points along hindered-rotor coordinate scans which are launched from some conformer in the save filesystem. For species and transition state conformers. This includes scanning procedures to generate geometries (relaxed) or energies (rigid) points along conformer structures, as well as __ calculations using some saved conformer as input. :param job: :type job: :param spc_dct: :type spc_dct: :param spc_name: :type spc_name: :param thy_dct: :type thy_dct: :param es_keyword_dct: keyword-val pairs for electronic structure task :type es_keyword_dct: dict[str:str] :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 """ spc_dct_i = spc_dct[spc_name] saddle = bool('ts_' in spc_name) # Set the spc_info if not saddle: spc_info = sinfo.from_dct(spc_dct_i) else: spc_info = rinfo.ts_info(spc_dct_i['rxn_info']) # Get options from the dct or es options lst overwrite = es_keyword_dct['overwrite'] retryfail = es_keyword_dct['retryfail'] tors_model = es_keyword_dct['tors_model'] # nprocs = es_keyword_dct['nprocs'] nprocs = 1 # Modify the theory method_dct = thy_dct.get(es_keyword_dct['runlvl']) ini_method_dct = thy_dct.get(es_keyword_dct['inplvl']) thy_info = tinfo.from_dct(method_dct) ini_thy_info = tinfo.from_dct(ini_method_dct) mod_thy_info = tinfo.modify_orb_label(thy_info, spc_info) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, spc_info) # Set the filesystem objects _root = root_locs(spc_dct_i, saddle=saddle, name=spc_name) _, ini_cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_ini_thy_info[1:], **_root) cnf_run_fs, cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_thy_info[1:], **_root) cnf_range = es_keyword_dct['cnf_range'] hbond_cutoffs = spc_dct_i['hbond_cutoffs'] user_conf_ids = spc_dct_i.get('conf_id') if user_conf_ids is None: cnf_sort_info_lst = _sort_info_lst(es_keyword_dct['sort'], thy_dct, spc_info) ini_min_locs_lst, ini_path_lst = filesys.mincnf.conformer_locators( ini_cnf_save_fs, mod_ini_thy_info, cnf_range=cnf_range, sort_info_lst=cnf_sort_info_lst, hbond_cutoffs=hbond_cutoffs, print_enes=True, nprocs=nprocs) else: ini_min_locs_lst = (user_conf_ids, ) ini_path_lst = (ini_cnf_save_fs[-1].path(user_conf_ids), ) all_run_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( cnf_save_fs, mod_thy_info, cnf_range='all', nprocs=nprocs) ini_to_run_locs_dct = filesys.mincnf.fs_confs_dict(cnf_save_fs, all_run_cnf_locs_lst, ini_cnf_save_fs, ini_min_locs_lst) for ini_min_locs, ini_cnf_save_path in zip(ini_min_locs_lst, ini_path_lst): # Read zma, geo, and torsions ini_zma_save_fs = autofile.fs.zmatrix(ini_cnf_save_path) geo = ini_cnf_save_fs[-1].file.geometry.read(ini_min_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) if ini_zma_save_fs[-1].file.torsions.exists([0]): tors_dct = ini_zma_save_fs[-1].file.torsions.read([0]) torsions = automol.rotor.from_data( zma, tors_dct, ) else: torsions = () zrxn = spc_dct_i.get('zrxn', None) # Run the task if any torsions exist if any(torsions): # Find equivalent conformer in the run filesys, if it doesn't exist # run a single conformer to generate it min_locs = ini_to_run_locs_dct[tuple(ini_min_locs)] if min_locs is None: script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) rid = conformer.rng_loc_for_geo(geo, cnf_save_fs) if rid is None: new_rid = autofile.schema.generate_new_ring_id() new_cid = autofile.schema.generate_new_conformer_id() conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, use_locs=(new_rid, new_cid), **kwargs) min_locs = (new_rid, new_cid) else: new_cid = autofile.schema.generate_new_conformer_id() conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, use_locs=(rid, new_cid), **kwargs) min_locs = (rid, new_cid) save_locs = cnf_save_fs[-1].existing() if min_locs not in save_locs: locinf = filesys.mincnf.this_conformer_was_run_in_run( zma, cnf_run_fs) _, sym_locs_lst = locinf for sym_locs in sym_locs_lst: if sym_locs in save_locs: min_locs = sym_locs cnf_save_path = cnf_save_fs[-1].path(min_locs) ioprinter.info_message( f'Same conformer saved at {ini_cnf_save_path} ' f'and {cnf_save_path}') # Create run fs if that directory has been deleted to run the jobs # ini_cnf_run_fs[-1].create(ini_min_locs) # ini_cnf_run_path = ini_cnf_run_fs[-1].path(ini_min_locs) cnf_run_fs[-1].create(min_locs) cnf_run_path = cnf_run_fs[-1].path(min_locs) # Get the runlvl zma and torsion info zma_save_fs = autofile.fs.zmatrix(cnf_save_path) geo = cnf_save_fs[-1].file.geometry.read(min_locs) zma = zma_save_fs[-1].file.zmatrix.read((0, )) if zma_save_fs[-1].file.torsions.exists([0]): tors_dct = zma_save_fs[-1].file.torsions.read([0]) torsions = automol.rotor.from_data( zma, tors_dct, ) else: torsions = () if 'fa' in tors_model: scn = 'CSCAN' elif 'f' in tors_model: if len(torsions) > 1: scn = 'CSCAN' else: scn = 'SCAN' else: scn = 'SCAN' # ini_scn_run_fs, ini_scn_save_fs = build_fs( # ini_cnf_run_path, ini_cnf_save_path, scn, # zma_locs=(0,)) scn_run_fs, scn_save_fs = build_fs(cnf_run_path, cnf_save_path, scn, zma_locs=(0, )) if job == 'scan': increment = spc_dct_i.get('hind_inc', 30.0 * phycon.DEG2RAD) hr.hindered_rotor_scans(zma, spc_info, mod_thy_info, scn_run_fs, scn_save_fs, torsions, tors_model, method_dct, overwrite, zrxn=zrxn, saddle=saddle, increment=increment, retryfail=retryfail) elif job == 'reopt': script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) # pull stuff from dcts ethresh = es_keyword_dct['hrthresh'] increment = spc_dct_i.get('hind_inc', 30.0 * phycon.DEG2RAD) zrxn = spc_dct_i.get('zrxn', None) run_tors_names = automol.rotor.names(torsions) run_tors_grids = automol.rotor.grids(torsions, increment=increment) # Set constraints const_names = automol.zmat.set_constraint_names( zma, run_tors_names, tors_model) # Read and print the potential sp_fs = autofile.fs.single_point(cnf_save_path) ref_ene = sp_fs[-1].file.energy.read(mod_thy_info[1:4]) tors_pots, tors_zmas, tors_paths = {}, {}, {} for tors_names, tors_grids in zip(run_tors_names, run_tors_grids): constraint_dct = automol.zmat.constraint_dct( zma, const_names, tors_names) pot, _, _, _, zmas, paths = filesys.read.potential( tors_names, tors_grids, cnf_save_path, mod_thy_info, ref_ene, constraint_dct, read_zma=True) tors_pots[tors_names] = pot tors_zmas[tors_names] = zmas tors_paths[tors_names] = paths # Check for new minimum conformer new_min_zma = hr.check_hr_pot(tors_pots, tors_zmas, tors_paths, emax=ethresh) if new_min_zma is not None: ioprinter.info_message( 'Finding new low energy conformer...', newline=1) new_min_geo = automol.zmat.geometry(new_min_zma) rid = conformer.rng_loc_for_geo(new_min_geo, cnf_save_fs) if rid is None: new_locs = None else: cid = autofile.schema.generate_new_conformer_id() new_locs = (rid, cid) conformer.single_conformer(new_min_zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, use_locs=new_locs, **kwargs) elif job in ('energy', 'grad', 'hess', 'vpt2'): # Script (add energy script call) script_str, kwargs = qchem_params(method_dct) run_tors_names = automol.rotor.names(torsions, flat=True) for tors_names in run_tors_names: # Set the constraint dct and filesys for the scan const_names = automol.zmat.set_constraint_names( zma, run_tors_names, tors_model) constraint_dct = automol.zmat.constraint_dct( zma, const_names, tors_names) # get the scn_locs, maybe get a function? _, scn_locs = scan.scan_locs(scn_save_fs, tors_names, constraint_dct=constraint_dct) for locs in scn_locs: geo = scn_save_fs[-1].file.geometry.read(locs) zma = scn_save_fs[-1].file.zmatrix.read(locs) scn_run_fs[-1].create(locs) ES_TSKS[job](zma, geo, spc_info, mod_thy_info, scn_run_fs, scn_save_fs, locs, run_prefix, script_str, overwrite, zrxn=zrxn, retryfail=retryfail, **kwargs) ioprinter.obj('vspace') else: ioprinter.info_message('No torsional modes in the species')
def hr_tsk(job, spc_dct, spc_name, thy_dct, es_keyword_dct, run_prefix, save_prefix): """ run a scan over the specified torsional coordinates """ spc_dct_i = spc_dct[spc_name] saddle = bool('ts_' in spc_name) # Set the spc_info if not saddle: spc_info = sinfo.from_dct(spc_dct_i) else: spc_info = rinfo.ts_info(spc_dct_i['rxn_info']) # Modify the theory method_dct = thy_dct.get(es_keyword_dct['runlvl']) ini_method_dct = thy_dct.get(es_keyword_dct['inplvl']) thy_info = tinfo.from_dct(method_dct) ini_thy_info = tinfo.from_dct(ini_method_dct) mod_thy_info = tinfo.modify_orb_label(thy_info, spc_info) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, spc_info) # Set the filesystem objects _root = root_locs(spc_dct_i, saddle=saddle, name=spc_name) ini_cnf_run_fs, ini_cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_ini_thy_info[1:], **_root) cnf_run_fs, cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_thy_info[1:], **_root) instab_save_fs = () ini_loc_info = filesys.mincnf.min_energy_conformer_locators( ini_cnf_save_fs, mod_ini_thy_info) ini_min_locs, ini_cnf_save_path = ini_loc_info # ini_min_rng_locs, ini_min_cnf_locs = ini_min_cnf_locs # ini_min_rng_path, ini_min_cnf_path = ini_min_cnf_path # Create run fs if that directory has been deleted to run the jobs ini_cnf_run_fs[-1].create(ini_min_locs) ini_cnf_run_path = ini_cnf_run_fs[-1].path(ini_min_locs) # Get options from the dct or es options lst overwrite = es_keyword_dct['overwrite'] retryfail = es_keyword_dct['retryfail'] tors_model = es_keyword_dct['tors_model'] # Read zma, geo, and torsions ini_zma_save_fs = autofile.fs.zmatrix(ini_cnf_save_path) geo = ini_cnf_save_fs[-1].file.geometry.read(ini_min_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) if ini_zma_save_fs[-1].file.torsions.exists([0]): tors_dct = ini_zma_save_fs[-1].file.torsions.read([0]) torsions = automol.rotor.from_data( zma, tors_dct, ) else: torsions = () # Run the task if any torsions exist if any(torsions): scn = 'SCAN' if 'fa' not in tors_model else 'CSCAN' ini_scn_run_fs, ini_scn_save_fs = build_fs(ini_cnf_run_path, ini_cnf_save_path, scn, zma_locs=(0, )) if job == 'scan': increment = spc_dct_i.get('hind_inc', 30.0 * phycon.DEG2RAD) hr.hindered_rotor_scans(zma, spc_info, mod_thy_info, instab_save_fs, ini_scn_run_fs, ini_scn_save_fs, torsions, tors_model, method_dct, overwrite, saddle=saddle, increment=increment, retryfail=retryfail) # elif job == 'reopt': # # pull stuff from dcts # two_stage = saddle # rxn_class = spc_dct_i['class'] if saddle else '' # mc_nsamp = spc_dct_i['mc_nsamp'] # ethresh = es_keyword_dct['hrthresh'] # # Read and print the potential # sp_fs = autofile.fs.single_point(ini_cnf_save_path) # ref_ene = sp_fs[-1].file.energy.read(mod_ini_thy_info[1:4]) # # ref_ene = ini_cnf_save_fs[-1].file.energy.read(ini_min_cnf_locs) # tors_pots, tors_zmas, tors_paths = {}, {}, {} # for tors_names, tors_grids in zip(run_tors_names, run_tors_grids): # constraint_dct = automol.zmat.build_constraint_dct( # zma, const_names, tors_names) # pot, _, _, _, zmas, paths = filesys.read.potential( # tors_names, tors_grids, # ini_cnf_save_path, # mod_ini_thy_info, ref_ene, # constraint_dct, # read_zma=True) # tors_pots[tors_names] = pot # tors_zmas[tors_names] = zmas # tors_paths[tors_names] = paths # # Check for new minimum conformer # new_min_zma = __.check_hr_pot( # tors_pots, tors_zmas, tors_paths, emax=ethresh) # if new_min_zma is not None: # ioprinter.info_message( # 'Finding new low energy conformer...', newline=1) # conformer.single_conformer( # zma, spc_info, mod_thy_info, # ini_cnf_run_fs, ini_cnf_save_fs, # script_str, overwrite, # retryfail=retryfail, rxn=rxn, **kwargs) elif job in ('energy', 'grad', 'hess', 'vpt2'): # Script (add energy script call) script_str, kwargs = qchem_params(method_dct) run_tors_names = automol.rotor.names(torsions, flat=True) for tors_names in run_tors_names: # Set the constraint dct and filesys for the scan const_names = automol.zmat.set_constraint_names( zma, run_tors_names, tors_model) constraint_dct = automol.zmat.build_constraint_dct( zma, const_names, tors_names) # get the scn_locs, maybe get a function? scn_locs = () for locs in scn_locs: geo_run_path = ini_scn_run_fs[-1].path(locs) geo_save_path = ini_scn_save_fs[-1].path(locs) geo = ini_scn_save_fs[-1].file.geometry.read(locs) zma = ini_scn_save_fs[-1].file.zmatrix.read(locs) ini_scn_run_fs[-1].create(locs) ES_TSKS[job](zma, geo, spc_info, mod_thy_info, ini_scn_save_fs, geo_run_path, geo_save_path, locs, script_str, overwrite, retryfail=retryfail, **kwargs) ioprinter.obj('vspace') else: ioprinter.info_message('No torsional modes in the species')
def _set_thy_inf_dcts(tsname, ts_dct, thy_dct, es_keyword_dct, run_prefix, save_prefix, zma_locs=(0, )): """ set the theory """ rxn_info = ts_dct['rxn_info'] ts_info = rinfo.ts_info(rxn_info) rct_info = rinfo.rgt_info(rxn_info, 'reacs') rxn_info = rinfo.sort(rxn_info) ts_locs = (int(tsname.split('_')[-1]), ) high_mult = rinfo.ts_mult(rxn_info, rxn_mul='high') # Set the hs info hs_info = (ts_info[0], ts_info[1], high_mult) # Initialize the theory objects ini_thy_info, mod_ini_thy_info = None, None thy_info, mod_thy_info = None, None vscnlvl_thy_info, mod_vscnlvl_thy_info = None, None vsp1lvl_thy_info, mod_vsp1lvl_thy_info = None, None vsp2lvl_thy_info, mod_vsp2lvl_thy_info = None, None hs_vscnlvl_thy_info = None hs_vsp1lvl_thy_info = None hs_vsp2lvl_thy_info = None hs_thy_info = None # Initialize the necessary run filesystem runlvl_ts_run_fs = None runlvl_scn_run_fs = None runlvl_cscn_run_fs = None vscnlvl_ts_run_fs = None vscnlvl_scn_run_fs = None vscnlvl_cscn_run_fs = None vrctst_run_fs = None # Initialize the necessary save filesystem ini_zma_save_fs = None runlvl_ts_save_fs = None runlvl_scn_save_fs = None # above cnf filesys, for search scans runlvl_cscn_save_fs = None # above cnf filesys, for search scans runlvl_cnf_save_fs = None vscnlvl_thy_save_fs = None vscnlvl_ts_save_fs = None vscnlvl_scn_save_fs = None vscnlvl_cscn_save_fs = None vrctst_save_fs = None runlvl_ts_zma_fs = None if es_keyword_dct.get('inplvl', None) is not None: ini_method_dct = thy_dct.get(es_keyword_dct['inplvl']) ini_thy_info = tinfo.from_dct(ini_method_dct) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, ts_info) ini_cnf_run_fs, ini_cnf_save_fs = build_fs( run_prefix, save_prefix, 'CONFORMER', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_ini_thy_info[1:]) ini_loc_info = filesys.mincnf.min_energy_conformer_locators( ini_cnf_save_fs, mod_ini_thy_info) ini_min_cnf_locs, ini_path = ini_loc_info if ini_path: ini_zma_save_fs = autofile.fs.zmatrix( ini_cnf_save_fs[-1].path(ini_min_cnf_locs)) if es_keyword_dct.get('runlvl', None) is not None: method_dct = thy_dct.get(es_keyword_dct['runlvl']) thy_info = tinfo.from_dct(method_dct) mod_thy_info = tinfo.modify_orb_label(thy_info, ts_info) hs_thy_info = tinfo.modify_orb_label(thy_info, hs_info) runlvl_cnf_run_fs, runlvl_cnf_save_fs = build_fs( run_prefix, save_prefix, 'CONFORMER', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_thy_info[1:]) _, runlvl_ts_zma_save_fs = build_fs(run_prefix, save_prefix, 'ZMATRIX', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_thy_info[1:]) runlvl_loc_info = filesys.mincnf.min_energy_conformer_locators( runlvl_cnf_save_fs, mod_thy_info) runlvl_min_cnf_locs, _ = runlvl_loc_info runlvl_cnf_save_fs = (runlvl_cnf_save_fs, runlvl_min_cnf_locs) runlvl_scn_run_fs, runlvl_scn_save_fs = build_fs( run_prefix, save_prefix, 'SCAN', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_thy_info[1:], zma_locs=(0, )) runlvl_cscn_run_fs, runlvl_cscn_save_fs = build_fs( run_prefix, save_prefix, 'CSCAN', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_thy_info[1:], zma_locs=(0, )) if es_keyword_dct.get('var_scnlvl', None) is not None: method_dct = thy_dct.get(es_keyword_dct['var_scnlvl']) vscnlvl_thy_info = tinfo.from_dct(method_dct) mod_vscnlvl_thy_info = tinfo.modify_orb_label(vscnlvl_thy_info, ts_info) hs_vscnlvl_thy_info = tinfo.modify_orb_label(vscnlvl_thy_info, hs_info) vscnlvl_scn_run_fs, vscnlvl_scn_save_fs = build_fs( run_prefix, save_prefix, 'SCAN', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_thy_info[1:], zma_locs=(0, )) vscnlvl_cscn_run_fs, vscnlvl_cscn_save_fs = build_fs( run_prefix, save_prefix, 'CSCAN', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_thy_info[1:], zma_locs=(0, )) vrctst_run_fs, vrctst_save_fs = build_fs(run_prefix, save_prefix, 'VRCTST', rxn_locs=rxn_info, ts_locs=ts_locs, thy_locs=mod_thy_info[1:]) if es_keyword_dct.get('var_splvl1', None) is not None: method_dct = thy_dct.get(es_keyword_dct['var_scnlvl1']) vsplvl1_thy_info = tinfo.from_dct(method_dct) mod_vsplvl1_thy_info = tinfo.modify_orb_label( vsplvl1_thy_info, ts_info) hs_vsplvl1_thy_info = tinfo.modify_orb_label( vsplvl1_thy_info, hs_info) if es_keyword_dct.get('var_splvl2', None) is not None: method_dct = thy_dct.get(es_keyword_dct['var_scnlvl2']) vsplvl2_thy_info = tinfo.from_dct(method_dct) mod_vsplvl2_thy_info = tinfo.modify_orb_label( vsplvl2_thy_info, ts_info) hs_vsplvl2_thy_info = tinfo.modify_orb_label( vsplvl2_thy_info, hs_info) # Get the conformer filesys for the reactants _rcts_cnf_fs = rcts_cnf_fs(rct_info, thy_dct, es_keyword_dct, run_prefix, save_prefix) thy_inf_dct = { 'inplvl': ini_thy_info, 'runlvl': thy_info, 'var_scnlvl': vscnlvl_thy_info, 'var_splvl1': vsp1lvl_thy_info, 'var_splvl2': vsp2lvl_thy_info, 'mod_inplvl': mod_ini_thy_info, 'mod_runlvl': mod_thy_info, 'mod_var_scnlvl': mod_vscnlvl_thy_info, 'mod_var_splvl1': mod_vsp1lvl_thy_info, 'mod_var_splvl2': mod_vsp2lvl_thy_info, 'hs_var_scnlvl': hs_vscnlvl_thy_info, 'hs_var_splvl1': hs_vsp1lvl_thy_info, 'hs_var_splvl2': hs_vsp2lvl_thy_info, 'hs_runlvl': hs_thy_info } runfs_dct = { 'runlvl_scn_fs': runlvl_scn_run_fs, 'runlvl_cscn_fs': runlvl_cscn_run_fs, 'runlvl_cnf_fs': runlvl_cnf_run_fs, 'vscnlvl_ts_fs': vscnlvl_ts_run_fs, 'vscnlvl_scn_fs': vscnlvl_scn_run_fs, 'vscnlvl_cscn_fs': vscnlvl_cscn_run_fs, 'vrctst_fs': vrctst_run_fs, } savefs_dct = { 'inilvl_zma_fs': ini_zma_save_fs, 'runlvl_scn_fs': runlvl_scn_save_fs, 'runlvl_cscn_fs': runlvl_cscn_save_fs, 'runlvl_cnf_fs': runlvl_cnf_save_fs, 'vscnlvl_scn_fs': vscnlvl_scn_save_fs, 'vscnlvl_cscn_fs': vscnlvl_cscn_save_fs, 'vrctst_fs': vrctst_save_fs, 'rcts_cnf_fs': _rcts_cnf_fs, 'runlvl_ts_zma_fs': runlvl_ts_zma_save_fs } return thy_inf_dct, runfs_dct, savefs_dct
def conformer_tsk(job, spc_dct, spc_name, thy_dct, es_keyword_dct, run_prefix, save_prefix, print_debug=False): """ Prepares and executes all electronic structure tasks that generate information for species and transition state conformers. This includes sampling and optimization procedures to generate conformer structures, as well as __ calculations using some saved conformer as input. :param job(subtask): calculatiion(s) to perform for conformer :type job: str :param spc_dct: :type spc_dct: :param spc_name: name of species :type spc_name: str :param thy_dct: :type thy_dct: :param es_keyword_dct: keyword-values for electronic structure task :type es_keyword_dct: dict[str:str] :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 """ saddle = bool('ts_' in spc_name) spc_dct_i = spc_dct[spc_name] # Set the spc_info if not saddle: spc_info = sinfo.from_dct(spc_dct_i) else: spc_info = rinfo.ts_info(spc_dct_i['rxn_info']) zrxn = spc_dct_i.get('zrxn', None) overwrite = es_keyword_dct['overwrite'] retryfail = es_keyword_dct['retryfail'] nprocs = 1 # Modify the theory method_dct = thy_dct.get(es_keyword_dct['runlvl']) ini_method_dct = thy_dct.get(es_keyword_dct['inplvl']) thy_info = tinfo.from_dct(method_dct) ini_thy_info = tinfo.from_dct(ini_method_dct) mod_thy_info = tinfo.modify_orb_label(thy_info, spc_info) mod_ini_thy_info = tinfo.modify_orb_label(ini_thy_info, spc_info) # New filesystem objects _root = root_locs(spc_dct_i, saddle=saddle, name=spc_name) ini_cnf_run_fs, ini_cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_ini_thy_info[1:], **_root) cnf_run_fs, cnf_save_fs = build_fs(run_prefix, save_prefix, 'CONFORMER', thy_locs=mod_thy_info[1:], **_root) if job == 'samp': # Build the ini zma filesys user_conf_ids = spc_dct_i.get('conf_id') if user_conf_ids is None: ini_loc_info = filesys.mincnf.min_energy_conformer_locators( ini_cnf_save_fs, mod_ini_thy_info) ini_locs, ini_min_cnf_path = ini_loc_info else: print(f'Using user specified conformer IDs: {user_conf_ids}') ini_locs = user_conf_ids if any(ini_locs): ini_zma_save_fs = autofile.fs.zmatrix(ini_min_cnf_path) # Set up the run scripts script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) # Set variables if it is a saddle two_stage = saddle mc_nsamp = spc_dct_i['mc_nsamp'] resave = es_keyword_dct['resave'] # Read the geometry and zma from the ini file system geo = ini_cnf_save_fs[-1].file.geometry.read(ini_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read([0]) # Read the torsions from the ini file sys if ini_zma_save_fs[-1].file.torsions.exists([0]): tors_dct = ini_zma_save_fs[-1].file.torsions.read([0]) rotors = automol.rotor.from_data(zma, tors_dct) tors_names = automol.rotor.names(rotors, flat=True) else: tors_names = () geo_path = ini_cnf_save_fs[-1].path(ini_locs) ioprinter.initial_geom_path('Sampling started', geo_path) # Check runsystem for equal ring CONF make conf_fs # Else make new ring conf directory rid = conformer.rng_loc_for_geo(geo, cnf_save_fs) if rid is None: conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, **kwargs) rid = conformer.rng_loc_for_geo(geo, cnf_save_fs) # Run the sampling conformer.conformer_sampling(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, rid, script_str, overwrite, nsamp_par=mc_nsamp, tors_names=tors_names, zrxn=zrxn, two_stage=two_stage, retryfail=retryfail, resave=resave, repulsion_thresh=40.0, print_debug=print_debug, **kwargs) else: ioprinter.info_message('Missing conformers. Skipping task...') elif job == 'pucker': # Build the ini zma filesys ini_loc_info = filesys.mincnf.min_energy_conformer_locators( ini_cnf_save_fs, mod_ini_thy_info) ini_min_locs, ini_min_cnf_path = ini_loc_info ini_zma_save_fs = autofile.fs.zmatrix(ini_min_cnf_path) # Set up the run scripts script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) # Set variables if it is a saddle two_stage = saddle mc_nsamp = spc_dct_i['mc_nsamp'] # Read the geometry and zma from the ini file system geo = ini_cnf_save_fs[-1].file.geometry.read(ini_min_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read([0]) # Read the torsions from the ini file sys if ini_zma_save_fs[-1].file.ring_torsions.exists([0]): ring_tors_dct = ini_zma_save_fs[-1].file.ring_torsions.read([0]) else: ring_tors_dct = {} geo_path = ini_cnf_save_fs[-1].path(ini_min_locs) ioprinter.initial_geom_path('Sampling started', geo_path) # Run the sampling conformer.ring_conformer_sampling(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, nsamp_par=mc_nsamp, ring_tors_dct=ring_tors_dct, zrxn=zrxn, two_stage=two_stage, retryfail=retryfail, **kwargs) elif job == 'opt': cnf_range = es_keyword_dct['cnf_range'] hbond_cutoffs = spc_dct_i['hbond_cutoffs'] cnf_sort_info_lst = _sort_info_lst(es_keyword_dct['sort'], thy_dct, spc_info) # Set up the run scripts script_str, kwargs = qchem_params(method_dct, elstruct.Job.OPTIMIZATION) rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( cnf_save_fs, mod_thy_info, cnf_range='all', nprocs=nprocs) ini_rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( ini_cnf_save_fs, mod_ini_thy_info, cnf_range=cnf_range, sort_info_lst=cnf_sort_info_lst, hbond_cutoffs=hbond_cutoffs, print_enes=True, nprocs=nprocs) # Truncate the list of the ini confs uni_rng_locs_lst, uni_cnf_locs_lst = conformer.unique_fs_ring_confs( cnf_save_fs, rng_cnf_locs_lst, ini_cnf_save_fs, ini_rng_cnf_locs_lst) # ioprinter.debug_message( # 'uni lst that has no similar ring', uni_rng_locs_lst) # ioprinter.debug_message( # 'uni lst that has similar ring', uni_cnf_locs_lst) for locs in uni_rng_locs_lst: rid, cid = locs # Obtain the zma from ini loc ini_cnf_save_path = ini_cnf_save_fs[-1].path(locs) ini_zma_save_fs = autofile.fs.zmatrix(ini_cnf_save_path) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) # Make the ring filesystem conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, use_locs=locs, **kwargs) for locs in uni_cnf_locs_lst: ini_locs, rid = locs # Obtain the zma from ini loc ini_cnf_save_path = ini_cnf_save_fs[-1].path(ini_locs) ini_zma_save_fs = autofile.fs.zmatrix(ini_cnf_save_path) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) # obtain conformer filesys associated with ring at the runlevel cid = autofile.schema.generate_new_conformer_id() conformer.single_conformer(zma, spc_info, mod_thy_info, cnf_run_fs, cnf_save_fs, script_str, overwrite, retryfail=retryfail, zrxn=zrxn, use_locs=(rid, cid), **kwargs) # print all geometres within cnfrange rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( cnf_save_fs, mod_thy_info, cnf_range=cnf_range, sort_info_lst=cnf_sort_info_lst, hbond_cutoffs=hbond_cutoffs, nprocs=nprocs) for locs in rng_cnf_locs_lst: geo = cnf_save_fs[-1].file.geometry.read(locs) ioprinter.geometry(geo) elif job in ('energy', 'grad', 'hess', 'vpt2', 'prop'): cnf_range = es_keyword_dct['cnf_range'] hbond_cutoffs = spc_dct_i['hbond_cutoffs'] cnf_sort_info_lst = _sort_info_lst(es_keyword_dct['sort'], thy_dct, spc_info) user_conf_ids = spc_dct_i.get('conf_id') if user_conf_ids is None: ini_rng_cnf_locs_lst, _ = filesys.mincnf.conformer_locators( ini_cnf_save_fs, mod_ini_thy_info, cnf_range=cnf_range, sort_info_lst=cnf_sort_info_lst, hbond_cutoffs=hbond_cutoffs, print_enes=True, nprocs=nprocs) else: print(f'Using user specified conformer IDs: {user_conf_ids}') ini_rng_cnf_locs_lst = (user_conf_ids, ) # Check if locs exist, kill if it doesn't if not ini_rng_cnf_locs_lst: ioprinter.error_message('No min-energy conformer found for level:') else: # Set up the run scripts script_str, kwargs = qchem_params(method_dct) # Grab frequencies for the reference, print ref freqs if job == 'hess': if ini_cnf_save_fs[-1].file.harmonic_frequencies.exists( ini_rng_cnf_locs_lst[0]): frq = ini_cnf_save_fs[-1].file.harmonic_frequencies.read( ini_rng_cnf_locs_lst[0]) ref_val = frq else: ref_val = None if ref_val is not None and zrxn is not None: ref_path = cnf_save_fs[-1].path(ini_rng_cnf_locs_lst[0]) print('Found reference frequencies for saddle-point ' f'checks for conformer at\n {ref_path}') ioprinter.frequencies(ref_val) else: ref_val = None # Run the job over all the conformers requested by the user print('Going over all requested conformers for task...\n') for ini_locs in ini_rng_cnf_locs_lst: ini_cnf_run_fs[-1].create(ini_locs) geo_save_path = ini_cnf_save_fs[-1].path(ini_locs) ini_zma_save_fs = autofile.fs.zmatrix(geo_save_path) print('Running task for geometry at ', geo_save_path) geo = ini_cnf_save_fs[-1].file.geometry.read(ini_locs) zma = ini_zma_save_fs[-1].file.zmatrix.read((0, )) ES_TSKS[job](zma, geo, spc_info, mod_thy_info, ini_cnf_run_fs, ini_cnf_save_fs, ini_locs, run_prefix, script_str, overwrite, zrxn=zrxn, retryfail=retryfail, method_dct=method_dct, ref_val=ref_val, **kwargs) print('\n === FINISHED CONF ===\n')
def obtain_saddle_point(guess_zmas, ts_dct, method_dct, runfs_dct, savefs_dct, es_keyword_dct): """ Given the saddle point guess structure, obtain a proper saddle point """ # Get info (move later) ts_info = rinfo.ts_info(ts_dct['rxn_info']) mod_thy_info = tinfo.modify_orb_label(tinfo.from_dct(method_dct), ts_info) script_str, kwargs = qchem_params(method_dct, job=elstruct.Job.OPTIMIZATION) overwrite = es_keyword_dct['overwrite'] ts_info = rinfo.ts_info(ts_dct['rxn_info']) zrxn = ts_dct['zrxn'] # runlvl_cnf_run_fs = runfs_dct['runlvl_cnf_fs'] # cid = [autofile.schema.generate_new_conformer_id()] # run_fs = autofile.fs.run(runlvl_cnf_run_fs[-1].path(cid)) run_prefix = runfs_dct['prefix'] runlvl_cnf_run_fs = runfs_dct['runlvl_cnf_fs'] rid = autofile.schema.generate_new_ring_id() cid = autofile.schema.generate_new_conformer_id() locs = (rid, cid) runlvl_cnf_run_fs[-1].create(locs) run_fs = autofile.fs.run(runlvl_cnf_run_fs[-1].path(locs)) # Optimize the saddle point script_str, kwargs = qchem_params(method_dct) opt_ret = optimize_saddle_point(guess_zmas, ts_info, mod_thy_info, run_fs, script_str, overwrite, **kwargs) # Calculate the Hessian for the optimized structure if opt_ret is not None: # Get the Hessian and check the saddle point # (maybe just have remove imag do this?) hess_ret, _, imags = saddle_point_hessian(opt_ret, ts_info, method_dct, run_fs, run_prefix, overwrite) sadpt_status = saddle_point_checker(imags) # ted_status = ted_coordinate_check(opt_ret, hess_ret, ts_dct, run_fs) # remove ted_status check for now since it was crashing # ted_status = True # Assess saddle point, save it if viable # if sadpt_status == 'kickoff': # opt_inf_obj, _, opt_out_str = opt_ret # opt_prog = opt_inf_obj.prog # geo = elstruct.reader.opt_geometry(opt_prog, opt_out_str) # # Need to return an opt_ret # geo, _ = geom.remove_imag( # geo, ts_info, mod_thy_info, ts_run_fs, run_fs, # kickoff_size=0.1, kickoff_backward=False, kickoff_mode=1, # overwrite=False) # sadpt_status = saddle_point_checker(imags) if sadpt_status == 'success': runlvl_cnf_save_fs, _ = savefs_dct['runlvl_cnf_fs'] filesys.save.conformer(opt_ret, hess_ret, runlvl_cnf_save_fs, mod_thy_info[1:], zrxn=zrxn, rng_locs=(rid, ), tors_locs=(cid, ), zma_locs=None) else: ioprinter.warning_message( '\n TS optimization failed. No geom to check and save.')