def _validate_damping(): """Sanity-checks DAMPING control options Raises ------ ValidationError If any of |scf__damping_percentage|, |scf__damping_convergence| don't play well together. Returns ------- bool Whether DAMPING is enabled during scf. """ # Q: I changed the enabled criterion get_option <-- has_option_changed enabled = (core.get_option('SCF', 'DAMPING_PERCENTAGE') > 0.0) if enabled: parameter = core.get_option('SCF', "DAMPING_PERCENTAGE") if parameter < 0.0 or parameter > 100.0: raise ValidationError('SCF DAMPING_PERCENTAGE ({}) must be between 0 and 100'.format(parameter)) stop = core.get_option('SCF', 'DAMPING_CONVERGENCE') if stop < 0.0: raise ValidationError('SCF DAMPING_CONVERGENCE ({}) must be > 0'.format(stop)) return enabled
def _validate_diis(): """Sanity-checks DIIS control options Raises ------ ValidationError If any of |scf__diis|, |scf__diis_start|, |scf__diis_min_vecs|, |scf__diis_max_vecs| don't play well together. Returns ------- bool Whether DIIS is enabled during scf. """ enabled = bool(core.get_option('SCF', 'DIIS')) if enabled: start = core.get_option('SCF', 'DIIS_START') if start < 1: raise ValidationError('SCF DIIS_START ({}) must be at least 1'.format(start)) minvecs = core.get_option('SCF', 'DIIS_MIN_VECS') if minvecs < 1: raise ValidationError('SCF DIIS_MIN_VECS ({}) must be at least 1'.format(minvecs)) maxvecs = core.get_option('SCF', 'DIIS_MAX_VECS') if maxvecs < minvecs: raise ValidationError( 'SCF DIIS_MAX_VECS ({}) must be at least DIIS_MIN_VECS ({})'.format(maxvecs, minvecs)) return enabled
def get_qm_atoms_opts(mol): """Provides list of coordinates of quantum mechanical atoms from psi4.core.Molecule `mol` to pylibefp.core.efp() `efpobj`. Also converts from `read_options("EFP"` to pylibefp opts dictionary. """ efpobj = mol.EFP ptc = [] coords = [] for iat in range(mol.natom()): ptc.append(mol.charge(iat)) coords.append(mol.x(iat)) coords.append(mol.y(iat)) coords.append(mol.z(iat)) # set options # * 'chtr', 'qm_exch', 'qm_disp', 'qm_chtr' may be enabled in a future libefp release opts = {} for opt in ['elst', 'exch', 'ind', 'disp', 'elst_damping', 'ind_damping', 'disp_damping']: psiopt = 'EFP_' + opt.upper() if core.has_option_changed('EFP', psiopt): opts[opt] = core.get_option('EFP', psiopt) for opt in ['elst', 'ind']: psiopt = 'EFP_QM_' + opt.upper() if core.has_option_changed('EFP', psiopt): opts['qm_' + opt] = core.get_option('EFP', psiopt) return ptc, coords, opts
def _converged(e_delta, d_rms, e_conv=None, d_conv=None): if e_conv is None: e_conv = core.get_option("SCF", "E_CONVERGENCE") if d_conv is None: d_conv = core.get_option("SCF", "D_CONVERGENCE") return (abs(e_delta) < e_conv and d_rms < d_conv)
def _validate_soscf(): """Sanity-checks SOSCF control options Raises ------ ValidationError If any of |scf__soscf|, |scf__soscf_start_convergence|, |scf__soscf_min_iter|, |scf__soscf_max_iter| don't play well together. Returns ------- bool Whether SOSCF is enabled during scf. """ enabled = core.get_option('SCF', 'SOSCF') if enabled: start = core.get_option('SCF', 'SOSCF_START_CONVERGENCE') if start < 0.0: raise ValidationError('SCF SOSCF_START_CONVERGENCE ({}) must be positive'.format(start)) miniter = core.get_option('SCF', 'SOSCF_MIN_ITER') if miniter < 1: raise ValidationError('SCF SOSCF_MIN_ITER ({}) must be at least 1'.format(miniter)) maxiter = core.get_option('SCF', 'SOSCF_MAX_ITER') if maxiter < miniter: raise ValidationError( 'SCF SOSCF_MAX_ITER ({}) must be at least SOSCF_MIN_ITER ({})'.format(maxiter, miniter)) conv = core.get_option('SCF', 'SOSCF_CONV') if conv < 1.e-10: raise ValidationError('SCF SOSCF_CONV ({}) must be achievable'.format(conv)) return enabled
def fisapt_fdrop(self): """Drop output files from FSAPT calculation. FISAPT::fdrop""" core.print_out(" ==> F-SAPT Output <==\n\n") filepath = core.get_option("FISAPT", "FISAPT_FSAPT_FILEPATH") os.makedirs(filepath, exist_ok=True) core.print_out(" F-SAPT Data Filepath = {}\n\n".format(filepath)) geomfile = filepath + os.sep + 'geom.xyz' xyz = self.molecule().to_string(dtype='xyz', units='Angstrom') with open(geomfile, 'w') as fh: fh.write(xyz) vectors = self.vectors() matrices = self.matrices() matrices["Qocc0A"].name = "QA" matrices["Qocc0B"].name = "QB" matrices["Elst_AB"].name = "Elst" matrices["Exch_AB"].name = "Exch" matrices["IndAB_AB"].name = "IndAB" matrices["IndBA_AB"].name = "IndBA" matrices["Disp_AB"].name = "Disp" _drop(vectors["ZA"], filepath) _drop(vectors["ZB"], filepath) _drop(matrices["Qocc0A"], filepath) _drop(matrices["Qocc0B"], filepath) _drop(matrices["Elst_AB"], filepath) _drop(matrices["Exch_AB"], filepath) _drop(matrices["IndAB_AB"], filepath) _drop(matrices["IndBA_AB"], filepath) _drop(matrices["Disp_AB"], filepath) if core.get_option("FISAPT", "SSAPT0_SCALE"): ssapt_filepath = core.get_option("FISAPT", "FISAPT_FSSAPT_FILEPATH") os.makedirs(ssapt_filepath, exist_ok=True) core.print_out(" sF-SAPT Data Filepath = {}\n\n".format(ssapt_filepath)) geomfile = ssapt_filepath + os.sep + 'geom.xyz' with open(geomfile, 'w') as fh: fh.write(xyz) matrices["sIndAB_AB"].name = "IndAB" matrices["sIndBA_AB"].name = "IndBA" matrices["sDisp_AB"].name = "Disp" _drop(vectors["ZA"], ssapt_filepath) _drop(vectors["ZB"], ssapt_filepath) _drop(matrices["Qocc0A"], ssapt_filepath) _drop(matrices["Qocc0B"], ssapt_filepath) _drop(matrices["Elst_AB"], ssapt_filepath) _drop(matrices["Exch_AB"], ssapt_filepath) _drop(matrices["sIndAB_AB"], ssapt_filepath) _drop(matrices["sIndBA_AB"], ssapt_filepath) _drop(matrices["sDisp_AB"], ssapt_filepath)
def scf_initialize(self): """Specialized initialization, compute integrals and does everything to prepare for iterations""" self.iteration_ = 0 efp_enabled = hasattr(self.molecule(), 'EFP') if core.get_option('SCF', "PRINT") > 0: core.print_out(" ==> Pre-Iterations <==\n\n") self.print_preiterations() if efp_enabled: # EFP: Set QM system, options, and callback. Display efp geom in [A] efpobj = self.molecule().EFP core.print_out(efpobj.banner()) core.print_out(efpobj.geometry_summary(units_to_bohr=constants.bohr2angstroms)) efpptc, efpcoords, efpopts = get_qm_atoms_opts(self.molecule()) efpobj.set_point_charges(efpptc, efpcoords) efpobj.set_opts(efpopts, label='psi', append='psi') efpobj.set_electron_density_field_fn(field_fn) if self.attempt_number_ == 1: mints = core.MintsHelper(self.basisset()) if core.get_global_option('RELATIVISTIC') in ['X2C', 'DKH']: mints.set_rel_basisset(self.get_basisset('BASIS_RELATIVISTIC')) mints.one_electron_integrals() self.integrals() core.timer_on("HF: Form core H") self.form_H() core.timer_off("HF: Form core H") if efp_enabled: # EFP: Add in permanent moment contribution and cache core.timer_on("HF: Form Vefp") verbose = core.get_option('SCF', "PRINT") Vefp = modify_Fock_permanent(self.molecule(), mints, verbose=verbose-1) Vefp = core.Matrix.from_array(Vefp) self.H().add(Vefp) Horig = self.H().clone() self.Horig = Horig core.print_out(" QM/EFP: iterating Total Energy including QM/EFP Induction\n") core.timer_off("HF: Form Vefp") core.timer_on("HF: Form S/X") self.form_Shalf() core.timer_off("HF: Form S/X") core.timer_on("HF: Guess") self.guess() core.timer_off("HF: Guess") else: # We're reading the orbitals from the previous set of iterations. self.form_D() self.set_energies("Total Energy", self.compute_initial_E())
def pybuild_JK(orbital_basis, aux=None, jk_type=None): """ Constructs a Psi4 JK object from an input basis. Parameters ---------- orbital_basis : :py:class:`~psi4.core.BasisSet` Orbital basis to use in the JK object. aux : :py:class:`~psi4.core.BasisSet` Optional auxiliary basis set for density-fitted tensors. Defaults to the DF_BASIS_SCF if set, otherwise the correspond JKFIT basis to the passed in orbital_basis. type : str Type of JK object to build (DF, Direct, PK, etc). Defaults to the current global SCF_TYPE option. Returns ------- :py:class:`~psi4.core.JK` Uninitialized JK object. Example ------- jk = psi4.core.JK.build(bas) jk.set_memory(int(5e8)) # 4GB of memory jk.initialize() ... jk.C_left_add(matirx) jk.compute() jk.C_clear() ... """ optstash = optproc.OptionsState(["SCF_TYPE"]) if jk_type is not None: core.set_global_option("SCF_TYPE", jk_type) if aux is None: if core.get_option("SCF", "SCF_TYPE") == "DF": aux = core.BasisSet.build(orbital_basis.molecule(), "DF_BASIS_SCF", core.get_option("SCF", "DF_BASIS_SCF"), "JKFIT", core.get_global_option('BASIS'), orbital_basis.has_puream()) else: aux = core.BasisSet.zero_ao_basis_set() jk = core.JK.build_JK(orbital_basis, aux) optstash.restore() return jk
def scf_set_reference_local(name): """ Figures out the correct SCF reference to set locally """ optstash = p4util.OptionsState( ['SCF', 'DFT_FUNCTIONAL'], ['SCF', 'SCF_TYPE'], ['SCF', 'REFERENCE']) # Alter default algorithm if not core.has_option_changed('SCF', 'SCF_TYPE'): core.set_local_option('SCF', 'SCF_TYPE', 'DF') if name == 'hf': if core.get_option('SCF','REFERENCE') == 'RKS': core.set_local_option('SCF','REFERENCE','RHF') elif core.get_option('SCF','REFERENCE') == 'UKS': core.set_local_option('SCF','REFERENCE','UHF') elif name == 'scf': if core.get_option('SCF','REFERENCE') == 'RKS': if (len(core.get_option('SCF', 'DFT_FUNCTIONAL')) > 0) or core.get_option('SCF', 'DFT_CUSTOM_FUNCTIONAL') is not None: pass else: core.set_local_option('SCF','REFERENCE','RHF') elif core.get_option('SCF','REFERENCE') == 'UKS': if (len(core.get_option('SCF', 'DFT_FUNCTIONAL')) > 0) or core.get_option('SCF', 'DFT_CUSTOM_FUNCTIONAL') is not None: pass else: core.set_local_option('SCF','REFERENCE','UHF') return optstash
def dft_set_reference_local(name): """ Figures out the correct DFT reference to set locally """ optstash = p4util.OptionsState( ['SCF', 'DFT_FUNCTIONAL'], ['SCF', 'REFERENCE'], ['SCF', 'SCF_TYPE'], ['DF_BASIS_MP2'], ['DFMP2', 'MP2_OS_SCALE'], ['DFMP2', 'MP2_SS_SCALE']) # Alter default algorithm if not core.has_option_changed('SCF', 'SCF_TYPE'): core.set_local_option('SCF', 'SCF_TYPE', 'DF') core.set_local_option('SCF', 'DFT_FUNCTIONAL', name) user_ref = core.get_option('SCF', 'REFERENCE') if (user_ref == 'RHF'): core.set_local_option('SCF', 'REFERENCE', 'RKS') elif (user_ref == 'UHF'): core.set_local_option('SCF', 'REFERENCE', 'UKS') elif (user_ref == 'ROHF'): raise ValidationError('ROHF reference for DFT is not available.') elif (user_ref == 'CUHF'): raise ValidationError('CUHF reference for DFT is not available.') return optstash
def df_mp2_sapt_dispersion(dimer_wfn, wfn_A, wfn_B, primary_basis, aux_basis, cache, do_print=True): if do_print: core.print_out("\n ==> E20 Dispersion (MP2) <== \n\n") optstash = p4util.OptionsState(['SAPT', 'SAPT0_E10'], ['SAPT', 'SAPT0_E20IND'], ['SAPT', 'SAPT0_E20DISP'], ['SAPT', 'SAPT_QUIET']) core.set_local_option("SAPT", "SAPT0_E10", False) core.set_local_option("SAPT", "SAPT0_E20IND", False) core.set_local_option("SAPT", "SAPT0_E20DISP", True) core.set_local_option("SAPT", "SAPT_QUIET", True) if core.get_option('SCF', 'REFERENCE') == 'RHF': core.IO.change_file_namespace(psif.PSIF_SAPT_MONOMERA, 'monomerA', 'dimer') core.IO.change_file_namespace(psif.PSIF_SAPT_MONOMERB, 'monomerB', 'dimer') core.IO.set_default_namespace('dimer') dimer_wfn.set_basisset("DF_BASIS_SAPT", aux_basis) dimer_wfn.set_basisset("DF_BASIS_ELST", aux_basis) e_sapt = core.sapt(dimer_wfn, wfn_A, wfn_B) optstash.restore() svars = dimer_wfn.variables() core.print_out("\n") core.print_out(print_sapt_var("Disp20 (MP2)", svars["E DISP20"], short=True) + "\n") core.print_out(print_sapt_var("Exch-Disp20,u", svars["E EXCH-DISP20"], short=True) + "\n") ret = {} ret["Exch-Disp20,u"] = svars["E EXCH-DISP20"] ret["Disp20,u"] = svars["E DISP20"] return ret
def scf_set_reference_local(name, is_dft=False): """ Figures out the correct SCF reference to set locally """ optstash = p4util.OptionsState( ['SCF_TYPE'], ['SCF', 'REFERENCE']) # Alter default algorithm if not core.has_global_option_changed('SCF_TYPE'): core.set_global_option('SCF_TYPE', 'DF') # Alter reference name if needed user_ref = core.get_option('SCF', 'REFERENCE') sup = build_superfunctional_from_dictionary(functionals[name], 1, 1, True)[0] if sup.needs_xc() or is_dft: if (user_ref == 'RHF'): core.set_local_option('SCF', 'REFERENCE', 'RKS') elif (user_ref == 'UHF'): core.set_local_option('SCF', 'REFERENCE', 'UKS') elif (user_ref == 'ROHF'): raise ValidationError('ROHF reference for DFT is not available.') elif (user_ref == 'CUHF'): raise ValidationError('CUHF reference for DFT is not available.') # else we are doing HF and nothing needs to be overloaded return optstash
def scf_set_reference_local(name, is_dft=False): """ Figures out the correct SCF reference to set locally """ optstash = p4util.OptionsState( ['SCF', 'SCF_TYPE'], ['SCF', 'REFERENCE']) # Alter default algorithm if not core.has_option_changed('SCF', 'SCF_TYPE'): core.set_local_option('SCF', 'SCF_TYPE', 'DF') # Alter reference name if needed user_ref = core.get_option('SCF', 'REFERENCE') if (name not in dft_funcs.superfunctional_noxc_names) or (is_dft): if (user_ref == 'RHF'): core.set_local_option('SCF', 'REFERENCE', 'RKS') elif (user_ref == 'UHF'): core.set_local_option('SCF', 'REFERENCE', 'UKS') elif (user_ref == 'ROHF'): raise ValidationError('ROHF reference for DFT is not available.') elif (user_ref == 'CUHF'): raise ValidationError('CUHF reference for DFT is not available.') # else we are doing HF and nothing needs to be overloaded return optstash
def scf_compute_energy(self): """Base class Wavefunction requires this function. Here it is simply a wrapper around initialize(), iterations(), finalize_energy(). It returns the SCF energy computed by finalize_energy(). """ if core.get_option('SCF', 'DF_SCF_GUESS') and (core.get_global_option('SCF_TYPE') == 'DIRECT'): # speed up DIRECT algorithm (recomputes full (non-DF) integrals # each iter) by first converging via fast DF iterations, then # fully converging in fewer slow DIRECT iterations. aka Andy trick 2.0 core.print_out(" Starting with a DF guess...\n\n") with p4util.OptionsStateCM(['SCF_TYPE']): core.set_global_option('SCF_TYPE', 'DF') self.initialize() try: self.iterations() except SCFConvergenceError: self.finalize() raise SCFConvergenceError("""SCF DF preiterations""", self.iteration_, self, 0, 0) core.print_out("\n DF guess converged.\n\n") # reset the DIIS & JK objects in prep for DIRECT if self.initialized_diis_manager_: self.diis_manager().reset_subspace() self.initialize_jk(self.memory_jk_) else: self.initialize() try: self.iterations() except SCFConvergenceError as e: if core.get_option("SCF", "FAIL_ON_MAXITER"): core.print_out(" Failed to converge.\n") # energy = 0.0 # A P::e fn to either throw or protest upon nonconvergence # die_if_not_converged() raise e else: core.print_out(" Energy did not converge, but proceeding anyway.\n\n") else: core.print_out(" Energy converged.\n\n") scf_energy = self.finalize_energy() return scf_energy
def check_non_symmetric_jk_density(name): """ Ensure non-symmetric density matrices are supported for the selected JK routine. """ scf_type = core.get_option('SCF', 'SCF_TYPE') supp_jk_type = ['DF', 'CD', 'PK', 'DIRECT', 'OUT_OF_CORE'] supp_string = ', '.join(supp_jk_type[:-1]) + ', or ' + supp_jk_type[-1] + '.' if scf_type not in supp_jk_type: raise ValidationError("Method %s: Requires support for non-symmetric density matrices.\n" " Please set SCF_TYPE to %s" % (name, supp_string))
def fisapt_plot(self): """Filesystem wrapper for FISAPT::plot.""" filepath = core.get_option("FISAPT", "FISAPT_PLOT_FILEPATH") os.makedirs(filepath, exist_ok=True) geomfile = filepath + os.sep + 'geom.xyz' xyz = self.molecule().to_string(dtype='xyz', units='Angstrom') with open(geomfile, 'w') as fh: fh.write(xyz) self.raw_plot(filepath)
def _validate_MOM(): """Sanity-checks MOM control options Raises ------ ValidationError If any of |scf__mom_start|, |scf__mom_occ| don't play well together. Returns ------- bool Whether excited-state MOM (not just the plain stabilizing MOM) is enabled during scf. """ enabled = (core.get_option('SCF', "MOM_START") != 0 and len(core.get_option('SCF', "MOM_OCC")) > 0) if enabled: start = core.get_option('SCF', "MOM_START") if enabled < 0: raise ValidationError('SCF MOM_START ({}) must be at least 1'.format(start)) return enabled
def scf_print_energies(self): enuc = self.get_energies('Nuclear') e1 = self.get_energies('One-Electron') e2 = self.get_energies('Two-Electron') exc = self.get_energies('XC') ed = self.get_energies('-D') #self.del_variable('-D Energy') evv10 = self.get_energies('VV10') eefp = self.get_energies('EFP') epcm = self.get_energies('PCM Polarization') hf_energy = enuc + e1 + e2 dft_energy = hf_energy + exc + ed + evv10 total_energy = dft_energy + eefp + epcm core.print_out(" => Energetics <=\n\n") core.print_out(" Nuclear Repulsion Energy = {:24.16f}\n".format(enuc)) core.print_out(" One-Electron Energy = {:24.16f}\n".format(e1)) core.print_out(" Two-Electron Energy = {:24.16f}\n".format(e2)) if self.functional().needs_xc(): core.print_out(" DFT Exchange-Correlation Energy = {:24.16f}\n".format(exc)) core.print_out(" Empirical Dispersion Energy = {:24.16f}\n".format(ed)) core.print_out(" VV10 Nonlocal Energy = {:24.16f}\n".format(evv10)) if core.get_option('SCF', 'PCM'): core.print_out(" PCM Polarization Energy = {:24.16f}\n".format(epcm)) if hasattr(self.molecule(), 'EFP'): core.print_out(" EFP Energy = {:24.16f}\n".format(eefp)) core.print_out(" Total Energy = {:24.16f}\n".format(total_energy)) self.set_variable('NUCLEAR REPULSION ENERGY', enuc) self.set_variable('ONE-ELECTRON ENERGY', e1) self.set_variable('TWO-ELECTRON ENERGY', e2) if self.functional().needs_xc(): self.set_variable('DFT XC ENERGY', exc) self.set_variable('DFT VV10 ENERGY', evv10) self.set_variable('DFT FUNCTIONAL TOTAL ENERGY', hf_energy + exc + evv10) #self.set_variable(self.functional().name() + ' FUNCTIONAL TOTAL ENERGY', hf_energy + exc + evv10) self.set_variable('DFT TOTAL ENERGY', dft_energy) # overwritten later for DH else: self.set_variable('HF TOTAL ENERGY', hf_energy) if hasattr(self, "_disp_functor"): self.set_variable('DISPERSION CORRECTION ENERGY', ed) #if abs(ed) > 1.0e-14: # for pv, pvv in self.variables().items(): # if abs(pvv - ed) < 1.0e-14: # if pv.endswith('DISPERSION CORRECTION ENERGY') and pv.startswith(self.functional().name()): # fctl_plus_disp_name = pv.split()[0] # self.set_variable(fctl_plus_disp_name + ' TOTAL ENERGY', dft_energy) # overwritten later for DH #else: # self.set_variable(self.functional().name() + ' TOTAL ENERGY', dft_energy) # overwritten later for DH self.set_variable('SCF ITERATIONS', self.iteration_)
def prepare_options_for_modules(changedOnly=False, commandsInsteadDict=False): """Function to return a string of commands to replicate the current state of user-modified options. Used to capture C++ options information for distributed (sow/reap) input files. .. caution:: Some features are not yet implemented. Buy a developer a coffee. - Need some option to get either all or changed - Need some option to either get dict or set string or psimod command list - command return doesn't revoke has_changed setting for unchanged with changedOnly=False """ options = collections.defaultdict(dict) commands = '' for opt in core.get_global_option_list(): if core.has_global_option_changed(opt) or not changedOnly: if opt in ['DFT_CUSTOM_FUNCTIONAL', 'EXTERN']: # Feb 2017 hack continue val = core.get_global_option(opt) options['GLOBALS'][opt] = {'value': val, 'has_changed': core.has_global_option_changed(opt)} if isinstance(val, basestring): commands += """core.set_global_option('%s', '%s')\n""" % (opt, val) else: commands += """core.set_global_option('%s', %s)\n""" % (opt, val) #if changedOnly: # print('Appending module %s option %s value %s has_changed %s.' % \ # ('GLOBALS', opt, core.get_global_option(opt), core.has_global_option_changed(opt))) for module in _modules: if core.option_exists_in_module(module, opt): hoc = core.has_option_changed(module, opt) if hoc or not changedOnly: val = core.get_option(module, opt) options[module][opt] = {'value': val, 'has_changed': hoc} if isinstance(val, str): commands += """core.set_local_option('%s', '%s', '%s')\n""" % (module, opt, val) else: commands += """core.set_local_option('%s', '%s', %s)\n""" % (module, opt, val) #if changedOnly: # print('Appending module %s option %s value %s has_changed %s.' % \ # (module, opt, core.get_option(module, opt), hoc)) if commandsInsteadDict: return commands else: return options
def check_iwl_file_from_scf_type(scf_type, wfn): """ Ensures that a IWL file has been written based on input SCF type. """ if scf_type in ['DF', 'DISK_DF', 'MEM_DF', 'CD', 'PK', 'DIRECT']: mints = core.MintsHelper(wfn.basisset()) if core.get_global_option("RELATIVISTIC") in ["X2C", "DKH"]: rel_bas = core.BasisSet.build(wfn.molecule(), "BASIS_RELATIVISTIC", core.get_option("SCF", "BASIS_RELATIVISTIC"), "DECON", core.get_global_option('BASIS'), puream=wfn.basisset().has_puream()) mints.set_rel_basisset(rel_bas) mints.set_print(1) mints.integrals()
def set_cholesky_from(mtd_type): type_val = core.get_global_option(mtd_type) if type_val == 'CD': core.set_local_option('GPU_DFCC', 'DF_BASIS_CC', 'CHOLESKY') # Alter default algorithm if not core.has_global_option_changed('SCF_TYPE'): optstash.add_option(['SCF_TYPE']) core.set_global_option('SCF_TYPE', 'CD') core.print_out(""" SCF Algorithm Type (re)set to CD.\n""") elif type_val in ['DF', 'DISK_DF']: if core.get_option('GPU_DFCC', 'DF_BASIS_CC') == 'CHOLESKY': core.set_local_option('GPU_DFCC', 'DF_BASIS_CC', '') proc_util.check_disk_df(name.upper(), optstash) else: raise ValidationError("""Invalid type '%s' for DFCC""" % type_val)
def __init__(self, option, module=None): self.option = option.upper() if module: self.module = module.upper() else: self.module = None self.value_global = core.get_global_option(option) self.haschanged_global = core.has_global_option_changed(option) if self.module: self.value_local = core.get_local_option(self.module, option) self.haschanged_local = core.has_local_option_changed(self.module, option) self.value_used = core.get_option(self.module, option) self.haschanged_used = core.has_option_changed(self.module, option) else: self.value_local = None self.haschanged_local = None self.value_used = None self.haschanged_used = None
def scf_print_energies(self): enuc = self.get_energies('Nuclear') e1 = self.get_energies('One-Electron') e2 = self.get_energies('Two-Electron') exc = self.get_energies('XC') ed = self.get_energies('-D') evv10 = self.get_energies('VV10') eefp = self.get_energies('EFP') epcm = self.get_energies('PCM Polarization') hf_energy = enuc + e1 + e2 dft_energy = hf_energy + exc + ed + evv10 total_energy = dft_energy + eefp + epcm core.print_out(" => Energetics <=\n\n") core.print_out(" Nuclear Repulsion Energy = {:24.16f}\n".format(enuc)) core.print_out(" One-Electron Energy = {:24.16f}\n".format(e1)) core.print_out(" Two-Electron Energy = {:24.16f}\n".format(e2)) if self.functional().needs_xc(): core.print_out(" DFT Exchange-Correlation Energy = {:24.16f}\n".format(exc)) core.print_out(" Empirical Dispersion Energy = {:24.16f}\n".format(ed)) core.print_out(" VV10 Nonlocal Energy = {:24.16f}\n".format(evv10)) if core.get_option('SCF', 'PCM'): core.print_out(" PCM Polarization Energy = {:24.16f}\n".format(epcm)) if hasattr(self.molecule(), 'EFP'): core.print_out(" EFP Energy = {:24.16f}\n".format(eefp)) core.print_out(" Total Energy = {:24.16f}\n".format(total_energy)) self.set_variable('NUCLEAR REPULSION ENERGY', enuc) self.set_variable('ONE-ELECTRON ENERGY', e1) self.set_variable('TWO-ELECTRON ENERGY', e2) if self.functional().needs_xc(): self.set_variable('DFT XC ENERGY', exc) self.set_variable('DFT VV10 ENERGY', evv10) self.set_variable('DFT FUNCTIONAL TOTAL ENERGY', hf_energy + exc + evv10) self.set_variable('DFT TOTAL ENERGY', dft_energy) else: self.set_variable('HF TOTAL ENERGY', hf_energy) if hasattr(self, "_disp_functor"): self.set_variable('DISPERSION CORRECTION ENERGY', ed) self.set_variable('SCF ITERATIONS', self.iteration_)
def _validate_frac(): """Sanity-checks FRAC control options Raises ------ ValidationError If any of |scf__frac_start| don't play well together. Returns ------- bool Whether FRAC is enabled during scf. """ enabled = (core.get_option('SCF', 'FRAC_START') != 0) if enabled: if enabled < 0: raise ValidationError('SCF FRAC_START ({}) must be at least 1'.format(enabled)) return enabled
def scf_initialize(self): """Specialized initialization, compute integrals and does everything to prepare for iterations""" self.iteration_ = 0 efp_enabled = hasattr(self.molecule(), 'EFP') if core.get_option('SCF', "PRINT") > 0: core.print_out(" ==> Pre-Iterations <==\n\n") self.print_preiterations() if efp_enabled: # EFP: Set QM system, options, and callback. Display efp geom in [A] efpobj = self.molecule().EFP core.print_out(efpobj.banner()) core.print_out( efpobj.geometry_summary(units_to_bohr=constants.bohr2angstroms)) efpptc, efpcoords, efpopts = get_qm_atoms_opts(self.molecule()) efpobj.set_point_charges(efpptc, efpcoords) efpobj.set_opts(efpopts, label='psi', append='psi') efpobj.set_electron_density_field_fn(field_fn) if self.attempt_number_ == 1: mints = core.MintsHelper(self.basisset()) if core.get_global_option('RELATIVISTIC') in ['X2C', 'DKH']: mints.set_rel_basisset(self.get_basisset('BASIS_RELATIVISTIC')) mints.one_electron_integrals() self.integrals() core.timer_on("HF: Form core H") self.form_H() core.timer_off("HF: Form core H") if efp_enabled: # EFP: Add in permanent moment contribution and cache core.timer_on("HF: Form Vefp") verbose = core.get_option('SCF', "PRINT") Vefp = modify_Fock_permanent(self.molecule(), mints, verbose=verbose - 1) Vefp = core.Matrix.from_array(Vefp) self.H().add(Vefp) Horig = self.H().clone() self.Horig = Horig core.print_out( " QM/EFP: iterating Total Energy including QM/EFP Induction\n" ) core.timer_off("HF: Form Vefp") core.timer_on("HF: Form S/X") self.form_Shalf() core.timer_off("HF: Form S/X") core.timer_on("HF: Guess") self.guess() core.timer_off("HF: Guess") else: # We're reading the orbitals from the previous set of iterations. self.form_D() self.set_energies("Total Energy", self.compute_initial_E())
def fisapt_fdrop(self): """Drop output files from FSAPT calculation. FISAPT::fdrop""" core.print_out(" ==> F-SAPT Output <==\n\n") filepath = core.get_option("FISAPT", "FISAPT_FSAPT_FILEPATH") os.makedirs(filepath, exist_ok=True) core.print_out(" F-SAPT Data Filepath = {}\n\n".format(filepath)) geomfile = filepath + os.sep + 'geom.xyz' xyz = self.molecule().to_string(dtype='xyz', units='Angstrom') with open(geomfile, 'w') as fh: fh.write(xyz) vectors = self.vectors() matrices = self.matrices() matrices["Qocc0A"].name = "QA" matrices["Qocc0B"].name = "QB" matrices["Elst_AB"].name = "Elst" matrices["Exch_AB"].name = "Exch" matrices["IndAB_AB"].name = "IndAB" matrices["IndBA_AB"].name = "IndBA" _drop(vectors["ZA"], filepath) _drop(vectors["ZB"], filepath) _drop(matrices["Qocc0A"], filepath) _drop(matrices["Qocc0B"], filepath) _drop(matrices["Elst_AB"], filepath) _drop(matrices["Exch_AB"], filepath) _drop(matrices["IndAB_AB"], filepath) _drop(matrices["IndBA_AB"], filepath) if core.get_option("FISAPT", "FISAPT_DO_FSAPT_DISP"): matrices["Disp_AB"].name = "Disp" _drop(matrices["Disp_AB"], filepath) if core.get_option("FISAPT", "SSAPT0_SCALE"): ssapt_filepath = core.get_option("FISAPT", "FISAPT_FSSAPT_FILEPATH") os.makedirs(ssapt_filepath, exist_ok=True) core.print_out( " sF-SAPT Data Filepath = {}\n\n".format(ssapt_filepath)) geomfile = ssapt_filepath + os.sep + 'geom.xyz' with open(geomfile, 'w') as fh: fh.write(xyz) matrices["sIndAB_AB"].name = "IndAB" matrices["sIndBA_AB"].name = "IndBA" _drop(vectors["ZA"], ssapt_filepath) _drop(vectors["ZB"], ssapt_filepath) _drop(matrices["Qocc0A"], ssapt_filepath) _drop(matrices["Qocc0B"], ssapt_filepath) _drop(matrices["Elst_AB"], ssapt_filepath) _drop(matrices["Exch_AB"], ssapt_filepath) _drop(matrices["sIndAB_AB"], ssapt_filepath) _drop(matrices["sIndBA_AB"], ssapt_filepath) if core.get_option("FISAPT", "FISAPT_DO_FSAPT_DISP"): matrices["sDisp_AB"].name = "Disp" _drop(matrices["sDisp_AB"], ssapt_filepath)
def build_superfunctional(name, restricted): npoints = core.get_option("SCF", "DFT_BLOCK_MAX_POINTS") deriv = 1 # Default depth for now # We are a XC generating function if hasattr(name, '__call__'): custom_error = "SCF: Custom functional type must either be a SuperFunctional or a tuple of (SuperFunctional, (base_name, dashparam))." sfunc = name("name", npoints, deriv, restricted) # Without Dispersion if isinstance(sfunc, core.SuperFunctional): sup = (sfunc, False) # With Dispersion elif isinstance(sup[0], core.SuperFunctional): sup = sfunc # Can we validate dispersion? else: raise ValidationError(custom_error) # Double check that the SuperFunctional is correctly sized (why dont we always do this?) sup[0].set_max_points(npoints) sup[0].set_deriv(deriv) sup[0].allocate() # Check for supplied dict_func functionals elif isinstance(name, dict): sup = dict_builder.build_superfunctional_from_dictionary( name, npoints, deriv, restricted) # Check for pre-defined dict-based functionals elif name.lower() in dict_builder.functionals: sup = dict_builder.build_superfunctional_from_dictionary( dict_builder.functionals[name.lower()], npoints, deriv, restricted) else: raise ValidationError("SCF: Functional (%s) not found!" % name) if (core.get_global_option('INTEGRAL_PACKAGE') == 'ERD') and (sup[0].is_x_lrc() or sup[0].is_c_lrc()): raise ValidationError( "INTEGRAL_PACKAGE ERD does not play nicely with omega ERI's, so stopping." ) # Lock and unlock the functional sup[0].set_lock(False) # Set options if core.has_option_changed("SCF", "DFT_OMEGA") and sup[0].is_x_lrc(): omega = core.get_option("SCF", "DFT_OMEGA") sup[0].set_x_omega(omega) # We also need to loop through all of the exchange functionals if sup[0].is_libxc_func(): # Full libxc funcs are dropped in c_functionals (smooth move!) sup[0].c_functionals()[0].set_omega(omega) else: for x_func in sup[0].x_functionals(): x_func.set_omega(omega) if core.has_option_changed("SCF", "DFT_OMEGA_C") and sup[0].is_c_lrc(): sup[0].set_c_omega(core.get_option("SCF", "DFT_OMEGA_C")) if core.has_option_changed("SCF", "DFT_ALPHA"): sup[0].set_x_alpha(core.get_option("SCF", "DFT_ALPHA")) if core.has_option_changed("SCF", "DFT_ALPHA_C"): sup[0].set_c_alpha(core.get_option("SCF", "DFT_ALPHA_C")) # add VV10 correlation to any functional or modify existing # custom procedures using name 'scf' without any quadrature grid like HF will fail and are not detected if (core.has_option_changed("SCF", "NL_DISPERSION_PARAMETERS") and sup[0].vv10_b() > 0.0): if (name.lower() == 'hf'): raise ValidationError("SCF: HF with -NL not implemented") nl_tuple = core.get_option("SCF", "NL_DISPERSION_PARAMETERS") sup[0].set_vv10_b(nl_tuple[0]) if len(nl_tuple) > 1: sup[0].set_vv10_c(nl_tuple[1]) if len(nl_tuple) > 2: raise ValidationError( "too many entries in NL_DISPERSION_PARAMETERS for DFT-NL") elif core.has_option_changed("SCF", "DFT_VV10_B"): if (name.lower() == 'hf'): raise ValidationError("SCF: HF with -NL not implemented") vv10_b = core.get_option("SCF", "DFT_VV10_B") sup[0].set_vv10_b(vv10_b) if core.has_option_changed("SCF", "DFT_VV10_C"): vv10_c = core.get_option("SCF", "DFT_VV10_C") sup[0].set_vv10_c(vv10_c) if (abs(sup[0].vv10_c() - 0.0) <= 1e-8): core.print_out( "SCF: VV10_C not specified. Using default (C=0.0093)!") sup[0].set_vv10_c(0.0093) if (core.has_option_changed("SCF", "NL_DISPERSION_PARAMETERS") and core.has_option_changed("SCF", "DFT_VV10_B")): raise ValidationError( "SCF: Decide between NL_DISPERSION_PARAMETERS and DFT_VV10_B !!") # Check SCF_TYPE if sup[0].is_x_lrc() and (core.get_global_option("SCF_TYPE") not in ["DIRECT", "DF", "OUT_OF_CORE", "PK"]): raise ValidationError( "SCF: SCF_TYPE (%s) not supported for range-separated functionals, plese use SCF_TYPE = 'DF' to automatically select the correct JK build." % core.get_global_option("SCF_TYPE")) if (core.get_global_option('INTEGRAL_PACKAGE') == 'ERD') and (sup[0].is_x_lrc()): raise ValidationError( 'INTEGRAL_PACKAGE ERD does not play nicely with LRC DFT functionals, so stopping.' ) sup[0].set_lock(True) return sup
def run_gcp(self, func=None, dertype=None, verbose=False): # dashlvl=None, dashparam=None """Function to call Grimme's dftd3 program (http://toc.uni-muenster.de/DFTD3/) to compute the -D correction of level *dashlvl* using parameters for the functional *func*. The dictionary *dashparam* can be used to supply a full set of dispersion parameters in the absense of *func* or to supply individual overrides in the presence of *func*. Returns energy if *dertype* is 0, gradient if *dertype* is 1, else tuple of energy and gradient if *dertype* unspecified. The dftd3 executable must be independently compiled and found in :envvar:`PATH` or :envvar:`PSIPATH`. *self* may be either a qcdb.Molecule (sensibly) or a psi4.Molecule (works b/c psi4.Molecule has been extended by this method py-side and only public interface fns used) or a string that can be instantiated into a qcdb.Molecule. """ # Create (if necessary) and update qcdb.Molecule if isinstance(self, Molecule): # called on a qcdb.Molecule pass elif isinstance(self, core.Molecule): # called on a python export of a psi4.core.Molecule (py-side through Psi4's driver) self.create_psi4_string_from_molecule() elif isinstance(self, basestring): # called on a string representation of a psi4.Molecule (c-side through psi4.Dispersion) self = Molecule(self) else: raise ValidationError( """Argument mol must be psi4string or qcdb.Molecule""") self.update_geometry() # # Validate arguments # dashlvl = dashlvl.lower() # dashlvl = dash_alias['-' + dashlvl][1:] if ('-' + dashlvl) in dash_alias.keys() else dashlvl # if dashlvl not in dashcoeff.keys(): # raise ValidationError("""-D correction level %s is not available. Choose among %s.""" % (dashlvl, dashcoeff.keys())) if dertype is None: dertype = -1 elif util.der0th.match(str(dertype)): dertype = 0 elif util.der1st.match(str(dertype)): dertype = 1 # elif der2nd.match(str(dertype)): # raise ValidationError('Requested derivative level \'dertype\' %s not valid for run_dftd3.' % (dertype)) else: raise ValidationError( 'Requested derivative level \'dertype\' %s not valid for run_dftd3.' % (dertype)) # if func is None: # if dashparam is None: # # defunct case # raise ValidationError("""Parameters for -D correction missing. Provide a func or a dashparam kwarg.""") # else: # # case where all param read from dashparam dict (which must have all correct keys) # func = 'custom' # dashcoeff[dashlvl][func] = {} # dashparam = dict((k.lower(), v) for k, v in dashparam.iteritems()) # for key in dashcoeff[dashlvl]['b3lyp'].keys(): # if key in dashparam.keys(): # dashcoeff[dashlvl][func][key] = dashparam[key] # else: # raise ValidationError("""Parameter %s is missing from dashparam dict %s.""" % (key, dashparam)) # else: # func = func.lower() # if func not in dashcoeff[dashlvl].keys(): # raise ValidationError("""Functional %s is not available for -D level %s.""" % (func, dashlvl)) # if dashparam is None: # # (normal) case where all param taken from dashcoeff above # pass # else: # # case where items in dashparam dict can override param taken from dashcoeff above # dashparam = dict((k.lower(), v) for k, v in dashparam.iteritems()) # for key in dashcoeff[dashlvl]['b3lyp'].keys(): # if key in dashparam.keys(): # dashcoeff[dashlvl][func][key] = dashparam[key] # TODO temp until figure out paramfile allowed_funcs = [ 'HF/MINIS', 'DFT/MINIS', 'HF/MINIX', 'DFT/MINIX', 'HF/SV', 'DFT/SV', 'HF/def2-SV(P)', 'DFT/def2-SV(P)', 'HF/def2-SVP', 'DFT/def2-SVP', 'HF/DZP', 'DFT/DZP', 'HF/def-TZVP', 'DFT/def-TZVP', 'HF/def2-TZVP', 'DFT/def2-TZVP', 'HF/631Gd', 'DFT/631Gd', 'HF/def2-TZVP', 'DFT/def2-TZVP', 'HF/cc-pVDZ', 'DFT/cc-pVDZ', 'HF/aug-cc-pVDZ', 'DFT/aug-cc-pVDZ', 'DFT/SV(P/h,c)', 'DFT/LANL', 'DFT/pobTZVP', 'TPSS/def2-SVP', 'PW6B95/def2-SVP', # specials 'hf3c', 'pbeh3c' ] allowed_funcs = [f.lower() for f in allowed_funcs] if func.lower() not in allowed_funcs: raise Dftd3Error("""bad gCP func: %s. need one of: %r""" % (func, allowed_funcs)) # Move ~/.dftd3par.<hostname> out of the way so it won't interfere defaultfile = os.path.expanduser( '~') + '/.dftd3par.' + socket.gethostname() defmoved = False if os.path.isfile(defaultfile): os.rename(defaultfile, defaultfile + '_hide') defmoved = True # Find environment by merging PSIPATH and PATH environment variables lenv = { 'PATH': ':'.join([os.path.abspath(x) for x in os.environ.get('PSIPATH', '').split(':') if x != '']) + \ ':' + os.environ.get('PATH'), 'LD_LIBRARY_PATH': os.environ.get('LD_LIBRARY_PATH') } # Filter out None values as subprocess will fault on them lenv = {k: v for k, v in lenv.items() if v is not None} # Find out if running from Psi4 for scratch details and such # try: # import psi4 # except ImportError as err: # isP4regime = False # else: # isP4regime = True isP4regime = False # Setup unique scratch directory and move in current_directory = os.getcwd() if isP4regime: psioh = core.IOManager.shared_object() psio = core.IO.shared_object() os.chdir(psioh.get_default_path()) gcp_tmpdir = 'psi.' + str(os.getpid()) + '.' + psio.get_default_namespace() + \ '.gcp.' + str(uuid.uuid4())[:8] else: gcp_tmpdir = os.environ['HOME'] + os.sep + 'gcp_' + str( uuid.uuid4())[:8] if os.path.exists(gcp_tmpdir) is False: os.mkdir(gcp_tmpdir) os.chdir(gcp_tmpdir) # Write gcp_parameters file that governs cp correction # paramcontents = gcp_server(func, dashlvl, 'dftd3') # paramfile1 = 'dftd3_parameters' # older patched name # with open(paramfile1, 'w') as handle: # handle.write(paramcontents) # paramfile2 = '.gcppar' # with open(paramfile2, 'w') as handle: # handle.write(paramcontents) ###Two kinds of parameter files can be read in: A short and an extended version. Both are read from ###$HOME/.gcppar.$HOSTNAME by default. If the option -local is specified the file is read in from ###the current working directory: .gcppar ###The short version reads in: basis-keywo # Write dftd3_geometry file that supplies geometry to dispersion calc numAtoms = self.natom() geom = self.save_string_xyz() reals = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': numAtoms -= 1 else: reals.append(line) geomtext = str(numAtoms) + '\n\n' for line in reals: geomtext += line.strip() + '\n' geomfile = './gcp_geometry.xyz' with open(geomfile, 'w') as handle: handle.write(geomtext) # TODO somehow the variations on save_string_xyz and # whether natom and chgmult does or doesn't get written # have gotten all tangled. I fear this doesn't work # the same btwn libmints and qcdb or for ghosts # Call gcp program command = ['gcp', geomfile] command.extend(['-level', func]) if dertype != 0: command.append('-grad') try: #print('command', command) dashout = subprocess.Popen(command, stdout=subprocess.PIPE, env=lenv) except OSError as e: raise ValidationError('Program gcp not found in path. %s' % e) out, err = dashout.communicate() # Parse output success = False for line in out.splitlines(): line = line.decode('utf-8') if re.match(' Egcp:', line): sline = line.split() dashd = float(sline[1]) if re.match(' normal termination of gCP', line): success = True if not success: os.chdir(current_directory) raise Dftd3Error("""Unsuccessful gCP run.""") # Parse grad output if dertype != 0: derivfile = './gcp_gradient' dfile = open(derivfile, 'r') dashdderiv = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': dashdderiv.append([0.0, 0.0, 0.0]) else: dashdderiv.append([ float(x.replace('D', 'E')) for x in dfile.readline().split() ]) dfile.close() if len(dashdderiv) != self.natom(): raise ValidationError('Program gcp gradient file has %d atoms- %d expected.' % \ (len(dashdderiv), self.natom())) # Prepare results for Psi4 if isP4regime and dertype != 0: core.set_variable('GCP CORRECTION ENERGY', dashd) psi_dashdderiv = core.Matrix.from_list(dashdderiv) # Print program output to file if verbose if not verbose and isP4regime: verbose = True if core.get_option('SCF', 'PRINT') >= 3 else False if verbose: text = '\n ==> GCP Output <==\n' text += out.decode('utf-8') if dertype != 0: with open(derivfile, 'r') as handle: text += handle.read().replace('D', 'E') text += '\n' if isP4regime: core.print_out(text) else: print(text) # # Clean up files and remove scratch directory # os.unlink(paramfile1) # os.unlink(paramfile2) # os.unlink(geomfile) # if dertype != 0: # os.unlink(derivfile) # if defmoved is True: # os.rename(defaultfile + '_hide', defaultfile) os.chdir('..') # try: # shutil.rmtree(dftd3_tmpdir) # except OSError as e: # ValidationError('Unable to remove dftd3 temporary directory %s' % e) os.chdir(current_directory) # return -D & d(-D)/dx if dertype == -1: return dashd, dashdderiv elif dertype == 0: return dashd elif dertype == 1: return psi_dashdderiv
def print_sapt_dft_summary(data, name, short=False): ret = " %s Results\n" % name ret += " " + "-" * 105 + "\n" # Elst ret += print_sapt_var("Electrostatics", data["Elst10,r"]) + "\n" ret += print_sapt_var(" Elst1,r", data["Elst10,r"]) + "\n" ret += "\n" core.set_variable("SAPT ELST ENERGY", data["Elst10,r"]) # Exchange ret += print_sapt_var("Exchange", data["Exch10"]) + "\n" ret += print_sapt_var(" Exch1", data["Exch10"]) + "\n" ret += print_sapt_var(" Exch1(S^2)", data["Exch10(S^2)"]) + "\n" ret += "\n" core.set_variable("SAPT EXCH ENERGY", data["Exch10"]) # Induction ind = data["Ind20,r"] + data["Exch-Ind20,r"] ind_ab = data["Ind20,r (A<-B)"] + data["Exch-Ind20,r (A<-B)"] ind_ba = data["Ind20,r (A->B)"] + data["Exch-Ind20,r (A->B)"] if "Delta HF Correction" in list(data): ind += data["Delta HF Correction"] ret += print_sapt_var("Induction", ind) + "\n" ret += print_sapt_var(" Ind2,r", data["Ind20,r"]) + "\n" ret += print_sapt_var(" Exch-Ind2,r", data["Exch-Ind20,r"]) + "\n" ret += print_sapt_var(" Induction (A<-B)", ind_ab) + "\n" ret += print_sapt_var(" Induction (A->B)", ind_ba) + "\n" if "Delta HF Correction" in list(data): ret += print_sapt_var(" delta HF,r (2)", data["Delta HF Correction"]) + "\n" ret += "\n" core.set_variable("SAPT IND ENERGY", ind) # Exchange-dispersion scaling exch_disp_scheme = core.get_option("SAPT", "SAPT_DFT_EXCH_DISP_SCALE_SCHEME") if exch_disp_scheme == "NONE": data["Exch-Disp20,r"] = data["Exch-Disp20,u"] elif exch_disp_scheme == "FIXED": exch_disp_scale = core.get_option("SAPT", "SAPT_DFT_EXCH_DISP_FIXED_SCALE") data["Exch-Disp20,r"] = exch_disp_scale * data["Exch-Disp20,u"] elif exch_disp_scheme == "DISP": exch_disp_scale = data["Disp20"] / data["Disp20,u"] data["Exch-Disp20,r"] = exch_disp_scale * data["Exch-Disp20,u"] # Dispersion disp = data["Disp20"] + data["Exch-Disp20,r"] ret += print_sapt_var("Dispersion", disp) + "\n" ret += print_sapt_var(" Disp2,r", data["Disp20"]) + "\n" ret += print_sapt_var(" Disp2,u", data["Disp20,u"]) + "\n" if exch_disp_scheme != "NONE": ret += print_sapt_var(" Est. Exch-Disp2,r", data["Exch-Disp20,r"]) + "\n" ret += print_sapt_var(" Exch-Disp2,u", data["Exch-Disp20,u"]) + "\n" ret += "\n" core.set_variable("SAPT DISP ENERGY", disp) # Total energy total = data["Elst10,r"] + data["Exch10"] + ind + disp ret += print_sapt_var("Total %-17s" % name, total, start_spacer=" ") + "\n" core.set_variable("SAPT(DFT) TOTAL ENERGY", total) core.set_variable("SAPT TOTAL ENERGY", total) core.set_variable("CURRENT ENERGY", total) ret += " " + "-" * 105 + "\n" return ret
def print_ci_results(ciwfn, rname, scf_e, ci_e, print_opdm_no=False): """ Printing for all CI Wavefunctions """ # Print out energetics core.print_out("\n ==> Energetics <==\n\n") core.print_out(" SCF energy = %20.15f\n" % scf_e) if "CI" in rname: core.print_out(" Total CI energy = %20.15f\n" % ci_e) elif "MP" in rname: core.print_out(" Total MP energy = %20.15f\n" % ci_e) elif "ZAPT" in rname: core.print_out(" Total ZAPT energy = %20.15f\n" % ci_e) else: core.print_out(" Total MCSCF energy = %20.15f\n" % ci_e) # Nothing to be done for ZAPT or MP if ("MP" in rname) or ("ZAPT" in rname): core.print_out("\n") return # Initial info ci_nroots = core.get_option("DETCI", "NUM_ROOTS") irrep_labels = ciwfn.molecule().irrep_labels() # Grab the D-vector dvec = ciwfn.D_vector() dvec.init_io_files(True) for root in range(ci_nroots): core.print_out("\n ==> %s root %d information <==\n\n" % (rname, root)) # Print total energy root_e = core.get_variable("CI ROOT %d TOTAL ENERGY" % (root)) core.print_out(" %s Root %d energy = %20.15f\n" % (rname, root, root_e)) # Print natural occupations if print_opdm_no: core.print_out("\n Active Space Natural occupation numbers:\n\n") occs_list = [] r_opdm = ciwfn.get_opdm(root, root, "SUM", False) for h in range(len(r_opdm.nph)): if 0 in r_opdm.nph[h].shape: continue nocc, rot = np.linalg.eigh(r_opdm.nph[h]) for e in nocc: occs_list.append((e, irrep_labels[h])) occs_list.sort(key=lambda x: -x[0]) cnt = 0 for value, label in occs_list: value, label = occs_list[cnt] core.print_out(" %4s % 8.6f" % (label, value)) cnt += 1 if (cnt % 3) == 0: core.print_out("\n") if (cnt % 3): core.print_out("\n") # Print CIVector information ciwfn.print_vector(dvec, root) # True to keep the file dvec.close_io_files(True)
def prepare_options_for_modules( changedOnly: bool = False, commandsInsteadDict: bool = False, globalsOnly: bool = False, stateInsteadMediated: bool = False, ) -> Union[Dict, str]: """Capture current state of C++ psi4.core.Options information. Parameters ---------- changedOnly Record info only for options that have been set (may still be default). When False, records values for every option. commandsInsteadDict Return string of commands to exec to reset options in current form. When False, return nested dictionary with globals in 'GLOBALS' subdictionary and locals in subdictionaries by module. globalsOnly Record only global options to save time querying the psi4.core.Options object. When False, record module-level options, too. stateInsteadMediated When ``True``, querying this function for options to be later *reset* into the same state -- the raw values and has_changed status at the global and local levels. When ``False``, querying this function for mediated options to be *used* -- the results of the globals/locals handshake as computed by the Options object itself. Here, ``dict[module][option][value]`` is the value to be used by module. Returns ------- dict When ``commandsInsteadDict=False``. str When ``commandsInsteadDict=True``. .. caution:: Some features are not yet implemented. Buy a developer a coffee. - command return doesn't revoke has_changed setting for unchanged with changedOnly=False - not all kwargs are independent """ has_changed_snapshot = { module: core.options_to_python(module) for module in _modules } options = collections.defaultdict(dict) commands = '' for opt in core.get_global_option_list(): hoc = core.has_global_option_changed(opt) if hoc or not changedOnly: if opt in ['DFT_CUSTOM_FUNCTIONAL', 'EXTERN']: # Feb 2017 hack continue val = core.get_global_option(opt) options['GLOBALS'][opt] = {'value': val, 'has_changed': hoc} if isinstance(val, str): commands += """core.set_global_option('%s', '%s')\n""" % (opt, val) else: commands += """core.set_global_option('%s', %s)\n""" % (opt, val) if globalsOnly: continue opt_snapshot = { k: v[opt] for k, v in has_changed_snapshot.items() if opt in v } for module, (lhoc, ohoc) in opt_snapshot.items(): if stateInsteadMediated: hoc = lhoc else: hoc = ohoc if hoc or not changedOnly: if stateInsteadMediated: val = core.get_local_option(module, opt) else: val = core.get_option(module, opt) options[module][opt] = {'value': val, 'has_changed': hoc} if isinstance(val, str): commands += """core.set_local_option('%s', '%s', '%s')\n""" % ( module, opt, val) else: commands += """core.set_local_option('%s', '%s', %s)\n""" % ( module, opt, val) if commandsInsteadDict: return commands else: return options
def run_sf_sapt(name, **kwargs): optstash = p4util.OptionsState(['SCF_TYPE'], ['SCF', 'REFERENCE'], ['SCF', 'DFT_GRAC_SHIFT'], ['SCF', 'SAVE_JK']) core.tstart() # Alter default algorithm if not core.has_global_option_changed('SCF_TYPE'): core.set_global_option('SCF_TYPE', 'DF') core.prepare_options_for_module("SAPT") # Get the molecule of interest ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: sapt_dimer = kwargs.pop('molecule', core.get_active_molecule()) else: core.print_out( 'Warning! SAPT argument "ref_wfn" is only able to use molecule information.' ) sapt_dimer = ref_wfn.molecule() sapt_dimer, monomerA, monomerB = proc_util.prepare_sapt_molecule( sapt_dimer, "dimer") # Print out the title and some information core.print_out("\n") core.print_out( " ---------------------------------------------------------\n") core.print_out(" " + "Spin-Flip SAPT Procedure".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith and Konrad Patkowski".center(58) + "\n") core.print_out( " ---------------------------------------------------------\n") core.print_out("\n") core.print_out(" ==> Algorithm <==\n\n") core.print_out(" JK Algorithm %12s\n" % core.get_option("SCF", "SCF_TYPE")) core.print_out("\n") core.print_out(" Required computations:\n") core.print_out(" HF (Monomer A)\n") core.print_out(" HF (Monomer B)\n") core.print_out("\n") if (core.get_option('SCF', 'REFERENCE') != 'ROHF'): raise ValidationError( 'Spin-Flip SAPT currently only supports restricted open-shell references.' ) # Run the two monomer computations core.IO.set_default_namespace('dimer') data = {} if (core.get_global_option('SCF_TYPE') == 'DF'): core.set_global_option('DF_INTS_IO', 'SAVE') # Compute dimer wavefunction wfn_A = scf_helper("SCF", molecule=monomerA, banner="SF-SAPT: HF Monomer A", **kwargs) core.set_global_option("SAVE_JK", True) wfn_B = scf_helper("SCF", molecule=monomerB, banner="SF-SAPT: HF Monomer B", **kwargs) sapt_jk = wfn_B.jk() core.set_global_option("SAVE_JK", False) core.print_out("\n") core.print_out( " ---------------------------------------------------------\n") core.print_out(" " + "Spin-Flip SAPT Exchange and Electrostatics".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith and Konrad Patkowski".center(58) + "\n") core.print_out( " ---------------------------------------------------------\n") core.print_out("\n") sf_data = sapt_sf_terms.compute_sapt_sf(sapt_dimer, sapt_jk, wfn_A, wfn_B) # Print the results core.print_out(" Spin-Flip SAPT Results\n") core.print_out(" " + "-" * 103 + "\n") for key, value in sf_data.items(): value = sf_data[key] print_vals = (key, value * 1000, value * constants.hartree2kcalmol, value * constants.hartree2kJmol) string = " %-26s % 15.8f [mEh] % 15.8f [kcal/mol] % 15.8f [kJ/mol]\n" % print_vals core.print_out(string) core.print_out(" " + "-" * 103 + "\n\n") dimer_wfn = core.Wavefunction.build(sapt_dimer, wfn_A.basisset()) # Set variables psivar_tanslator = { "Elst10": "SAPT ELST ENERGY", "Exch10(S^2) [diagonal]": "SAPT EXCH10(S^2),DIAGONAL ENERGY", "Exch10(S^2) [off-diagonal]": "SAPT EXCH10(S^2),OFF-DIAGONAL ENERGY", "Exch10(S^2) [highspin]": "SAPT EXCH10(S^2),HIGHSPIN ENERGY", } for k, v in sf_data.items(): psi_k = psivar_tanslator[k] dimer_wfn.set_variable(psi_k, v) core.set_variable(psi_k, v) # Copy over highspin core.set_variable("SAPT EXCH ENERGY", sf_data["Exch10(S^2) [highspin]"]) core.tstop() return dimer_wfn
def scf_initialize(self): """Specialized initialization, compute integrals and does everything to prepare for iterations""" # Figure out memory distributions # Get memory in terms of doubles total_memory = (core.get_memory() / 8) * core.get_global_option("SCF_MEM_SAFETY_FACTOR") # Figure out how large the DFT collocation matrices are vbase = self.V_potential() if vbase: collocation_size = vbase.grid().collocation_size() if vbase.functional().ansatz() == 1: collocation_size *= 4 # First derivs elif vbase.functional().ansatz() == 2: collocation_size *= 10 # Second derivs else: collocation_size = 0 # Change allocation for collocation matrices based on DFT type jk = _build_jk(self, total_memory) jk_size = jk.memory_estimate() # Give remaining to collocation if total_memory > jk_size: collocation_memory = total_memory - jk_size # Give up to 10% to collocation elif (total_memory * 0.1) > collocation_size: collocation_memory = collocation_size else: collocation_memory = total_memory * 0.1 if collocation_memory > collocation_size: collocation_memory = collocation_size # Set constants self.iteration_ = 0 self.memory_jk_ = int(total_memory - collocation_memory) self.memory_collocation_ = int(collocation_memory) # Print out initial docc/socc/etc data if self.get_print(): core.print_out(" ==> Pre-Iterations <==\n\n") self.print_preiterations() if self.get_print(): core.print_out(" ==> Integral Setup <==\n\n") # Initialize EFP efp_enabled = hasattr(self.molecule(), 'EFP') if efp_enabled: # EFP: Set QM system, options, and callback. Display efp geom in [A] efpobj = self.molecule().EFP core.print_out(efpobj.banner()) core.print_out( efpobj.geometry_summary(units_to_bohr=constants.bohr2angstroms)) efpptc, efpcoords, efpopts = get_qm_atoms_opts(self.molecule()) efpobj.set_point_charges(efpptc, efpcoords) efpobj.set_opts(efpopts, label='psi', append='psi') efpobj.set_electron_density_field_fn(field_fn) # Initilize all integratals and perform the first guess if self.attempt_number_ == 1: mints = core.MintsHelper(self.basisset()) if core.get_global_option('RELATIVISTIC') in ['X2C', 'DKH']: mints.set_rel_basisset(self.get_basisset('BASIS_RELATIVISTIC')) mints.one_electron_integrals() self.initialize_jk(self.memory_jk_, jk=jk) if self.V_potential(): self.V_potential().build_collocation_cache( self.memory_collocation_) core.timer_on("HF: Form core H") self.form_H() core.timer_off("HF: Form core H") if efp_enabled: # EFP: Add in permanent moment contribution and cache core.timer_on("HF: Form Vefp") verbose = core.get_option('SCF', "PRINT") Vefp = modify_Fock_permanent(self.molecule(), mints, verbose=verbose - 1) Vefp = core.Matrix.from_array(Vefp) self.H().add(Vefp) Horig = self.H().clone() self.Horig = Horig core.print_out( " QM/EFP: iterating Total Energy including QM/EFP Induction\n" ) core.timer_off("HF: Form Vefp") core.timer_on("HF: Form S/X") self.form_Shalf() core.timer_off("HF: Form S/X") core.timer_on("HF: Guess") self.guess() core.timer_off("HF: Guess") else: # We're reading the orbitals from the previous set of iterations. self.form_D() self.set_energies("Total Energy", self.compute_initial_E()) # turn off VV10 for iterations if core.get_option( 'SCF', "DFT_VV10_POSTSCF") and self.functional().vv10_b() > 0.0: core.print_out(" VV10: post-SCF option active \n \n") self.functional().set_lock(False) self.functional().set_do_vv10(False) self.functional().set_lock(True)
def sapt_dft(dimer_wfn, wfn_A, wfn_B, sapt_jk=None, sapt_jk_B=None, data=None, print_header=True, cleanup_jk=True): """ The primary SAPT(DFT) algorithm to compute the interaction energy once the wavefunctions have been built. Example ------- dimer = psi4.geometry(''' Ne -- Ar 1 6.5 units bohr ''') psi4.set_options({"BASIS": "aug-cc-pVDZ"}) # Prepare the fragments sapt_dimer, monomerA, monomerB = psi4.proc_util.prepare_sapt_molecule(sapt_dimer, "dimer") # Run the first monomer set DFT_GRAC_SHIFT 0.203293 wfnA, energyA = psi4.energy("PBE0", monomer=monomerA, return_wfn=True) # Run the second monomer set DFT_GRAC_SHIFT 0.138264 wfnB, energyB = psi4.energy("PBE0", monomer=monomerB, return_wfn=True) # Build the dimer wavefunction wfnD = psi4.core.Wavefunction.build(sapt_dimer) # Compute SAPT(DFT) from the provided wavefunctions data = psi4.procrouting.sapt.sapt_dft(wfnD, wfnA, wfnB) """ # Handle the input options core.timer_on("SAPT(DFT):SAPT(DFT):JK") if print_header: sapt_dft_header() if sapt_jk is None: core.print_out("\n => Building SAPT JK object <= \n\n") sapt_jk = core.JK.build(dimer_wfn.basisset()) sapt_jk.set_do_J(True) sapt_jk.set_do_K(True) if wfn_A.functional().is_x_lrc(): sapt_jk.set_do_wK(True) sapt_jk.set_omega(wfn_A.functional().x_omega()) sapt_jk.initialize() sapt_jk.print_header() if wfn_B.functional().is_x_lrc() and (wfn_A.functional().x_omega() != wfn_B.functional().x_omega()): core.print_out(" => Monomer B: Building SAPT JK object <= \n\n") core.print_out( " Reason: MonomerA Omega != MonomerB Omega\n\n") sapt_jk_B = core.JK.build(dimer_wfn.basisset()) sapt_jk_B.set_do_J(True) sapt_jk_B.set_do_K(True) sapt_jk_B.set_do_wK(True) sapt_jk_B.set_omega(wfn_B.functional().x_omega()) sapt_jk_B.initialize() sapt_jk_B.print_header() else: sapt_jk.set_do_K(True) if data is None: data = {} # Build SAPT cache cache = sapt_jk_terms.build_sapt_jk_cache(wfn_A, wfn_B, sapt_jk, True) core.timer_off("SAPT(DFT):SAPT(DFT):JK") # Electrostatics core.timer_on("SAPT(DFT):SAPT(DFT):elst") elst = sapt_jk_terms.electrostatics(cache, True) data.update(elst) core.timer_off("SAPT(DFT):SAPT(DFT):elst") # Exchange core.timer_on("SAPT(DFT):SAPT(DFT):exch") exch = sapt_jk_terms.exchange(cache, sapt_jk, True) data.update(exch) core.timer_off("SAPT(DFT):SAPT(DFT):exch") # Induction core.timer_on("SAPT(DFT):SAPT(DFT):ind") ind = sapt_jk_terms.induction(cache, sapt_jk, True, sapt_jk_B=sapt_jk_B, maxiter=core.get_option("SAPT", "MAXITER"), conv=core.get_option("SAPT", "D_CONVERGENCE"), Sinf=core.get_option("SAPT", "DO_IND_EXCH_SINF")) data.update(ind) core.timer_off("SAPT(DFT):SAPT(DFT):ind") # Blow away JK object before doing MP2 for memory considerations if cleanup_jk: sapt_jk.finalize() # Dispersion core.timer_on("SAPT(DFT):SAPT(DFT):disp") primary_basis = wfn_A.basisset() core.print_out("\n") aux_basis = core.BasisSet.build(dimer_wfn.molecule(), "DF_BASIS_MP2", core.get_option("DFMP2", "DF_BASIS_MP2"), "RIFIT", core.get_global_option('BASIS')) fdds_disp = sapt_mp2_terms.df_fdds_dispersion(primary_basis, aux_basis, cache) data.update(fdds_disp) if core.get_option("SAPT", "SAPT_DFT_MP2_DISP_ALG") == "FISAPT": mp2_disp = sapt_mp2_terms.df_mp2_fisapt_dispersion(wfn_A, primary_basis, aux_basis, cache, do_print=True) else: mp2_disp = sapt_mp2_terms.df_mp2_sapt_dispersion(dimer_wfn, wfn_A, wfn_B, primary_basis, aux_basis, cache, do_print=True) data.update(mp2_disp) core.timer_off("SAPT(DFT):SAPT(DFT):disp") # Print out final data core.print_out("\n") core.print_out(print_sapt_dft_summary(data, "SAPT(DFT)")) return data
def fcidump(wfn, fname='INTDUMP', oe_ints=None): """Save integrals to file in FCIDUMP format as defined in Comp. Phys. Commun. 54 75 (1989) Additional one-electron integrals, including orbital energies, can also be saved. This latter format can be used with the HANDE QMC code but is not standard. :returns: None :raises: ValidationError when SCF wavefunction is not RHF :type wfn: :py:class:`~psi4.core.Wavefunction` :param wfn: set of molecule, basis, orbitals from which to generate cube files :param fname: name of the integrals file, defaults to INTDUMP :param oe_ints: list of additional one-electron integrals to save to file. So far only EIGENVALUES is a valid option. :examples: >>> # [1] Save one- and two-electron integrals to standard FCIDUMP format >>> E, wfn = energy('scf', return_wfn=True) >>> fcidump(wfn) >>> # [2] Save orbital energies, one- and two-electron integrals. >>> E, wfn = energy('scf', return_wfn=True) >>> fcidump(wfn, oe_ints=['EIGENVALUES']) """ # Get some options reference = core.get_option('SCF', 'REFERENCE') ints_tolerance = core.get_global_option('INTS_TOLERANCE') # Some sanity checks if reference not in ['RHF', 'UHF']: raise ValidationError('FCIDUMP not implemented for {} references\n'.format(reference)) if oe_ints is None: oe_ints = [] molecule = wfn.molecule() docc = wfn.doccpi() frzcpi = wfn.frzcpi() frzvpi = wfn.frzvpi() active_docc = docc - frzcpi active_socc = wfn.soccpi() active_mopi = wfn.nmopi() - frzcpi - frzvpi nbf = active_mopi.sum() if wfn.same_a_b_orbs() else 2 * active_mopi.sum() nirrep = wfn.nirrep() nelectron = 2 * active_docc.sum() + active_socc.sum() irrep_map = _irrep_map(wfn) wfn_irrep = 0 for h, n_socc in enumerate(active_socc): if n_socc % 2 == 1: wfn_irrep ^= h core.print_out('Writing integrals in FCIDUMP format to ' + fname + '\n') # Generate FCIDUMP header header = '&FCI\n' header += 'NORB={:d},\n'.format(nbf) header += 'NELEC={:d},\n'.format(nelectron) header += 'MS2={:d},\n'.format(wfn.nalpha() - wfn.nbeta()) header += 'UHF=.{}.,\n'.format(not wfn.same_a_b_orbs()).upper() orbsym = '' for h in range(active_mopi.n()): for n in range(frzcpi[h], frzcpi[h] + active_mopi[h]): orbsym += '{:d},'.format(irrep_map[h]) if not wfn.same_a_b_orbs(): orbsym += '{:d},'.format(irrep_map[h]) header += 'ORBSYM={}\n'.format(orbsym) header += 'ISYM={:d},\n'.format(irrep_map[wfn_irrep]) header += '&END\n' with open(fname, 'w') as intdump: intdump.write(header) # Get an IntegralTransform object check_iwl_file_from_scf_type(core.get_global_option('SCF_TYPE'), wfn) spaces = [core.MOSpace.all()] trans_type = core.IntegralTransform.TransformationType.Restricted if not wfn.same_a_b_orbs(): trans_type = core.IntegralTransform.TransformationType.Unrestricted ints = core.IntegralTransform(wfn, spaces, trans_type) ints.transform_tei(core.MOSpace.all(), core.MOSpace.all(), core.MOSpace.all(), core.MOSpace.all()) core.print_out('Integral transformation complete!\n') DPD_info = {'instance_id': ints.get_dpd_id(), 'alpha_MO': ints.DPD_ID('[A>=A]+'), 'beta_MO': 0} if not wfn.same_a_b_orbs(): DPD_info['beta_MO'] = ints.DPD_ID("[a>=a]+") # Write TEI to fname in FCIDUMP format core.fcidump_tei_helper(nirrep, wfn.same_a_b_orbs(), DPD_info, ints_tolerance, fname) # Read-in OEI and write them to fname in FCIDUMP format # Indexing functions to translate from zero-based (C and Python) to # one-based (Fortran) mo_idx = lambda x: x + 1 alpha_mo_idx = lambda x: 2 * x + 1 beta_mo_idx = lambda x: 2 * (x + 1) with open(fname, 'a') as intdump: core.print_out('Writing frozen core operator in FCIDUMP format to ' + fname + '\n') if reference == 'RHF': PSIF_MO_FZC = 'MO-basis Frozen-Core Operator' moH = core.Matrix(PSIF_MO_FZC, wfn.nmopi(), wfn.nmopi()) moH.load(core.IO.shared_object(), psif.PSIF_OEI) mo_slice = core.Slice(frzcpi, active_mopi) MO_FZC = moH.get_block(mo_slice, mo_slice) offset = 0 for h, block in enumerate(MO_FZC.nph): il = np.tril_indices(block.shape[0]) for index, x in np.ndenumerate(block[il]): row = mo_idx(il[0][index] + offset) col = mo_idx(il[1][index] + offset) if (abs(x) > ints_tolerance): intdump.write('{:29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(x, row, col, 0, 0)) offset += block.shape[0] # Additional one-electron integrals as requested in oe_ints # Orbital energies core.print_out('Writing orbital energies in FCIDUMP format to ' + fname + '\n') if 'EIGENVALUES' in oe_ints: eigs_dump = write_eigenvalues(wfn.epsilon_a().get_block(mo_slice).to_array(), mo_idx) intdump.write(eigs_dump) else: PSIF_MO_A_FZC = 'MO-basis Alpha Frozen-Core Oper' moH_A = core.Matrix(PSIF_MO_A_FZC, wfn.nmopi(), wfn.nmopi()) moH_A.load(core.IO.shared_object(), psif.PSIF_OEI) mo_slice = core.Slice(frzcpi, active_mopi) MO_FZC_A = moH_A.get_block(mo_slice, mo_slice) offset = 0 for h, block in enumerate(MO_FZC_A.nph): il = np.tril_indices(block.shape[0]) for index, x in np.ndenumerate(block[il]): row = alpha_mo_idx(il[0][index] + offset) col = alpha_mo_idx(il[1][index] + offset) if (abs(x) > ints_tolerance): intdump.write('{:29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(x, row, col, 0, 0)) offset += block.shape[0] PSIF_MO_B_FZC = 'MO-basis Beta Frozen-Core Oper' moH_B = core.Matrix(PSIF_MO_B_FZC, wfn.nmopi(), wfn.nmopi()) moH_B.load(core.IO.shared_object(), psif.PSIF_OEI) mo_slice = core.Slice(frzcpi, active_mopi) MO_FZC_B = moH_B.get_block(mo_slice, mo_slice) offset = 0 for h, block in enumerate(MO_FZC_B.nph): il = np.tril_indices(block.shape[0]) for index, x in np.ndenumerate(block[il]): row = beta_mo_idx(il[0][index] + offset) col = beta_mo_idx(il[1][index] + offset) if (abs(x) > ints_tolerance): intdump.write('{:29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(x, row, col, 0, 0)) offset += block.shape[0] # Additional one-electron integrals as requested in oe_ints # Orbital energies core.print_out('Writing orbital energies in FCIDUMP format to ' + fname + '\n') if 'EIGENVALUES' in oe_ints: alpha_eigs_dump = write_eigenvalues(wfn.epsilon_a().get_block(mo_slice).to_array(), alpha_mo_idx) beta_eigs_dump = write_eigenvalues(wfn.epsilon_b().get_block(mo_slice).to_array(), beta_mo_idx) intdump.write(alpha_eigs_dump + beta_eigs_dump) # Dipole integrals #core.print_out('Writing dipole moment OEI in FCIDUMP format to ' + fname + '\n') # Traceless quadrupole integrals #core.print_out('Writing traceless quadrupole moment OEI in FCIDUMP format to ' + fname + '\n') # Frozen core + nuclear repulsion energy core.print_out('Writing frozen core + nuclear repulsion energy in FCIDUMP format to ' + fname + '\n') e_fzc = ints.get_frozen_core_energy() e_nuc = molecule.nuclear_repulsion_energy(wfn.get_dipole_field_strength()) intdump.write('{: 29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(e_fzc + e_nuc, 0, 0, 0, 0)) core.print_out('Done generating {} with integrals in FCIDUMP format.\n'.format(fname))
def df_fdds_dispersion(primary, auxiliary, cache, leg_points=10, leg_lambda=0.3, do_print=True): rho_thresh = core.get_option("SAPT", "SAPT_FDDS_V2_RHO_CUTOFF") if do_print: core.print_out("\n ==> E20 Dispersion (CHF FDDS) <== \n\n") core.print_out(" Legendre Points: % 10d\n" % leg_points) core.print_out(" Lambda Shift: % 10.3f\n" % leg_lambda) core.print_out(" Fxc Kernal: % 10s\n" % "ALDA") core.print_out(" (P|Fxc|Q) Thresh: % 8.3e\n" % rho_thresh) # Build object df_matrix_keys = ["Cocc_A", "Cvir_A", "Cocc_B", "Cvir_B"] fdds_matrix_cache = {key: cache[key] for key in df_matrix_keys} df_vector_keys = ["eps_occ_A", "eps_vir_A", "eps_occ_B", "eps_vir_B"] fdds_vector_cache = {key: cache[key] for key in df_vector_keys} fdds_obj = core.FDDS_Dispersion(primary, auxiliary, fdds_matrix_cache, fdds_vector_cache) # Aux Densities D = fdds_obj.project_densities([cache["D_A"], cache["D_B"]]) # Temps half_Saux = fdds_obj.aux_overlap().clone() half_Saux.power(-0.5, 1.e-12) halfp_Saux = fdds_obj.aux_overlap().clone() halfp_Saux.power(0.5, 1.e-12) # Builds potentials W_A = fdds_obj.metric().clone() W_A.axpy(1.0, _compute_fxc(D[0], half_Saux, halfp_Saux, rho_thresh=rho_thresh)) W_B = fdds_obj.metric().clone() W_B.axpy(1.0, _compute_fxc(D[1], half_Saux, halfp_Saux, rho_thresh=rho_thresh)) # Nuke the densities del D metric = fdds_obj.metric() metric_inv = fdds_obj.metric_inv() # Integrate core.print_out("\n => Time Integration <= \n\n") val_pack = ("Omega", "Weight", "Disp20,u", "Disp20", "time [s]") core.print_out("% 12s % 12s % 14s % 14s % 10s\n" % val_pack) # print("% 12s % 12s % 14s % 14s % 10s" % val_pack) start_time = time.time() total_uc = 0 total_c = 0 for point, weight in zip(*np.polynomial.legendre.leggauss(leg_points)): omega = leg_lambda * (1.0 - point) / (1.0 + point) lambda_scale = ((2.0 * leg_lambda) / (point + 1.0)**2) # Monomer A X_A = fdds_obj.form_unc_amplitude("A", omega) # Coupled A X_A_coupled = X_A.clone() XSW_A = core.triplet(X_A, metric_inv, W_A, False, False, False) amplitude_inv = metric.clone() amplitude_inv.axpy(1.0, XSW_A) nremoved = 0 amplitude = amplitude_inv.pseudoinverse(1.e-13, nremoved) amplitude.transpose_this() # Why is this coming out transposed? X_A_coupled.axpy( -1.0, core.triplet(XSW_A, amplitude, X_A, False, False, False)) del XSW_A, amplitude X_B = fdds_obj.form_unc_amplitude("B", omega) # print(np.linalg.norm(X_B)) # Coupled B X_B_coupled = X_B.clone() XSW_B = core.triplet(X_B, metric_inv, W_B, False, False, False) amplitude_inv = metric.clone() amplitude_inv.axpy(1.0, XSW_B) amplitude = amplitude_inv.pseudoinverse(1.e-13, nremoved) amplitude.transpose_this() # Why is this coming out transposed? X_B_coupled.axpy( -1.0, core.triplet(XSW_B, amplitude, X_B, False, False, False)) del XSW_B, amplitude # Make sure the results are symmetrized for tensor in [X_A, X_B, X_A_coupled, X_B_coupled]: tensor.add(tensor.transpose()) tensor.scale(0.5) # Combine tmp_uc = core.triplet(metric_inv, X_A, metric_inv, False, False, False) value_uc = tmp_uc.vector_dot(X_B) del tmp_uc tmp_c = core.triplet(metric_inv, X_A_coupled, metric_inv, False, False, False) value_c = tmp_c.vector_dot(X_B_coupled) del tmp_c # Tally total_uc += value_uc * weight * lambda_scale total_c += value_c * weight * lambda_scale if do_print: tmp_disp_unc = value_uc * weight * lambda_scale tmp_disp = value_c * weight * lambda_scale fdds_time = time.time() - start_time val_pack = (omega, weight, tmp_disp_unc, tmp_disp, fdds_time) core.print_out("% 12.3e % 12.3e % 14.3e % 14.3e %10d\n" % val_pack) # print("% 12.3e % 12.3e % 14.3e % 14.3e %10d" % val_pack) Disp20_uc = -1.0 / (2.0 * np.pi) * total_uc Disp20_c = -1.0 / (2.0 * np.pi) * total_c core.print_out("\n") core.print_out(print_sapt_var("Disp20,u", Disp20_uc, short=True) + "\n") core.print_out(print_sapt_var("Disp20", Disp20_c, short=True) + "\n") return {"Disp20,FDDS (unc)": Disp20_uc, "Disp20": Disp20_c}
def ip_fitting(name, omega_l=0.05, omega_r=2.5, omega_convergence=1.0e-3, maxiter=20, **kwargs): """Optimize DFT omega parameter for molecular system. Parameters ---------- name : string or function DFT functional string name or function defining functional whose omega is to be optimized. omega_l : float, optional Minimum omega to be considered during fitting. omega_r : float, optional Maximum omega to be considered during fitting. molecule : :ref:`molecule <op_py_molecule>`, optional Target molecule (neutral) for which omega is to be tuned, if not last defined. omega_convergence : float, optional Threshold below which to consider omega converged. (formerly omega_tolerance) maxiter : int, optional Maximum number of iterations towards omega convergence. Returns ------- float Optimal omega parameter. """ optstash = p4util.OptionsState( ['SCF', 'REFERENCE'], ['SCF', 'GUESS'], ['SCF', 'DF_INTS_IO'], ['SCF', 'DFT_OMEGA'], ['DOCC'], ['SOCC']) kwargs = p4util.kwargs_lower(kwargs) # By default, do not read previous 180 orbitals file read = False read180 = '' if 'read' in kwargs: read = True read180 = kwargs['read'] if core.get_option('SCF', 'REFERENCE') != 'UKS': core.print_out(""" Requested procedure `ip_fitting` runs further calculations with UKS reference.\n""") core.set_local_option('SCF', 'REFERENCE', 'UKS') # Make sure the molecule the user provided is the active one, and neutral molecule = kwargs.pop('molecule', core.get_active_molecule()) molecule.update_geometry() if molecule.molecular_charge() != 0: raise ValidationError("""IP Fitting requires neutral molecule to start.""") if molecule.schoenflies_symbol() != 'c1': core.print_out(""" Requested procedure `ip_fitting` does not make use of molecular symmetry: """ """further calculations in C1 point group.\n""") molecule = molecule.clone() molecule.reset_point_group('c1') molecule.update_geometry() charge0 = molecule.molecular_charge() mult0 = molecule.multiplicity() # How many electrons are there? N = 0 for A in range(molecule.natom()): N += molecule.Z(A) N -= charge0 N = int(N) Nb = int((N - mult0 + 1) / 2) Na = int(N - Nb) # Work in the ot namespace for this procedure core.IO.set_default_namespace("ot") # Burn in to determine orbital eigenvalues if read: core.set_local_option("SCF", "GUESS", "READ") copy_file_to_scratch(read180, 'psi', 'ot', 180) core.set_local_option("SCF", "DF_INTS_IO", "SAVE") E, wfn = driver.energy('scf', dft_functional=name, return_wfn=True, molecule=molecule, banner='IP Fitting SCF: Burn-in', **kwargs) core.set_local_option("SCF", "DF_INTS_IO", "LOAD") if not wfn.functional().is_x_lrc(): raise ValidationError("""Not sensible to optimize omega for non-long-range-correction functional.""") # Determine H**O, to determine mult1 eps_a = wfn.epsilon_a() eps_b = wfn.epsilon_b() if Na == Nb: H**O = -Nb elif Nb == 0: H**O = Na else: E_a = eps_a.np[int(Na - 1)] E_b = eps_b.np[int(Nb - 1)] if E_a >= E_b: H**O = Na else: H**O = -Nb Na1 = Na Nb1 = Nb if H**O > 0: Na1 -= 1 else: Nb1 -= 1 charge1 = charge0 + 1 mult1 = Na1 - Nb1 + 1 omegas = [] E0s = [] E1s = [] kIPs = [] IPs = [] types = [] # Right endpoint core.set_local_option('SCF', 'DFT_OMEGA', omega_r) # Neutral if read: core.set_local_option("SCF", "GUESS", "READ") p4util.copy_file_to_scratch(read180, 'psi', 'ot', 180) molecule.set_molecular_charge(charge0) molecule.set_multiplicity(mult0) E0r, wfn = driver.energy('scf', dft_functional=name, return_wfn=True, molecule=molecule, banner='IP Fitting SCF: Neutral, Right Endpoint', **kwargs) eps_a = wfn.epsilon_a() eps_b = wfn.epsilon_b() if Nb == 0: E_HOMO = eps_a.np[int(Na - 1)] else: E_a = eps_a.np[int(Na - 1)] E_b = eps_b.np[int(Nb - 1)] E_HOMO = max(E_a, E_b) E_HOMOr = E_HOMO core.IO.change_file_namespace(180, "ot", "neutral") # Cation if read: core.set_local_option("SCF", "GUESS", "READ") p4util.copy_file_to_scratch(read180, 'psi', 'ot', 180) molecule.set_molecular_charge(charge1) molecule.set_multiplicity(mult1) E1r = driver.energy('scf', dft_functional=name, molecule=molecule, banner='IP Fitting SCF: Cation, Right Endpoint', **kwargs) core.IO.change_file_namespace(180, "ot", "cation") IPr = E1r - E0r kIPr = -E_HOMOr delta_r = IPr - kIPr if IPr > kIPr: raise ValidationError("""\n***IP Fitting Error: Right Omega limit should have kIP > IP: {} !> {}""".format(kIPr, IPr)) omegas.append(omega_r) types.append('Right Limit') E0s.append(E0r) E1s.append(E1r) IPs.append(IPr) kIPs.append(kIPr) # Use previous orbitals from here out core.set_local_option("SCF", "GUESS", "READ") # Left endpoint core.set_local_option('SCF', 'DFT_OMEGA', omega_l) # Neutral core.IO.change_file_namespace(180, "neutral", "ot") molecule.set_molecular_charge(charge0) molecule.set_multiplicity(mult0) core.set_global_option("DOCC", [Nb]) core.set_global_option("SOCC", [Na - Nb]) E0l, wfn = driver.energy('scf', dft_functional=name, return_wfn=True, molecule=molecule, banner='IP Fitting SCF: Neutral, Left Endpoint', **kwargs) eps_a = wfn.epsilon_a() eps_b = wfn.epsilon_b() if Nb == 0: E_HOMO = eps_a.np[int(Na - 1)] else: E_a = eps_a.np[int(Na - 1)] E_b = eps_b.np[int(Nb - 1)] E_HOMO = max(E_a, E_b) E_HOMOl = E_HOMO core.IO.change_file_namespace(180, "ot", "neutral") # Cation core.IO.change_file_namespace(180, "cation", "ot") molecule.set_molecular_charge(charge1) molecule.set_multiplicity(mult1) core.set_global_option("DOCC", [Nb1]) core.set_global_option("SOCC", [Na1 - Nb1]) E1l = driver.energy('scf', dft_functional=name, molecule=molecule, banner='IP Fitting SCF: Cation, Left Endpoint', **kwargs) core.IO.change_file_namespace(180, "ot", "cation") IPl = E1l - E0l kIPl = -E_HOMOl delta_l = IPl - kIPl if IPl < kIPl: raise ValidationError("""\n***IP Fitting Error: Left Omega limit should have kIP < IP: {} !< {}""".format(kIPl, IPl)) omegas.append(omega_l) types.append('Left Limit') E0s.append(E0l) E1s.append(E1l) IPs.append(IPl) kIPs.append(kIPl) converged = False repeat_l = 0 repeat_r = 0 for step in range(maxiter): # Regula Falsi (modified) if repeat_l > 1: delta_l /= 2.0 if repeat_r > 1: delta_r /= 2.0 omega = - (omega_r - omega_l) / (delta_r - delta_l) * delta_l + omega_l core.set_local_option('SCF', 'DFT_OMEGA', omega) # Neutral core.IO.change_file_namespace(180, "neutral", "ot") molecule.set_molecular_charge(charge0) molecule.set_multiplicity(mult0) core.set_global_option("DOCC", [Nb]) core.set_global_option("SOCC", [Na - Nb]) E0, wfn = driver.energy('scf', dft_functional=name, return_wfn=True, molecule=molecule, banner='IP Fitting SCF: Neutral, Omega = {:11.3E}'.format(omega), **kwargs) eps_a = wfn.epsilon_a() eps_b = wfn.epsilon_b() if Nb == 0: E_HOMO = eps_a.np[int(Na - 1)] else: E_a = eps_a.np[int(Na - 1)] E_b = eps_b.np[int(Nb - 1)] E_HOMO = max(E_a, E_b) core.IO.change_file_namespace(180, "ot", "neutral") # Cation core.IO.change_file_namespace(180, "cation", "ot") molecule.set_molecular_charge(charge1) molecule.set_multiplicity(mult1) core.set_global_option("DOCC", [Nb1]) core.set_global_option("SOCC", [Na1 - Nb1]) E1 = driver.energy('scf', dft_functional=name, molecule=molecule, banner='IP Fitting SCF: Cation, Omega = {:11.3E}'.format(omega), **kwargs) core.IO.change_file_namespace(180, "ot", "cation") IP = E1 - E0 kIP = -E_HOMO delta = IP - kIP if kIP > IP: omega_r = omega E0r = E0 E1r = E1 IPr = IP kIPr = kIP delta_r = delta repeat_r = 0 repeat_l += 1 else: omega_l = omega E0l = E0 E1l = E1 IPl = IP kIPl = kIP delta_l = delta repeat_l = 0 repeat_r += 1 omegas.append(omega) types.append('Regula-Falsi') E0s.append(E0) E1s.append(E1) IPs.append(IP) kIPs.append(kIP) # Termination if abs(omega_l - omega_r) < omega_convergence: converged = True break core.IO.set_default_namespace("") core.print_out("""\n ==> IP Fitting Results <==\n\n""") core.print_out(""" => Occupation Determination <= \n\n""") core.print_out(""" %6s %6s %6s %6s %6s %6s\n""" % ('N', 'Na', 'Nb', 'Charge', 'Mult', 'H**O')) core.print_out(""" Neutral: %6d %6d %6d %6d %6d %6d\n""" % (N, Na, Nb, charge0, mult0, H**O)) core.print_out(""" Cation: %6d %6d %6d %6d %6d\n\n""" % (N - 1, Na1, Nb1, charge1, mult1)) core.print_out(""" => Regula Falsi Iterations <=\n\n""") core.print_out(""" %3s %11s %14s %14s %14s %s\n""" % ('N','Omega','IP','kIP','Delta','Type')) for k in range(len(omegas)): core.print_out(""" %3d %11.3E %14.6E %14.6E %14.6E %s\n""" % (k + 1, omegas[k], IPs[k], kIPs[k], IPs[k] - kIPs[k], types[k])) optstash.restore() if converged: core.print_out("""\n IP Fitting Converged\n""") core.print_out(""" Final omega = %14.6E\n""" % ((omega_l + omega_r) / 2)) core.print_out("""\n "M,I. does the dying. Fleet just does the flying."\n""") core.print_out(""" -Starship Troopers\n""") else: raise ConvergenceError("""IP Fitting """, step + 1) return ((omega_l + omega_r) / 2)
def _initialize_findif(mol, freq_irrep_only, mode, initialize_string, verbose=0): """Perform initialization tasks needed by all primary functions. Parameters ---------- mol : qcdb.molecule or :py:class:`~psi4.core.Molecule` The molecule to displace freq_irrep_only : int The Cotton ordered irrep to get frequencies for. Choose -1 for all irreps. mode : {"1_0", "2_0", "2_1"} The first number specifies the derivative level determined from displacements, and the second number is the level determined at. initialize_string : function A function that returns the string to print to show the caller was entered. The string is both caller-specific and dependent on values determined in this function. verbose : int Set to 0 to silence extra print information, regardless of the print level. Used so the information is printed only during geometry generation, and not during the derivative computation as well. Returns ------- data : dict Miscellaneous information required by callers. """ core.print_out( "\n ----------------------------------------------------------\n" ) core.print_out(" FINDIF\n") core.print_out(" R. A. King and Jonathon Misiewicz\n") core.print_out( " ---------------------------------------------------------\n\n" ) print_lvl = core.get_option("FINDIF", "PRINT") num_pts = core.get_option("FINDIF", "POINTS") disp_size = core.get_option("FINDIF", "DISP_SIZE") data = {"print_lvl": print_lvl, "num_pts": num_pts, "disp_size": disp_size} if print_lvl: core.print_out(initialize_string(data)) # Get settings for CdSalcList, then get the CdSalcList. method_allowed_irreps = 0x1 if mode == "1_0" else 0xFF t_project = not core.get_global_option("EXTERN") and ( not core.get_global_option("PERTURB_H")) # core.get_option returns an int, but CdSalcList expect a bool, so re-cast r_project = t_project and bool(core.get_option("FINDIF", "FD_PROJECT")) salc_list = core.CdSalcList(mol, method_allowed_irreps, t_project, r_project) n_atom = mol.natom() n_irrep = salc_list.nirrep() n_salc = salc_list.ncd() if print_lvl and verbose: core.print_out(" Number of atoms is {:d}.\n".format(n_atom)) if method_allowed_irreps != 0x1: core.print_out(" Number of irreps is {:d}.\n".format(n_irrep)) core.print_out(" Number of {!s}SALCs is {:d}.\n".format( "" if method_allowed_irreps != 0x1 else "symmetric ", n_salc)) core.print_out( " Translations projected? {:d}. Rotations projected? {:d}.\n". format(t_project, r_project)) # TODO: Replace with a generator from a stencil to a set of points. # Diagonal displacements differ between the totally symmetric irrep, compared to all others. # Off-diagonal displacements are the same for both. pts_dict = { 3: { "sym_irr": ((-1, ), (1, )), "asym_irr": ((-1, ), ), "off": ((1, 1), (-1, -1)) }, 5: { "sym_irr": ((-2, ), (-1, ), (1, ), (2, )), "asym_irr": ((-2, ), (-1, )), "off": ((-1, -2), (-2, -1), (-1, -1), (1, -1), (-1, 1), (1, 1), (2, 1), (1, 2)) } } if num_pts not in pts_dict: raise ValidationError("FINDIF: Invalid number of points!") # Convention: x_pi means x_per_irrep. The ith element is x for irrep i, with Cotton ordering. salc_indices_pi = [[] for h in range(n_irrep)] # Validate that we have an irrep matching the user-specified irrep, if any. try: salc_indices_pi[freq_irrep_only] except (TypeError, IndexError): if freq_irrep_only != -1: raise ValidationError("FINDIF: Irrep value not in valid range.") # Populate salc_indices_pi for all irreps. for i, salc in enumerate(salc_list): salc_indices_pi[salc.irrep_index()].append(i) # If the method allows more than one irrep, print how the irreps partition the SALCS. if print_lvl and method_allowed_irreps != 0x1 and verbose: core.print_out(" Index of SALCs per irrep:\n") for h in range(n_irrep): if print_lvl > 1 or freq_irrep_only in {h, -1}: tmp = (" {:d} " * len(salc_indices_pi[h])).format(*salc_indices_pi[h]) core.print_out(" {:d} : ".format(h + 1) + tmp + "\n") core.print_out(" Number of SALCs per irrep:\n") for h in range(n_irrep): if print_lvl > 1 or freq_irrep_only in {h, -1}: core.print_out(" Irrep {:d}: {:d}\n".format( h + 1, len(salc_indices_pi[h]))) # Now that we've printed the SALCs, clear any that are not of user-specified symmetry. if freq_irrep_only != -1: for h in range(n_irrep): if h != freq_irrep_only: salc_indices_pi[h].clear() n_disp_pi = [] disps = pts_dict[num_pts] # We previously validated num_pts in pts_dict. for irrep, indices in enumerate(salc_indices_pi): n_disp = len(indices) * len( disps["asym_irr" if irrep != 0 else "sym_irr"]) if mode == "2_0": # Either len(indices) or len(indices)-1 is even, so dividing by two is safe. n_disp += len(indices) * (len(indices) - 1) // 2 * len( disps["off"]) n_disp_pi.append(n_disp) # Let's print out the number of geometries, the displacement multiplicity, and the CdSALCs! if print_lvl and verbose: core.print_out( " Number of geometries (including reference) is {:d}.\n".format( sum(n_disp_pi) + 1)) if method_allowed_irreps != 0x1: core.print_out(" Number of displacements per irrep:\n") for i, ndisp in enumerate(n_disp_pi, start=1): core.print_out(" Irrep {:d}: {:d}\n".format(i, ndisp)) if print_lvl > 1 and verbose: for salc in salc_list: salc.print_out() data.update({ "n_disp_pi": n_disp_pi, "n_irrep": n_irrep, "n_salc": n_salc, "n_atom": n_atom, "salc_list": salc_list, "salc_indices_pi": salc_indices_pi, "disps": disps, "project_translations": t_project, "project_rotations": r_project }) return data
def run_gaussian_2(name, **kwargs): # throw an exception for open-shells if (core.get_option('SCF', 'REFERENCE') != 'RHF'): raise ValidationError("""g2 computations require "reference rhf".""") # stash user options: optstash = p4util.OptionsState(['FNOCC', 'COMPUTE_TRIPLES'], ['FNOCC', 'COMPUTE_MP4_TRIPLES'], ['FREEZE_CORE'], ['MP2_TYPE'], ['SCF', 'SCF_TYPE']) # override default scf_type core.set_local_option('SCF', 'SCF_TYPE', 'PK') # optimize geometry at scf level core.clean() core.set_global_option('BASIS', "6-31G(D)") driver.optimize('scf') core.clean() # scf frequencies for zpe # NOTE This line should not be needed, but without it there's a seg fault scf_e, ref = driver.frequency('scf', return_wfn=True) # thermodynamic properties du = core.get_variable('INTERNAL ENERGY CORRECTION') dh = core.get_variable('ENTHALPY CORRECTION') dg = core.get_variable('GIBBS FREE ENERGY CORRECTION') freqs = ref.frequencies() nfreq = freqs.dim(0) freqsum = 0.0 for i in range(0, nfreq): freqsum += freqs.get(i) zpe = freqsum / p4const.psi_hartree2wavenumbers * 0.8929 * 0.5 core.clean() # optimize geometry at mp2 (no frozen core) level # note: freeze_core isn't an option in MP2 core.set_global_option('FREEZE_CORE', "FALSE") core.set_global_option('MP2_TYPE', 'CONV') driver.optimize('mp2') core.clean() # qcisd(t) core.set_local_option('FNOCC', 'COMPUTE_MP4_TRIPLES', "TRUE") core.set_global_option('FREEZE_CORE', "TRUE") core.set_global_option('BASIS', "6-311G(D_P)") ref = driver.proc.run_fnocc('qcisd(t)', return_wfn=True, **kwargs) # HLC: high-level correction based on number of valence electrons nirrep = ref.nirrep() frzcpi = ref.frzcpi() nfzc = 0 for i in range(0, nirrep): nfzc += frzcpi[i] nalpha = ref.nalpha() - nfzc nbeta = ref.nbeta() - nfzc # hlc of gaussian-2 hlc = -0.00481 * nalpha - 0.00019 * nbeta # hlc of gaussian-1 hlc1 = -0.00614 * nalpha eqci_6311gdp = core.get_variable("QCISD(T) TOTAL ENERGY") emp4_6311gd = core.get_variable("MP4 TOTAL ENERGY") emp2_6311gd = core.get_variable("MP2 TOTAL ENERGY") core.clean() # correction for diffuse functions core.set_global_option('BASIS', "6-311+G(D_P)") driver.energy('mp4') emp4_6311pg_dp = core.get_variable("MP4 TOTAL ENERGY") emp2_6311pg_dp = core.get_variable("MP2 TOTAL ENERGY") core.clean() # correction for polarization functions core.set_global_option('BASIS', "6-311G(2DF_P)") driver.energy('mp4') emp4_6311g2dfp = core.get_variable("MP4 TOTAL ENERGY") emp2_6311g2dfp = core.get_variable("MP2 TOTAL ENERGY") core.clean() # big basis mp2 core.set_global_option('BASIS', "6-311+G(3DF_2P)") #run_fnocc('_mp2',**kwargs) driver.energy('mp2') emp2_big = core.get_variable("MP2 TOTAL ENERGY") core.clean() eqci = eqci_6311gdp e_delta_g2 = emp2_big + emp2_6311gd - emp2_6311g2dfp - emp2_6311pg_dp e_plus = emp4_6311pg_dp - emp4_6311gd e_2df = emp4_6311g2dfp - emp4_6311gd eg2 = eqci + e_delta_g2 + e_plus + e_2df eg2_mp2_0k = eqci + (emp2_big - emp2_6311gd) + hlc + zpe core.print_out('\n') core.print_out(' ==> G1/G2 Energy Components <==\n') core.print_out('\n') core.print_out(' QCISD(T): %20.12lf\n' % eqci) core.print_out(' E(Delta): %20.12lf\n' % e_delta_g2) core.print_out(' E(2DF): %20.12lf\n' % e_2df) core.print_out(' E(+): %20.12lf\n' % e_plus) core.print_out(' E(G1 HLC): %20.12lf\n' % hlc1) core.print_out(' E(G2 HLC): %20.12lf\n' % hlc) core.print_out(' E(ZPE): %20.12lf\n' % zpe) core.print_out('\n') core.print_out(' ==> 0 Kelvin Results <==\n') core.print_out('\n') eg2_0k = eg2 + zpe + hlc core.print_out(' G1: %20.12lf\n' % (eqci + e_plus + e_2df + hlc1 + zpe)) core.print_out(' G2(MP2): %20.12lf\n' % eg2_mp2_0k) core.print_out(' G2: %20.12lf\n' % eg2_0k) core.set_variable("G1 TOTAL ENERGY", eqci + e_plus + e_2df + hlc1 + zpe) core.set_variable("G2 TOTAL ENERGY", eg2_0k) core.set_variable("G2(MP2) TOTAL ENERGY", eg2_mp2_0k) core.print_out('\n') T = core.get_global_option('T') core.print_out(' ==> %3.0lf Kelvin Results <==\n' % T) core.print_out('\n') internal_energy = eg2_mp2_0k + du - zpe / 0.8929 enthalpy = eg2_mp2_0k + dh - zpe / 0.8929 gibbs = eg2_mp2_0k + dg - zpe / 0.8929 core.print_out(' G2(MP2) energy: %20.12lf\n' % internal_energy) core.print_out(' G2(MP2) enthalpy: %20.12lf\n' % enthalpy) core.print_out(' G2(MP2) free energy: %20.12lf\n' % gibbs) core.print_out('\n') core.set_variable("G2(MP2) INTERNAL ENERGY", internal_energy) core.set_variable("G2(MP2) ENTHALPY", enthalpy) core.set_variable("G2(MP2) FREE ENERGY", gibbs) internal_energy = eg2_0k + du - zpe / 0.8929 enthalpy = eg2_0k + dh - zpe / 0.8929 gibbs = eg2_0k + dg - zpe / 0.8929 core.print_out(' G2 energy: %20.12lf\n' % internal_energy) core.print_out(' G2 enthalpy: %20.12lf\n' % enthalpy) core.print_out(' G2 free energy: %20.12lf\n' % gibbs) core.set_variable("CURRENT ENERGY", eg2_0k) core.set_variable("G2 INTERNAL ENERGY", internal_energy) core.set_variable("G2 ENTHALPY", enthalpy) core.set_variable("G2 FREE ENERGY", gibbs) core.clean() optstash.restore() # return 0K g2 results return eg2_0k
def scf_iterate(self, e_conv=None, d_conv=None): is_dfjk = core.get_global_option('SCF_TYPE').endswith('DF') verbose = core.get_option('SCF', "PRINT") reference = core.get_option('SCF', "REFERENCE") # self.member_data_ signals are non-local, used internally by c-side fns self.diis_enabled_ = _validate_diis() self.MOM_excited_ = _validate_MOM() self.diis_start_ = core.get_option('SCF', 'DIIS_START') damping_enabled = _validate_damping() soscf_enabled = _validate_soscf() frac_enabled = _validate_frac() efp_enabled = hasattr(self.molecule(), 'EFP') diis_rms = core.get_option('SCF', 'DIIS_RMS_ERROR') if self.iteration_ < 2: core.print_out(" ==> Iterations <==\n\n") core.print_out( "%s Total Energy Delta E %s |[F,P]|\n\n" % (" " if is_dfjk else "", "RMS" if diis_rms else "MAX")) # SCF iterations! SCFE_old = 0.0 Dnorm = 0.0 while True: self.iteration_ += 1 diis_performed = False soscf_performed = False self.frac_performed_ = False #self.MOM_performed_ = False # redundant from common_init() self.save_density_and_energy() if efp_enabled: # EFP: Add efp contribution to Fock matrix self.H().copy(self.Horig) global mints_psi4_yo mints_psi4_yo = core.MintsHelper(self.basisset()) Vefp = modify_Fock_induced(self.molecule().EFP, mints_psi4_yo, verbose=verbose - 1) Vefp = core.Matrix.from_array(Vefp) self.H().add(Vefp) SCFE = 0.0 self.clear_external_potentials() core.timer_on("HF: Form G") self.form_G() core.timer_off("HF: Form G") upcm = 0.0 if core.get_option('SCF', 'PCM'): calc_type = core.PCM.CalcType.Total if core.get_option("PCM", "PCM_SCF_TYPE") == "SEPARATE": calc_type = core.PCM.CalcType.NucAndEle Dt = self.Da().clone() Dt.add(self.Db()) upcm, Vpcm = self.get_PCM().compute_PCM_terms(Dt, calc_type) SCFE += upcm self.push_back_external_potential(Vpcm) self.set_variable("PCM POLARIZATION ENERGY", upcm) self.set_energies("PCM Polarization", upcm) core.timer_on("HF: Form F") # SAD: since we don't have orbitals yet, we might not be able # to form the real Fock matrix. Instead, build an initial one if (self.iteration_ == 0) and self.sad_: self.form_initial_F() else: self.form_F() core.timer_off("HF: Form F") if verbose > 3: self.Fa().print_out() self.Fb().print_out() SCFE += self.compute_E() if efp_enabled: global efp_Dt_psi4_yo # EFP: Add efp contribution to energy efp_Dt_psi4_yo = self.Da().clone() efp_Dt_psi4_yo.add(self.Db()) SCFE += self.molecule().EFP.get_wavefunction_dependent_energy() self.set_energies("Total Energy", SCFE) core.set_variable("SCF ITERATION ENERGY", SCFE) Ediff = SCFE - SCFE_old SCFE_old = SCFE status = [] # Check if we are doing SOSCF if (soscf_enabled and (self.iteration_ >= 3) and (Dnorm < core.get_option('SCF', 'SOSCF_START_CONVERGENCE'))): Dnorm = self.compute_orbital_gradient( False, core.get_option('SCF', 'DIIS_MAX_VECS')) diis_performed = False if self.functional().needs_xc(): base_name = "SOKS, nmicro=" else: base_name = "SOSCF, nmicro=" if not _converged(Ediff, Dnorm, e_conv=e_conv, d_conv=d_conv): nmicro = self.soscf_update( core.get_option('SCF', 'SOSCF_CONV'), core.get_option('SCF', 'SOSCF_MIN_ITER'), core.get_option('SCF', 'SOSCF_MAX_ITER'), core.get_option('SCF', 'SOSCF_PRINT')) # if zero, the soscf call bounced for some reason soscf_performed = (nmicro > 0) if soscf_performed: self.find_occupation() status.append(base_name + str(nmicro)) else: if verbose > 0: core.print_out( "Did not take a SOSCF step, using normal convergence methods\n" ) else: # need to ensure orthogonal orbitals and set epsilon status.append(base_name + "conv") core.timer_on("HF: Form C") self.form_C() core.timer_off("HF: Form C") soscf_performed = True # Stops DIIS if not soscf_performed: # Normal convergence procedures if we do not do SOSCF # SAD: form initial orbitals from the initial Fock matrix, and # reset the occupations. From here on, the density matrices # are correct. if (self.iteration_ == 0) and self.sad_: self.form_initial_C() self.reset_occupation() self.find_occupation() else: # Run DIIS core.timer_on("HF: DIIS") diis_performed = False add_to_diis_subspace = self.diis_enabled_ and self.iteration_ >= self.diis_start_ Dnorm = self.compute_orbital_gradient( add_to_diis_subspace, core.get_option('SCF', 'DIIS_MAX_VECS')) if (add_to_diis_subspace and core.get_option('SCF', 'DIIS_MIN_VECS') - 1): diis_performed = self.diis() if diis_performed: status.append("DIIS") core.timer_off("HF: DIIS") if verbose > 4 and diis_performed: core.print_out(" After DIIS:\n") self.Fa().print_out() self.Fb().print_out() # frac, MOM invoked here from Wfn::HF::find_occupation core.timer_on("HF: Form C") self.form_C() core.timer_off("HF: Form C") if self.MOM_performed_: status.append("MOM") if self.frac_performed_: status.append("FRAC") # Reset occupations if necessary if (self.iteration_ == 0) and self.reset_occ_: self.reset_occupation() self.find_occupation() # Form new density matrix core.timer_on("HF: Form D") self.form_D() core.timer_off("HF: Form D") self.set_variable("SCF ITERATION ENERGY", SCFE) # After we've built the new D, damp the update if (damping_enabled and self.iteration_ > 1 and Dnorm > core.get_option('SCF', 'DAMPING_CONVERGENCE')): damping_percentage = core.get_option('SCF', "DAMPING_PERCENTAGE") self.damping_update(damping_percentage * 0.01) status.append("DAMP={}%".format(round(damping_percentage))) if verbose > 3: self.Ca().print_out() self.Cb().print_out() self.Da().print_out() self.Db().print_out() # Print out the iteration core.print_out( " @%s%s iter %3s: %20.14f %12.5e %-11.5e %s\n" % ("DF-" if is_dfjk else "", reference, "SAD" if ((self.iteration_ == 0) and self.sad_) else self.iteration_, SCFE, Ediff, Dnorm, '/'.join(status))) # if a an excited MOM is requested but not started, don't stop yet if self.MOM_excited_ and not self.MOM_performed_: continue # if a fractional occupation is requested but not started, don't stop yet if frac_enabled and not self.frac_performed_: continue # Call any postiteration callbacks if not ((self.iteration_ == 0) and self.sad_) and _converged( Ediff, Dnorm, e_conv=e_conv, d_conv=d_conv): break if self.iteration_ >= core.get_option('SCF', 'MAXITER'): raise SCFConvergenceError("""SCF iterations""", self.iteration_, self, Ediff, Dnorm)
def _set_convergence_criterion(ptype, method_name, scf_Ec, pscf_Ec, scf_Dc, pscf_Dc, gen_Ec, verbose=1): r""" This function will set local SCF and global energy convergence criterion to the defaults listed at: http://www.psicode.org/psi4manual/master/scf.html#convergence-and- algorithm-defaults. SCF will be converged more tightly if a post-SCF method is select (pscf_Ec, and pscf_Dc) else the looser (scf_Ec, and scf_Dc convergence criterion will be used). ptype - Procedure type (energy, gradient, etc). Nearly always test on procedures['energy'] since that's guaranteed to exist for a method. method_name - Name of the method scf_Ec - E convergence criterion for scf target method pscf_Ec - E convergence criterion for scf of post-scf target method scf_Dc - D convergence criterion for scf target method pscf_Dc - D convergence criterion for scf of post-scf target method gen_Ec - E convergence criterion for post-scf target method """ optstash = p4util.OptionsState(['SCF', 'E_CONVERGENCE'], ['SCF', 'D_CONVERGENCE'], ['E_CONVERGENCE']) # Kind of want to move this out of here _method_exists(ptype, method_name) if verbose >= 2: print(' Setting convergence', end=' ') # Set method-dependent scf convergence criteria, check against energy routines if not core.has_option_changed('SCF', 'E_CONVERGENCE'): if procedures['energy'][method_name] in [proc.run_scf, proc.run_dft]: core.set_local_option('SCF', 'E_CONVERGENCE', scf_Ec) if verbose >= 2: print(scf_Ec, end=' ') else: core.set_local_option('SCF', 'E_CONVERGENCE', pscf_Ec) if verbose >= 2: print(pscf_Ec, end=' ') else: if verbose >= 2: print('CUSTOM', core.get_option('SCF', 'E_CONVERGENCE'), end=' ') if not core.has_option_changed('SCF', 'D_CONVERGENCE'): if procedures['energy'][method_name] in [proc.run_scf, proc.run_dft]: core.set_local_option('SCF', 'D_CONVERGENCE', scf_Dc) if verbose >= 2: print(scf_Dc, end=' ') else: core.set_local_option('SCF', 'D_CONVERGENCE', pscf_Dc) if verbose >= 2: print(pscf_Dc, end=' ') else: if verbose >= 2: print('CUSTOM', core.get_option('SCF', 'D_CONVERGENCE'), end=' ') # Set post-scf convergence criteria (global will cover all correlated modules) if not core.has_global_option_changed('E_CONVERGENCE'): if procedures['energy'][method_name] not in [ proc.run_scf, proc.run_dft ]: core.set_global_option('E_CONVERGENCE', gen_Ec) if verbose >= 2: print(gen_Ec, end=' ') else: if procedures['energy'][method_name] not in [ proc.run_scf, proc.run_dft ]: if verbose >= 2: print('CUSTOM', core.get_global_option('E_CONVERGENCE'), end=' ') if verbose >= 2: print('') return optstash
def scf_finalize_energy(self): """Performs stability analysis and calls back SCF with new guess if needed, Returns the SCF energy. This function should be called once orbitals are ready for energy/property computations, usually after iterations() is called. """ # post-scf vv10 correlation if core.get_option( 'SCF', "DFT_VV10_POSTSCF") and self.functional().vv10_b() > 0.0: self.functional().set_lock(False) self.functional().set_do_vv10(True) self.functional().set_lock(True) core.print_out( " ==> Computing Non-Self-Consistent VV10 Energy Correction <==\n\n" ) SCFE = 0.0 self.form_V() SCFE += self.compute_E() self.set_energies("Total Energy", SCFE) # Perform wavefunction stability analysis before doing # anything on a wavefunction that may not be truly converged. if core.get_option('SCF', 'STABILITY_ANALYSIS') != "NONE": # Don't bother computing needed integrals if we can't do anything with them. if self.functional().needs_xc(): raise ValidationError( "Stability analysis not yet supported for XC functionals.") # We need the integral file, make sure it is written and # compute it if needed if core.get_option('SCF', 'REFERENCE') != "UHF": psio = core.IO.shared_object() #psio.open(constants.PSIF_SO_TEI, 1) # PSIO_OPEN_OLD #try: # psio.tocscan(constants.PSIF_SO_TEI, "IWL Buffers") #except TypeError: # # "IWL Buffers" actually found but psio_tocentry can't be returned to Py # psio.close(constants.PSIF_SO_TEI, 1) #else: # # tocscan returned None # psio.close(constants.PSIF_SO_TEI, 1) # logic above foiled by psio_tocentry not returning None<--nullptr in pb11 2.2.1 # so forcibly recomputing for now until stability revamp core.print_out(" SO Integrals not on disk. Computing...") mints = core.MintsHelper(self.basisset()) #next 2 lines fix a bug that prohibits relativistic stability analysis if core.get_global_option('RELATIVISTIC') in ['X2C', 'DKH']: mints.set_rel_basisset(self.get_basisset('BASIS_RELATIVISTIC')) mints.integrals() core.print_out("done.\n") # Q: Not worth exporting all the layers of psio, right? follow = self.stability_analysis() while follow and self.attempt_number_ <= core.get_option( 'SCF', 'MAX_ATTEMPTS'): self.attempt_number_ += 1 core.print_out( " Running SCF again with the rotated orbitals.\n") if self.initialized_diis_manager_: self.diis_manager().reset_subspace() # reading the rotated orbitals in before starting iterations self.form_D() self.set_energies("Total Energy", self.compute_initial_E()) self.iterations() follow = self.stability_analysis() if follow and self.attempt_number_ > core.get_option( 'SCF', 'MAX_ATTEMPTS'): core.print_out( " There's still a negative eigenvalue. Try modifying FOLLOW_STEP_SCALE\n" ) core.print_out( " or increasing MAX_ATTEMPTS (not available for PK integrals).\n" ) # At this point, we are not doing any more SCF cycles # and we can compute and print final quantities. if hasattr(self.molecule(), 'EFP'): efpobj = self.molecule().EFP efpobj.compute() # do_gradient=do_gradient) efpene = efpobj.get_energy(label='psi') efp_wfn_independent_energy = efpene['total'] - efpene['ind'] self.set_energies("EFP", efpene['total']) SCFE = self.get_energies("Total Energy") SCFE += efp_wfn_independent_energy self.set_energies("Total Energy", SCFE) core.print_out(efpobj.energy_summary(scfefp=SCFE, label='psi')) self.set_variable( 'EFP ELST ENERGY', efpene['electrostatic'] + efpene['charge_penetration'] + efpene['electrostatic_point_charges']) self.set_variable('EFP IND ENERGY', efpene['polarization']) self.set_variable('EFP DISP ENERGY', efpene['dispersion']) self.set_variable('EFP EXCH ENERGY', efpene['exchange_repulsion']) self.set_variable('EFP TOTAL ENERGY', efpene['total']) self.set_variable('CURRENT ENERGY', efpene['total']) core.print_out("\n ==> Post-Iterations <==\n\n") self.check_phases() self.compute_spin_contamination() self.frac_renormalize() reference = core.get_option("SCF", "REFERENCE") energy = self.get_energies("Total Energy") # fail_on_maxiter = core.get_option("SCF", "FAIL_ON_MAXITER") # if converged or not fail_on_maxiter: # # if print_lvl > 0: # self.print_orbitals() # # if converged: # core.print_out(" Energy converged.\n\n") # else: # core.print_out(" Energy did not converge, but proceeding anyway.\n\n") if core.get_option('SCF', 'PRINT') > 0: self.print_orbitals() is_dfjk = core.get_global_option('SCF_TYPE').endswith('DF') core.print_out(" @%s%s Final Energy: %20.14f" % ('DF-' if is_dfjk else '', reference, energy)) # if (perturb_h_) { # core.print_out(" with %f %f %f perturbation" % # (dipole_field_strength_[0], dipole_field_strength_[1], dipole_field_strength_[2])) # } core.print_out("\n\n") self.print_energies() self.clear_external_potentials() if core.get_option('SCF', 'PCM'): calc_type = core.PCM.CalcType.Total if core.get_option("PCM", "PCM_SCF_TYPE") == "SEPARATE": calc_type = core.PCM.CalcType.NucAndEle Dt = self.Da().clone() Dt.add(self.Db()) _, Vpcm = self.get_PCM().compute_PCM_terms(Dt, calc_type) self.push_back_external_potential(Vpcm) # Properties # Comments so that autodoc utility will find these PSI variables # Process::environment.globals["SCF DIPOLE X"] = # Process::environment.globals["SCF DIPOLE Y"] = # Process::environment.globals["SCF DIPOLE Z"] = # Process::environment.globals["SCF QUADRUPOLE XX"] = # Process::environment.globals["SCF QUADRUPOLE XY"] = # Process::environment.globals["SCF QUADRUPOLE XZ"] = # Process::environment.globals["SCF QUADRUPOLE YY"] = # Process::environment.globals["SCF QUADRUPOLE YZ"] = # Process::environment.globals["SCF QUADRUPOLE ZZ"] = # Orbitals are always saved, in case an MO guess is requested later # save_orbitals() # Shove variables into global space for k, v in self.variables().items(): core.set_variable(k, v) # TODO re-enable self.finalize() if self.V_potential(): self.V_potential().clear_collocation_cache() core.print_out("\nComputation Completed\n") return energy
def run_roa(name, **kwargs): """ Main driver for managing Raman Optical activity computations with CC response theory. Uses distributed finite differences approach --> 1. Sets up a database to keep track of running/finished/waiting computations. 2. Generates separate input files for displaced geometries. 3. When all displacements are run, collects the necessary information from each displaced computation, and computes final result. """ # Get list of omega values -> Make sure we only have one wavelength # Catch this now before any real work gets done omega = core.get_option('CCRESPONSE', 'OMEGA') if len(omega) > 2: raise Exception( 'ROA scattering can only be performed for one wavelength.') else: pass core.print_out('Running ROA computation. Subdirectories for each ' 'required displaced geometry have been created.\n\n') dbno = 0 # Initialize database db = shelve.open('database', writeback=True) # Check if final result is in here # ->if we have already computed roa, back up the dict # ->copy it setting this flag to false and continue if ('roa_computed' in db) and (db['roa_computed']): db2 = shelve.open('.database.bak{}'.format(dbno), writeback=True) dbno += 1 for key, value in db.items(): db2[key] = value db2.close() db['roa_computed'] = False else: db['roa_computed'] = False if 'inputs_generated' not in db: findif_response_utils.initialize_database(db, name, "roa", ["roa_tensor"]) # Generate input files if not db['inputs_generated']: findif_response_utils.generate_inputs(db, name) # handled by helper db['inputs_generated'] = True # Check job status if db['inputs_generated'] and not db['jobs_complete']: print('Checking status') findif_response_utils.stat(db) for job, status in db['job_status'].items(): print("{} --> {}".format(job, status)) # Compute ROA Scattering if db['jobs_complete']: mygauge = core.get_option('CCRESPONSE', 'GAUGE') consider_gauge = { 'LENGTH': ['Length Gauge'], 'VELOCITY': ['Modified Velocity Gauge'], 'BOTH': ['Length Gauge', 'Modified Velocity Gauge'] } gauge_list = ["{} Results".format(x) for x in consider_gauge[mygauge]] # Gather data dip_polar_list = findif_response_utils.collect_displaced_matrix_data( db, 'Dipole Polarizability', 3) opt_rot_list = [ x for x in (findif_response_utils.collect_displaced_matrix_data( db, "Optical Rotation Tensor ({})".format(gauge), 3) for gauge in consider_gauge[mygauge]) ] dip_quad_polar_list = findif_response_utils.collect_displaced_matrix_data( db, "Electric-Dipole/Quadrupole Polarizability", 9) # Compute Scattering # Run new function (src/bin/ccresponse/scatter.cc) core.print_out('Running scatter function') step = core.get_local_option('FINDIF', 'DISP_SIZE') for g_idx, gauge in enumerate(opt_rot_list): print( '\n\n----------------------------------------------------------------------' ) print('\t%%%%%%%%%% {} %%%%%%%%%%'.format(gauge_list[g_idx])) print( '----------------------------------------------------------------------\n\n' ) core.print_out( '\n\n----------------------------------------------------------------------\n' ) core.print_out('\t%%%%%%%%%% {} %%%%%%%%%%\n'.format( gauge_list[g_idx])) core.print_out( '----------------------------------------------------------------------\n\n' ) print( 'roa.py:85 I am not being passed a molecule, grabbing from global :(' ) core.scatter(core.get_active_molecule(), step, dip_polar_list, gauge, dip_quad_polar_list) db['roa_computed'] = True db.close()
def run_dftd3(mol, func=None, dashlvl=None, dashparam=None, dertype=None, verbose=False): """Compute dispersion correction using Grimme's DFTD3 executable. Function to call Grimme's dftd3 program to compute the -D correction of level `dashlvl` using parameters for the functional `func`. `dashparam` can supply a full set of dispersion parameters in the absence of `func` or individual overrides in the presence of `func`. The DFTD3 executable must be independently compiled and found in :envvar:`PATH` or :envvar:`PSIPATH`. Parameters ---------- mol : qcdb.Molecule or psi4.core.Molecule or str Molecule on which to run dispersion calculation. Both qcdb and psi4.core Molecule classes have been extended by this method, so either allowed. Alternately, a string that can be instantiated into a qcdb.Molecule. func : str or None Density functional (Psi4, not Turbomole, names) for which to load parameters from dashcoeff[dashlvl][func]. This is not passed to DFTD3 and thus may be a dummy or `None`. Any or all parameters initialized can be overwritten via `dashparam`. dashlvl : {'d2p4', 'd2gr', 'd3zero', 'd3bj', 'd3mzero', d3mbj', 'd', 'd2', 'd3', 'd3m'} Flavor of a posteriori dispersion correction for which to load parameters and call procedure in DFTD3. Must be a keys in dashcoeff dict (or a key in dashalias that resolves to one). dashparam : dict, optional Dictionary of the same keys as dashcoeff[dashlvl] used to override any or all values initialized by dashcoeff[dashlvl][func]. dertype : {None, 0, 'none', 'energy', 1, 'first', 'gradient'}, optional Maximum derivative level at which to run DFTD3. For large `mol`, energy-only calculations can be significantly more efficient. Also controls return values, see below. verbose : bool, optional When `True`, additionally include DFTD3 output in output. Returns ------- energy : float, optional When `dertype` is 0, energy [Eh]. gradient : list of lists of floats or psi4.core.Matrix, optional When `dertype` is 1, (nat, 3) gradient [Eh/a0]. (energy, gradient) : float and list of lists of floats or psi4.core.Matrix, optional When `dertype` is unspecified, both energy [Eh] and (nat, 3) gradient [Eh/a0]. Notes ----- research site: https://www.chemie.uni-bonn.de/pctc/mulliken-center/software/dft-d3 Psi4 mode: When `psi4` the python module is importable at `import qcdb` time, Psi4 mode is activated, with the following alterations: * output goes to output file * gradient returned as psi4.core.Matrix, not list o'lists * scratch is written to randomly named subdirectory of psi scratch * psivar "DISPERSION CORRECTION ENERGY" is set * `verbose` triggered when PRINT keywork of SCF module >=3 """ # Create (if necessary) and update qcdb.Molecule if isinstance(mol, (Molecule, core.Molecule)): # 1st: called on a qcdb.Molecule # 2nd: called on a python export of a psi4.Molecule (py-side through Psi4's driver) pass elif isinstance(mol, basestring): # called on a string representation of a psi4.Molecule (c-side through psi4.Dispersion) mol = Molecule(mol) else: raise ValidationError("""Argument mol must be psi4string or qcdb.Molecule""") mol.update_geometry() # Validate arguments if dertype is None: dertype = -1 elif der0th.match(str(dertype)): dertype = 0 elif der1st.match(str(dertype)): dertype = 1 elif der2nd.match(str(dertype)): raise ValidationError("""Requested derivative level 'dertype' %s not valid for run_dftd3.""" % (dertype)) else: raise ValidationError("""Requested derivative level 'dertype' %s not valid for run_dftd3.""" % (dertype)) if dashlvl is not None: dashlvl = dashlvl.lower() dashlvl = get_dispersion_aliases()[dashlvl] if dashlvl in get_dispersion_aliases() else dashlvl if dashlvl not in dashcoeff.keys(): raise ValidationError("""-D correction level %s is not available. Choose among %s.""" % (dashlvl, dashcoeff.keys())) else: raise ValidationError("""Must specify a dashlvl""") if func is not None: dftd3_params = dash_server(func, dashlvl) else: dftd3_params = {} if dashparam is not None: dftd3_params.update(dashparam) # Move ~/.dftd3par.<hostname> out of the way so it won't interfere defaultfile = os.path.expanduser('~') + '/.dftd3par.' + socket.gethostname() defmoved = False if os.path.isfile(defaultfile): os.rename(defaultfile, defaultfile + '_hide') defmoved = True # Find environment by merging PSIPATH and PATH environment variables lenv = { 'PATH': ':'.join([os.path.abspath(x) for x in os.environ.get('PSIPATH', '').split(':') if x != '']) + \ ':' + os.environ.get('PATH'), 'LD_LIBRARY_PATH': os.environ.get('LD_LIBRARY_PATH') } # Filter out None values as subprocess will fault on them lenv = {k: v for k, v in lenv.items() if v is not None} # Find out if running from Psi4 for scratch details and such # try: # import psi4 # except ImportError as err: # isP4regime = False # else: # isP4regime = True # Setup unique scratch directory and move in current_directory = os.getcwd() if isP4regime: psioh = core.IOManager.shared_object() psio = core.IO.shared_object() os.chdir(psioh.get_default_path()) dftd3_tmpdir = 'psi.' + str(os.getpid()) + '.' + psio.get_default_namespace() + \ '.dftd3.' + str(uuid.uuid4())[:8] else: dftd3_tmpdir = os.environ['HOME'] + os.sep + 'dftd3_' + str(uuid.uuid4())[:8] if os.path.exists(dftd3_tmpdir) is False: os.mkdir(dftd3_tmpdir) os.chdir(dftd3_tmpdir) # Write dftd3_parameters file that governs dispersion calc paramcontents = dftd3_coeff_formatter(dashlvl, dftd3_params) paramfile1 = 'dftd3_parameters' # older patched name with open(paramfile1, 'w') as handle: handle.write(paramcontents) paramfile2 = '.dftd3par.local' # new mainline name with open(paramfile2, 'w') as handle: handle.write(paramcontents) # Write dftd3_geometry file that supplies geometry to dispersion calc numAtoms = mol.natom() # We seem to have a problem with one atom, force the correct result if numAtoms == 1: dashd = 0.0 dashdderiv = core.Matrix(1, 3) if dertype == -1: return dashd, dashdderiv elif dertype == 0: return dashd elif dertype == 1: return dashdderiv geom = mol.save_string_xyz() reals = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': numAtoms -= 1 else: reals.append(line) geomtext = str(numAtoms) + '\n\n' for line in reals: geomtext += line.strip() + '\n' geomfile = './dftd3_geometry.xyz' with open(geomfile, 'w') as handle: handle.write(geomtext) # TODO somehow the variations on save_string_xyz and # whether natom and chgmult does or doesn't get written # have gotten all tangled. I fear this doesn't work # the same btwn libmints and qcdb or for ghosts # Call dftd3 program command = ['dftd3', geomfile] if dertype != 0: command.append('-grad') try: dashout = subprocess.Popen(command, stdout=subprocess.PIPE, env=lenv) except OSError as e: raise ValidationError('Program dftd3 not found in path. %s' % e) out, err = dashout.communicate() # Parse output (could go further and break into E6, E8, E10 and Cn coeff) success = False for line in out.splitlines(): line = line.decode('utf-8') if re.match(' Edisp /kcal,au', line): sline = line.split() dashd = float(sline[3]) if re.match(' normal termination of dftd3', line): success = True if not success: os.chdir(current_directory) raise Dftd3Error("""Unsuccessful run. Possibly -D variant not available in dftd3 version.""") # Parse grad output if dertype != 0: derivfile = './dftd3_gradient' dfile = open(derivfile, 'r') dashdderiv = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': dashdderiv.append([0.0, 0.0, 0.0]) else: dashdderiv.append([float(x.replace('D', 'E')) for x in dfile.readline().split()]) dfile.close() if len(dashdderiv) != mol.natom(): raise ValidationError('Program dftd3 gradient file has %d atoms- %d expected.' % \ (len(dashdderiv), mol.natom())) # Prepare results for Psi4 if isP4regime and dertype != 0: core.set_variable('DISPERSION CORRECTION ENERGY', dashd) psi_dashdderiv = core.Matrix.from_list(dashdderiv) # Print program output to file if verbose if not verbose and isP4regime: verbose = True if core.get_option('SCF', 'PRINT') >= 3 else False if verbose: text = '\n ==> DFTD3 Output <==\n' text += out.decode('utf-8') if dertype != 0: with open(derivfile, 'r') as handle: text += handle.read().replace('D', 'E') text += '\n' if isP4regime: core.print_out(text) else: print(text) # Clean up files and remove scratch directory os.unlink(paramfile1) os.unlink(paramfile2) os.unlink(geomfile) if dertype != 0: os.unlink(derivfile) if defmoved is True: os.rename(defaultfile + '_hide', defaultfile) os.chdir('..') try: shutil.rmtree(dftd3_tmpdir) except OSError as e: ValidationError('Unable to remove dftd3 temporary directory %s' % e) os.chdir(current_directory) # return -D & d(-D)/dx if dertype == -1: return dashd, dashdderiv elif dertype == 0: return dashd elif dertype == 1: return psi_dashdderiv
def fisapt_compute_energy(self): """Computes the FSAPT energy. FISAPT::compute_energy""" # => Header <= self.print_header() # => Zero-th Order Wavefunction <= core.timer_on("FISAPT: Setup") self.localize() self.partition() self.overlap() self.kinetic() self.nuclear() self.coulomb() core.timer_off("FISAPT: Setup") core.timer_on("FISAPT: Monomer SCF") self.scf() core.timer_off("FISAPT: Monomer SCF") self.freeze_core() self.unify() core.timer_on("FISAPT: Subsys E") self.dHF() core.timer_off("FISAPT: Subsys E") # => SAPT0 <= core.timer_on("FISAPT:SAPT:elst") self.elst() core.timer_off("FISAPT:SAPT:elst") core.timer_on("FISAPT:SAPT:exch") self.exch() core.timer_off("FISAPT:SAPT:exch") core.timer_on("FISAPT:SAPT:ind") self.ind() core.timer_off("FISAPT:SAPT:ind") if not core.get_option("FISAPT", "FISAPT_DO_FSAPT"): core.timer_on("FISAPT:SAPT:disp") self.disp(matrices_, vectors_, true) # Expensive, only do if needed core.timer_off("FISAPT:SAPT:disp") # => F-SAPT0 <= if core.get_option("FISAPT", "FISAPT_DO_FSAPT"): core.timer_on("FISAPT:FSAPT:loc") self.flocalize() core.timer_off("FISAPT:FSAPT:loc") core.timer_on("FISAPT:FSAPT:elst") self.felst() core.timer_off("FISAPT:FSAPT:elst") core.timer_on("FISAPT:FSAPT:exch") self.fexch() core.timer_off("FISAPT:FSAPT:exch") core.timer_on("FISAPT:FSAPT:ind") self.find() core.timer_off("FISAPT:FSAPT:ind") core.timer_on("FISAPT:FSAPT:disp") self.fdisp() core.timer_off("FISAPT:FSAPT:disp") self.fdrop() # => Scalar-Field Analysis <= if core.get_option("FISAPT", "FISAPT_DO_PLOT"): core.timer_on("FISAPT:FSAPT:cubeplot") self.plot() core.timer_off("FISAPT:FSAPT:cubeplot") # => Summary <= self.print_trailer()
def run_dftd3(mol, func=None, dashlvl=None, dashparam=None, dertype=None, verbose=False): """Compute dispersion correction using Grimme's DFTD3 executable. Function to call Grimme's dftd3 program to compute the -D correction of level `dashlvl` using parameters for the functional `func`. `dashparam` can supply a full set of dispersion parameters in the absence of `func` or individual overrides in the presence of `func`. The DFTD3 executable must be independently compiled and found in :envvar:`PATH` or :envvar:`PSIPATH`. Parameters ---------- mol : qcdb.Molecule or psi4.core.Molecule or str Molecule on which to run dispersion calculation. Both qcdb and psi4.core Molecule classes have been extended by this method, so either allowed. Alternately, a string that can be instantiated into a qcdb.Molecule. func : str or None Density functional (Psi4, not Turbomole, names) for which to load parameters from dashcoeff[dashlvl][func]. This is not passed to DFTD3 and thus may be a dummy or `None`. Any or all parameters initialized can be overwritten via `dashparam`. dashlvl : {'d2p4', 'd2gr', 'd3zero', 'd3bj', 'd3mzero', d3mbj', 'd', 'd2', 'd3', 'd3m'} Flavor of a posteriori dispersion correction for which to load parameters and call procedure in DFTD3. Must be a keys in dashcoeff dict (or a key in dashalias that resolves to one). dashparam : dict, optional Dictionary of the same keys as dashcoeff[dashlvl] used to override any or all values initialized by dashcoeff[dashlvl][func]. dertype : {None, 0, 'none', 'energy', 1, 'first', 'gradient'}, optional Maximum derivative level at which to run DFTD3. For large `mol`, energy-only calculations can be significantly more efficient. Also controls return values, see below. verbose : bool, optional When `True`, additionally include DFTD3 output in output. Returns ------- energy : float, optional When `dertype` is 0, energy [Eh]. gradient : list of lists of floats or psi4.core.Matrix, optional When `dertype` is 1, (nat, 3) gradient [Eh/a0]. (energy, gradient) : float and list of lists of floats or psi4.core.Matrix, optional When `dertype` is unspecified, both energy [Eh] and (nat, 3) gradient [Eh/a0]. Notes ----- research site: https://www.chemie.uni-bonn.de/pctc/mulliken-center/software/dft-d3 Psi4 mode: When `psi4` the python module is importable at `import qcdb` time, Psi4 mode is activated, with the following alterations: * output goes to output file * gradient returned as psi4.core.Matrix, not list o'lists * scratch is written to randomly named subdirectory of psi scratch * psivar "DISPERSION CORRECTION ENERGY" is set * `verbose` triggered when PRINT keywork of SCF module >=3 """ # Create (if necessary) and update qcdb.Molecule if isinstance(mol, (Molecule, core.Molecule)): # 1st: called on a qcdb.Molecule # 2nd: called on a python export of a psi4.Molecule (py-side through Psi4's driver) pass elif isinstance(mol, basestring): # called on a string representation of a psi4.Molecule (c-side through psi4.Dispersion) mol = Molecule(mol) else: raise ValidationError("""Argument mol must be psi4string or qcdb.Molecule""") mol.update_geometry() # Validate arguments if dertype is None: dertype = -1 elif der0th.match(str(dertype)): dertype = 0 elif der1st.match(str(dertype)): dertype = 1 elif der2nd.match(str(dertype)): raise ValidationError("""Requested derivative level 'dertype' %s not valid for run_dftd3.""" % (dertype)) else: raise ValidationError("""Requested derivative level 'dertype' %s not valid for run_dftd3.""" % (dertype)) if dashlvl is not None: dashlvl = dashlvl.lower() dashlvl = get_dispersion_aliases()[dashlvl] if dashlvl in get_dispersion_aliases() else dashlvl if dashlvl not in dashcoeff.keys(): raise ValidationError("""-D correction level %s is not available. Choose among %s.""" % (dashlvl, dashcoeff.keys())) else: raise ValidationError("""Must specify a dashlvl""") if func is not None: dftd3_params = dash_server(func, dashlvl) else: dftd3_params = {} if dashparam is not None: dftd3_params.update(dashparam) # Move ~/.dftd3par.<hostname> out of the way so it won't interfere defaultfile = os.path.expanduser('~') + '/.dftd3par.' + socket.gethostname() defmoved = False if os.path.isfile(defaultfile): os.rename(defaultfile, defaultfile + '_hide') defmoved = True # Find environment by merging PSIPATH and PATH environment variables lenv = { 'PATH': ':'.join([os.path.abspath(x) for x in os.environ.get('PSIPATH', '').split(':') if x != '']) + \ ':' + os.environ.get('PATH'), 'LD_LIBRARY_PATH': os.environ.get('LD_LIBRARY_PATH') } # Filter out None values as subprocess will fault on them lenv = {k: v for k, v in lenv.items() if v is not None} # Find out if running from Psi4 for scratch details and such # try: # import psi4 # except ImportError as err: # isP4regime = False # else: # isP4regime = True # Setup unique scratch directory and move in current_directory = os.getcwd() if isP4regime: psioh = core.IOManager.shared_object() psio = core.IO.shared_object() os.chdir(psioh.get_default_path()) dftd3_tmpdir = 'psi.' + str(os.getpid()) + '.' + psio.get_default_namespace() + \ '.dftd3.' + str(uuid.uuid4())[:8] else: dftd3_tmpdir = os.environ['HOME'] + os.sep + 'dftd3_' + str(uuid.uuid4())[:8] if os.path.exists(dftd3_tmpdir) is False: os.mkdir(dftd3_tmpdir) os.chdir(dftd3_tmpdir) # Write dftd3_parameters file that governs dispersion calc paramcontents = dftd3_coeff_formatter(dashlvl, dftd3_params) paramfile1 = 'dftd3_parameters' # older patched name with open(paramfile1, 'w') as handle: handle.write(paramcontents) paramfile2 = '.dftd3par.local' # new mainline name with open(paramfile2, 'w') as handle: handle.write(paramcontents) # Write dftd3_geometry file that supplies geometry to dispersion calc numAtoms = mol.natom() # We seem to have a problem with one atom, force the correct result if numAtoms == 1: os.chdir(current_directory) dashd = 0.0 dashdderiv = core.Matrix(1, 3) if dertype == -1: return dashd, dashdderiv elif dertype == 0: return dashd elif dertype == 1: return dashdderiv geom = mol.save_string_xyz() reals = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': numAtoms -= 1 else: reals.append(line) geomtext = str(numAtoms) + '\n\n' for line in reals: geomtext += line.strip() + '\n' geomfile = './dftd3_geometry.xyz' with open(geomfile, 'w') as handle: handle.write(geomtext) # TODO somehow the variations on save_string_xyz and # whether natom and chgmult does or doesn't get written # have gotten all tangled. I fear this doesn't work # the same btwn libmints and qcdb or for ghosts # Call dftd3 program command = ['dftd3', geomfile] if dertype != 0: command.append('-grad') try: dashout = subprocess.Popen(command, stdout=subprocess.PIPE, env=lenv) except OSError as e: raise ValidationError('Program dftd3 not found in path. %s' % e) out, err = dashout.communicate() # Parse output (could go further and break into E6, E8, E10 and Cn coeff) success = False for line in out.splitlines(): line = line.decode('utf-8') if re.match(' Edisp /kcal,au', line): sline = line.split() dashd = float(sline[3]) if re.match(' normal termination of dftd3', line): success = True if not success: os.chdir(current_directory) raise Dftd3Error("""Unsuccessful run. Possibly -D variant not available in dftd3 version.""") # Parse grad output if dertype != 0: derivfile = './dftd3_gradient' dfile = open(derivfile, 'r') dashdderiv = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': dashdderiv.append([0.0, 0.0, 0.0]) else: dashdderiv.append([float(x.replace('D', 'E')) for x in dfile.readline().split()]) dfile.close() if len(dashdderiv) != mol.natom(): raise ValidationError('Program dftd3 gradient file has %d atoms- %d expected.' % \ (len(dashdderiv), mol.natom())) # Prepare results for Psi4 if isP4regime and dertype != 0: core.set_variable('DISPERSION CORRECTION ENERGY', dashd) psi_dashdderiv = core.Matrix.from_list(dashdderiv) # Print program output to file if verbose if not verbose and isP4regime: verbose = True if core.get_option('SCF', 'PRINT') >= 3 else False if verbose: text = '\n ==> DFTD3 Output <==\n' text += out.decode('utf-8') if dertype != 0: with open(derivfile, 'r') as handle: text += handle.read().replace('D', 'E') text += '\n' if isP4regime: core.print_out(text) else: print(text) # Clean up files and remove scratch directory os.unlink(paramfile1) os.unlink(paramfile2) os.unlink(geomfile) if dertype != 0: os.unlink(derivfile) if defmoved is True: os.rename(defaultfile + '_hide', defaultfile) os.chdir('..') try: shutil.rmtree(dftd3_tmpdir) except OSError as e: ValidationError('Unable to remove dftd3 temporary directory %s' % e) os.chdir(current_directory) # return -D & d(-D)/dx if dertype == -1: return dashd, dashdderiv elif dertype == 0: return dashd elif dertype == 1: return psi_dashdderiv
def run_dftd3(self, func=None, dashlvl=None, dashparam=None, dertype=None, verbose=False): """Function to call Grimme's dftd3 program (http://toc.uni-muenster.de/DFTD3/) to compute the -D correction of level *dashlvl* using parameters for the functional *func*. The dictionary *dashparam* can be used to supply a full set of dispersion parameters in the absense of *func* or to supply individual overrides in the presence of *func*. Returns energy if *dertype* is 0, gradient if *dertype* is 1, else tuple of energy and gradient if *dertype* unspecified. The dftd3 executable must be independently compiled and found in :envvar:`PATH` or :envvar:`PSIPATH`. *self* may be either a qcdb.Molecule (sensibly) or a psi4.Molecule (works b/c psi4.Molecule has been extended by this method py-side and only public interface fns used) or a string that can be instantiated into a qcdb.Molecule. func - functional alias or None dashlvl - functional type d2gr/d3zero/d3bj/d3mzero/d3mbj dashparam - dictionary dertype = derivative level """ # Create (if necessary) and update qcdb.Molecule if isinstance(self, Molecule): # called on a qcdb.Molecule pass elif isinstance(self, core.Molecule): # called on a python export of a psi4.Molecule (py-side through Psi4's driver) self.create_psi4_string_from_molecule() elif isinstance(self, basestring): # called on a string representation of a psi4.Molecule (c-side through psi4.Dispersion) self = Molecule(self) else: raise ValidationError( """Argument mol must be psi4string or qcdb.Molecule""") self.update_geometry() # Validate arguments if dertype is None: dertype = -1 elif der0th.match(str(dertype)): dertype = 0 elif der1st.match(str(dertype)): dertype = 1 elif der2nd.match(str(dertype)): raise ValidationError( 'Requested derivative level \'dertype\' %s not valid for run_dftd3.' % (dertype)) else: raise ValidationError( 'Requested derivative level \'dertype\' %s not valid for run_dftd3.' % (dertype)) if dashlvl is not None: dashlvl = dashlvl.lower() dashlvl = dash_alias['-' + dashlvl][1:] if ( '-' + dashlvl) in dash_alias.keys() else dashlvl if dashlvl not in dashcoeff.keys(): raise ValidationError( """-D correction level %s is not available. Choose among %s.""" % (dashlvl, dashcoeff.keys())) else: raise ValidationError("""Must specify a dashlvl""") if func is not None: dftd3_params = dash_server(func, dashlvl) else: dftd3_params = {} if dashparam is not None: dftd3_params.update(dashparam) # Move ~/.dftd3par.<hostname> out of the way so it won't interfere defaultfile = os.path.expanduser( '~') + '/.dftd3par.' + socket.gethostname() defmoved = False if os.path.isfile(defaultfile): os.rename(defaultfile, defaultfile + '_hide') defmoved = True # Find environment by merging PSIPATH and PATH environment variables lenv = { 'PATH': ':'.join([os.path.abspath(x) for x in os.environ.get('PSIPATH', '').split(':') if x != '']) + \ ':' + os.environ.get('PATH'), 'LD_LIBRARY_PATH': os.environ.get('LD_LIBRARY_PATH') } # Filter out None values as subprocess will fault on them lenv = {k: v for k, v in lenv.items() if v is not None} # Find out if running from Psi4 for scratch details and such # try: # import psi4 # except ImportError as err: # isP4regime = False # else: # isP4regime = True # Setup unique scratch directory and move in current_directory = os.getcwd() if isP4regime: psioh = core.IOManager.shared_object() psio = core.IO.shared_object() os.chdir(psioh.get_default_path()) dftd3_tmpdir = 'psi.' + str(os.getpid()) + '.' + psio.get_default_namespace() + \ '.dftd3.' + str(random.randint(0, 99999)) else: dftd3_tmpdir = os.environ['HOME'] + os.sep + 'dftd3_' + str( random.randint(0, 99999)) if os.path.exists(dftd3_tmpdir) is False: os.mkdir(dftd3_tmpdir) os.chdir(dftd3_tmpdir) # Write dftd3_parameters file that governs dispersion calc paramcontents = dftd3_coeff_formatter(dashlvl, dftd3_params) paramfile1 = 'dftd3_parameters' # older patched name with open(paramfile1, 'w') as handle: handle.write(paramcontents) paramfile2 = '.dftd3par.local' # new mainline name with open(paramfile2, 'w') as handle: handle.write(paramcontents) # Write dftd3_geometry file that supplies geometry to dispersion calc numAtoms = self.natom() # We seem to have a problem with one atom, force the correct result if numAtoms == 1: dashd = 0.0 dashdderiv = core.Matrix(1, 3) if dertype == -1: return dashd, dashdderiv elif dertype == 0: return dashd elif dertype == 1: return dashdderiv geom = self.save_string_xyz() reals = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': numAtoms -= 1 else: reals.append(line) geomtext = str(numAtoms) + '\n\n' for line in reals: geomtext += line.strip() + '\n' geomfile = './dftd3_geometry.xyz' with open(geomfile, 'w') as handle: handle.write(geomtext) # TODO somehow the variations on save_string_xyz and # whether natom and chgmult does or doesn't get written # have gotten all tangled. I fear this doesn't work # the same btwn libmints and qcdb or for ghosts # Call dftd3 program command = ['dftd3', geomfile] if dertype != 0: command.append('-grad') try: dashout = subprocess.Popen(command, stdout=subprocess.PIPE, env=lenv) except OSError as e: raise ValidationError('Program dftd3 not found in path. %s' % e) out, err = dashout.communicate() # Parse output (could go further and break into E6, E8, E10 and Cn coeff) success = False for line in out.splitlines(): line = line.decode('utf-8') if re.match(' Edisp /kcal,au', line): sline = line.split() dashd = float(sline[3]) if re.match(' normal termination of dftd3', line): success = True if not success: os.chdir(current_directory) raise Dftd3Error( """Unsuccessful run. Possibly -D variant not available in dftd3 version.""" ) # Parse grad output if dertype != 0: derivfile = './dftd3_gradient' dfile = open(derivfile, 'r') dashdderiv = [] for line in geom.splitlines(): lline = line.split() if len(lline) != 4: continue if lline[0] == 'Gh': dashdderiv.append([0.0, 0.0, 0.0]) else: dashdderiv.append([ float(x.replace('D', 'E')) for x in dfile.readline().split() ]) dfile.close() if len(dashdderiv) != self.natom(): raise ValidationError('Program dftd3 gradient file has %d atoms- %d expected.' % \ (len(dashdderiv), self.natom())) # Prepare results for Psi4 if isP4regime and dertype != 0: core.set_variable('DISPERSION CORRECTION ENERGY', dashd) psi_dashdderiv = core.Matrix(self.natom(), 3) psi_dashdderiv.set(dashdderiv) # Print program output to file if verbose if isP4regime: verbose = True if core.get_option('SCF', 'PRINT') >= 3 else False if verbose: text = '\n ==> DFTD3 Output <==\n' text += out if dertype != 0: with open(derivfile, 'r') as handle: text += handle.read().replace('D', 'E') text += '\n' if isP4regime: core.print_out(text) else: print(text) # Clean up files and remove scratch directory os.unlink(paramfile1) os.unlink(paramfile2) os.unlink(geomfile) if dertype != 0: os.unlink(derivfile) if defmoved is True: os.rename(defaultfile + '_hide', defaultfile) os.chdir('..') try: shutil.rmtree(dftd3_tmpdir) except OSError as e: ValidationError('Unable to remove dftd3 temporary directory %s' % e) os.chdir(current_directory) # return -D & d(-D)/dx if dertype == -1: return dashd, dashdderiv elif dertype == 0: return dashd elif dertype == 1: return psi_dashdderiv
def _basis_projection(self, oldcalc, newcalc): # There's a bug in Psi4 upcasting between custom basis sets # https://github.com/psi4/psi4/issues/719, so we do it ourselves. start_time = time.time() assert (oldcalc.B, oldcalc.Z) != (newcalc.B, newcalc.Z) read_filename = self._fmt_mo_fn(oldcalc) data = np.load(read_filename) Ca_occ = core.Matrix.np_read(data, "Ca_occ") Cb_occ = core.Matrix.np_read(data, "Cb_occ") puream = int(data["BasisSet PUREAM"]) old_molecule = self.molecule(oldcalc) with psiopts('BASIS %s' % self.basis_sets[oldcalc.Z]): old_basis = core.BasisSet.build(old_molecule, "ORBITAL", self.basis_sets[oldcalc.Z], puream=puream) if isinstance(old_basis, tuple) and len(old_basis) == 2: # newer versions of psi return a second ECP basis old_basis = old_basis[0] new_molecule = self.molecule(newcalc) with psiopts('BASIS %s' % self.basis_sets[newcalc.Z]): new_basis = core.BasisSet.build(new_molecule, 'ORBITAL', self.basis_sets[newcalc.Z], puream=puream) if isinstance(new_basis, tuple) and len(new_basis) == 2: # newer versions of psi return a second ECP basis base_wfn = core.Wavefunction(new_molecule, *new_basis) new_basis = new_basis[0] else: base_wfn = core.Wavefunction(new_molecule, new_basis) nalphapi = core.Dimension.from_list(data["nalphapi"]) nbetapi = core.Dimension.from_list(data["nbetapi"]) pCa = base_wfn.basis_projection(Ca_occ, nalphapi, old_basis, new_basis) pCb = base_wfn.basis_projection(Cb_occ, nbetapi, old_basis, new_basis) new_data = {} new_data.update(pCa.np_write(None, prefix="Ca_occ")) new_data.update(pCb.np_write(None, prefix="Cb_occ")) new_data["reference"] = core.get_option('SCF', 'REFERENCE') new_data["symmetry"] = new_molecule.schoenflies_symbol() new_data["BasisSet"] = new_basis.name() new_data["BasisSet PUREAM"] = puream core.print_out( '\n Computing basis set projection from {calc1} to {calc2} (elapsed={time:.2f})\n' .format( calc1=self._display_name(oldcalc).lower(), calc2=self._display_name(newcalc).lower(), time=time.time() - start_time, )) # Workaround for https://github.com/psi4/psi4/pull/750 for key, value in new_data.items(): if isinstance(value, np.ndarray) and value.flags['OWNDATA'] == False: new_data[key] = np.copy(value) return new_data
def fisapt_compute_energy(self): """Computes the FSAPT energy. FISAPT::compute_energy""" # => Header <= self.print_header() # => Zero-th Order Wavefunction <= core.timer_on("FISAPT: Setup") self.localize() self.partition() self.overlap() self.kinetic() self.nuclear() self.coulomb() core.timer_off("FISAPT: Setup") core.timer_on("FISAPT: Monomer SCF") self.scf() core.timer_off("FISAPT: Monomer SCF") self.freeze_core() self.unify() core.timer_on("FISAPT: Subsys E") self.dHF() core.timer_off("FISAPT: Subsys E") # => SAPT0 <= core.timer_on("FISAPT:SAPT:elst") self.elst() core.timer_off("FISAPT:SAPT:elst") core.timer_on("FISAPT:SAPT:exch") self.exch() core.timer_off("FISAPT:SAPT:exch") core.timer_on("FISAPT:SAPT:ind") self.ind() core.timer_off("FISAPT:SAPT:ind") if not core.get_option("FISAPT", "FISAPT_DO_FSAPT"): core.timer_on("FISAPT:SAPT:disp") self.disp( self.matrices(), self.vectors(), True ) # Expensive, only do if needed # unteseted translation of below # self.disp(matrices_, vectors_, true) # Expensive, only do if needed core.timer_off("FISAPT:SAPT:disp") # => F-SAPT0 <= if core.get_option("FISAPT", "FISAPT_DO_FSAPT"): core.timer_on("FISAPT:FSAPT:loc") self.flocalize() core.timer_off("FISAPT:FSAPT:loc") core.timer_on("FISAPT:FSAPT:elst") self.felst() core.timer_off("FISAPT:FSAPT:elst") core.timer_on("FISAPT:FSAPT:exch") self.fexch() core.timer_off("FISAPT:FSAPT:exch") core.timer_on("FISAPT:FSAPT:ind") self.find() core.timer_off("FISAPT:FSAPT:ind") if core.get_option("FISAPT", "FISAPT_DO_FSAPT_DISP"): core.timer_on("FISAPT:FSAPT:disp") self.fdisp() core.timer_off("FISAPT:FSAPT:disp") #else: # # Build Empirical Dispersion # dashD = empirical_dispersion.EmpiricalDispersion(name_hint='SAPT0-D3M') # dashD.print_out() # # Compute -D # Edisp = dashD.compute_energy(core.get_active_molecule()) # core.set_variable('{} DISPERSION CORRECTION ENERGY'.format(dashD.fctldash), Edisp) # Printing # text = [] # text.append(" => {}: Empirical Dispersion <=".format(dashD.fctldash.upper())) # text.append(" ") # text.append(dashD.description) # text.append(dashD.dashlevel_citation.rstrip()) # text.append("\n Empirical Dispersion Energy [Eh] = {:24.16f}\n".format(Edisp)) # text.append('\n') # core.print_out('\n'.join(text)) self.fdrop() # => Scalar-Field Analysis <= if core.get_option("FISAPT", "FISAPT_DO_PLOT"): core.timer_on("FISAPT:FSAPT:cubeplot") self.plot() core.timer_off("FISAPT:FSAPT:cubeplot") # => Summary <= self.print_trailer()
def mcscf_solver(ref_wfn): # Build CIWavefunction core.prepare_options_for_module("DETCI") ciwfn = core.CIWavefunction(ref_wfn) # Hush a lot of CI output ciwfn.set_print(0) # Begin with a normal two-step step_type = 'Initial CI' total_step = core.Matrix("Total step", ciwfn.get_dimension('OA'), ciwfn.get_dimension('AV')) start_orbs = ciwfn.get_orbitals("ROT").clone() ciwfn.set_orbitals("ROT", start_orbs) # Grab da options mcscf_orb_grad_conv = core.get_option("DETCI", "MCSCF_R_CONVERGENCE") mcscf_e_conv = core.get_option("DETCI", "MCSCF_E_CONVERGENCE") mcscf_max_macroiteration = core.get_option("DETCI", "MCSCF_MAXITER") mcscf_type = core.get_option("DETCI", "MCSCF_TYPE") mcscf_d_file = core.get_option("DETCI", "CI_FILE_START") + 3 mcscf_nroots = core.get_option("DETCI", "NUM_ROOTS") mcscf_wavefunction_type = core.get_option("DETCI", "WFN") mcscf_ndet = ciwfn.ndet() mcscf_nuclear_energy = ciwfn.molecule().nuclear_repulsion_energy() mcscf_steplimit = core.get_option("DETCI", "MCSCF_MAX_ROT") mcscf_rotate = core.get_option("DETCI", "MCSCF_ROTATE") # DIIS info mcscf_diis_start = core.get_option("DETCI", "MCSCF_DIIS_START") mcscf_diis_freq = core.get_option("DETCI", "MCSCF_DIIS_FREQ") mcscf_diis_error_type = core.get_option("DETCI", "MCSCF_DIIS_ERROR_TYPE") mcscf_diis_max_vecs = core.get_option("DETCI", "MCSCF_DIIS_MAX_VECS") # One-step info mcscf_target_conv_type = core.get_option("DETCI", "MCSCF_ALGORITHM") mcscf_so_start_grad = core.get_option("DETCI", "MCSCF_SO_START_GRAD") mcscf_so_start_e = core.get_option("DETCI", "MCSCF_SO_START_E") mcscf_current_step_type = 'Initial CI' # Start with SCF energy and other params scf_energy = core.get_variable("HF TOTAL ENERGY") eold = scf_energy norb_iter = 1 converged = False ah_step = False qc_step = False approx_integrals_only = True # Fake info to start with the inital diagonalization ediff = 1.e-4 orb_grad_rms = 1.e-3 # Grab needed objects diis_obj = solvers.DIIS(mcscf_diis_max_vecs) mcscf_obj = ciwfn.mcscf_object() # Execute the rotate command for rot in mcscf_rotate: if len(rot) != 4: raise p4util.PsiException("Each element of the MCSCF rotate command requires 4 arguements (irrep, orb1, orb2, theta).") irrep, orb1, orb2, theta = rot if irrep > ciwfn.Ca().nirrep(): raise p4util.PsiException("MCSCF_ROTATE: Expression %s irrep number is larger than the number of irreps" % (str(rot))) if max(orb1, orb2) > ciwfn.Ca().coldim()[irrep]: raise p4util.PsiException("MCSCF_ROTATE: Expression %s orbital number exceeds number of orbitals in irrep" % (str(rot))) theta = np.deg2rad(theta) x = ciwfn.Ca().nph[irrep][:, orb1].copy() y = ciwfn.Ca().nph[irrep][:, orb2].copy() xp = np.cos(theta) * x - np.sin(theta) * y yp = np.sin(theta) * x + np.cos(theta) * y ciwfn.Ca().nph[irrep][:, orb1] = xp ciwfn.Ca().nph[irrep][:, orb2] = yp # Limited RAS functionality if core.get_local_option("DETCI", "WFN") == "RASSCF" and mcscf_target_conv_type != "TS": core.print_out("\n Warning! Only the TS algorithm for RASSCF wavefunction is currently supported.\n") core.print_out(" Switching to the TS algorithm.\n\n") mcscf_target_conv_type = "TS" # Print out headers if mcscf_type == "CONV": mtype = " @MCSCF" core.print_out("\n ==> Starting MCSCF iterations <==\n\n") core.print_out(" Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n") elif mcscf_type == "DF": mtype = " @DF-MCSCF" core.print_out("\n ==> Starting DF-MCSCF iterations <==\n\n") core.print_out(" Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n") else: mtype = " @AO-MCSCF" core.print_out("\n ==> Starting AO-MCSCF iterations <==\n\n") core.print_out(" Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n") # Iterate ! for mcscf_iter in range(1, mcscf_max_macroiteration + 1): # Transform integrals, diagonalize H ciwfn.transform_mcscf_integrals(approx_integrals_only) nci_iter = ciwfn.diag_h(abs(ediff) * 1.e-2, orb_grad_rms * 1.e-3) # After the first diag we need to switch to READ ciwfn.set_ci_guess("DFILE") ciwfn.form_opdm() ciwfn.form_tpdm() ci_grad_rms = core.get_variable("DETCI AVG DVEC NORM") # Update MCSCF object Cocc = ciwfn.get_orbitals("DOCC") Cact = ciwfn.get_orbitals("ACT") Cvir = ciwfn.get_orbitals("VIR") opdm = ciwfn.get_opdm(-1, -1, "SUM", False) tpdm = ciwfn.get_tpdm("SUM", True) mcscf_obj.update(Cocc, Cact, Cvir, opdm, tpdm) current_energy = core.get_variable("MCSCF TOTAL ENERGY") orb_grad_rms = mcscf_obj.gradient_rms() ediff = current_energy - eold # Print iterations print_iteration(mtype, mcscf_iter, current_energy, ediff, orb_grad_rms, ci_grad_rms, nci_iter, norb_iter, mcscf_current_step_type) eold = current_energy if mcscf_current_step_type == 'Initial CI': mcscf_current_step_type = 'TS' # Check convergence if (orb_grad_rms < mcscf_orb_grad_conv) and (abs(ediff) < abs(mcscf_e_conv)) and\ (mcscf_iter > 3) and not qc_step: core.print_out("\n %s has converged!\n\n" % mtype); converged = True break # Which orbital convergence are we doing? if ah_step: converged, norb_iter, step = ah_iteration(mcscf_obj, print_micro=False) norb_iter += 1 if converged: mcscf_current_step_type = 'AH' else: core.print_out(" !Warning. Augmented Hessian did not converge. Taking an approx step.\n") step = mcscf_obj.approx_solve() mcscf_current_step_type = 'TS, AH failure' else: step = mcscf_obj.approx_solve() step_type = 'TS' maxstep = step.absmax() if maxstep > mcscf_steplimit: core.print_out(' Warning! Maxstep = %4.2f, scaling to %4.2f\n' % (maxstep, mcscf_steplimit)) step.scale(mcscf_steplimit / maxstep) xstep = total_step.clone() total_step.add(step) # Do or add DIIS if (mcscf_iter >= mcscf_diis_start) and ("TS" in mcscf_current_step_type): # Figure out DIIS error vector if mcscf_diis_error_type == "GRAD": error = core.Matrix.triplet(ciwfn.get_orbitals("OA"), mcscf_obj.gradient(), ciwfn.get_orbitals("AV"), False, False, True) else: error = step diis_obj.add(total_step, error) if not (mcscf_iter % mcscf_diis_freq): total_step = diis_obj.extrapolate() mcscf_current_step_type = 'TS, DIIS' # Build the rotation by continuous updates if mcscf_iter == 1: totalU = mcscf_obj.form_rotation_matrix(total_step) else: xstep.axpy(-1.0, total_step) xstep.scale(-1.0) Ustep = mcscf_obj.form_rotation_matrix(xstep) totalU = core.Matrix.doublet(totalU, Ustep, False, False) # Build the rotation directly (not recommended) # orbs_mat = mcscf_obj.Ck(start_orbs, total_step) # Finally rotate and set orbitals orbs_mat = core.Matrix.doublet(start_orbs, totalU, False, False) ciwfn.set_orbitals("ROT", orbs_mat) # Figure out what the next step should be if (orb_grad_rms < mcscf_so_start_grad) and (abs(ediff) < abs(mcscf_so_start_e)) and\ (mcscf_iter >= 2): if mcscf_target_conv_type == 'AH': approx_integrals_only = False ah_step = True elif mcscf_target_conv_type == 'OS': approx_integrals_only = False mcscf_current_step_type = 'OS, Prep' break else: continue #raise p4util.PsiException("") # If we converged do not do onestep if converged or (mcscf_target_conv_type != 'OS'): one_step_iters = [] # If we are not converged load in Dvec and build iters array else: one_step_iters = range(mcscf_iter + 1, mcscf_max_macroiteration + 1) dvec = ciwfn.D_vector() dvec.init_io_files(True) dvec.read(0, 0) dvec.symnormalize(1.0, 0) ci_grad = ciwfn.new_civector(1, mcscf_d_file + 1, True, True) ci_grad.set_nvec(1) ci_grad.init_io_files(True) # Loop for onestep for mcscf_iter in one_step_iters: # Transform integrals and update the MCSCF object ciwfn.transform_mcscf_integrals(ciwfn.H(), False) ciwfn.form_opdm() ciwfn.form_tpdm() # Update MCSCF object Cocc = ciwfn.get_orbitals("DOCC") Cact = ciwfn.get_orbitals("ACT") Cvir = ciwfn.get_orbitals("VIR") opdm = ciwfn.get_opdm(-1, -1, "SUM", False) tpdm = ciwfn.get_tpdm("SUM", True) mcscf_obj.update(Cocc, Cact, Cvir, opdm, tpdm) orb_grad_rms = mcscf_obj.gradient_rms() # Warning! Does not work for SA-MCSCF current_energy = mcscf_obj.current_total_energy() current_energy += mcscf_nuclear_energy core.set_variable("CI ROOT %d TOTAL ENERGY" % 1, current_energy) core.set_variable("CURRENT ENERGY", current_energy) docc_energy = mcscf_obj.current_docc_energy() ci_energy = mcscf_obj.current_ci_energy() # Compute CI gradient ciwfn.sigma(dvec, ci_grad, 0, 0) ci_grad.scale(2.0, 0) ci_grad.axpy(-2.0 * ci_energy, dvec, 0, 0) ci_grad_rms = ci_grad.norm(0) orb_grad_rms = mcscf_obj.gradient().rms() ediff = current_energy - eold print_iteration(mtype, mcscf_iter, current_energy, ediff, orb_grad_rms, ci_grad_rms, nci_iter, norb_iter, mcscf_current_step_type) mcscf_current_step_type = 'OS' eold = current_energy if (orb_grad_rms < mcscf_orb_grad_conv) and (abs(ediff) < abs(mcscf_e_conv)): core.print_out("\n %s has converged!\n\n" % mtype); converged = True break # Take a step converged, norb_iter, nci_iter, step = qc_iteration(dvec, ci_grad, ciwfn, mcscf_obj) # Rotate integrals to new frame total_step.add(step) orbs_mat = mcscf_obj.Ck(ciwfn.get_orbitals("ROT"), step) ciwfn.set_orbitals("ROT", orbs_mat) core.print_out(mtype + " Final Energy: %20.15f\n" % current_energy) # Die if we did not converge if (not converged): if core.get_global_option("DIE_IF_NOT_CONVERGED"): raise p4util.PsiException("MCSCF: Iterations did not converge!") else: core.print_out("\nWarning! MCSCF iterations did not converge!\n\n") # Print out CI vector information if mcscf_target_conv_type == 'OS': dvec.close_io_files() ci_grad.close_io_files() # For orbital invariant methods we transform the orbitals to the natural or # semicanonical basis. Frozen doubly occupied and virtual orbitals are not # modified. if core.get_option("DETCI", "WFN") == "CASSCF": # Do we diagonalize the opdm? if core.get_option("DETCI", "NAT_ORBS"): ciwfn.ci_nat_orbs() else: ciwfn.semicanonical_orbs() # Retransform intragrals and update CI coeffs., OPDM, and TPDM ciwfn.transform_mcscf_integrals(approx_integrals_only) nci_iter = ciwfn.diag_h(abs(ediff) * 1.e-2, orb_grad_rms * 1.e-3) ciwfn.set_ci_guess("DFILE") ciwfn.form_opdm() ciwfn.form_tpdm() proc_util.print_ci_results(ciwfn, "MCSCF", scf_energy, current_energy, print_opdm_no=True) # Set final energy core.set_variable("CURRENT ENERGY", core.get_variable("MCSCF TOTAL ENERGY")) # What do we need to cleanup? if core.get_option("DETCI", "MCSCF_CI_CLEANUP"): ciwfn.cleanup_ci() if core.get_option("DETCI", "MCSCF_DPD_CLEANUP"): ciwfn.cleanup_dpd() del diis_obj del mcscf_obj return ciwfn
def _set_convergence_criterion(ptype, method_name, scf_Ec, pscf_Ec, scf_Dc, pscf_Dc, gen_Ec, verbose=1): r""" This function will set local SCF and global energy convergence criterion to the defaults listed at: http://www.psicode.org/psi4manual/master/scf.html#convergence-and- algorithm-defaults. SCF will be converged more tightly if a post-SCF method is select (pscf_Ec, and pscf_Dc) else the looser (scf_Ec, and scf_Dc convergence criterion will be used). ptype - Procedure type (energy, gradient, etc). Nearly always test on procedures['energy'] since that's guaranteed to exist for a method. method_name - Name of the method scf_Ec - E convergence criterion for scf target method pscf_Ec - E convergence criterion for scf of post-scf target method scf_Dc - D convergence criterion for scf target method pscf_Dc - D convergence criterion for scf of post-scf target method gen_Ec - E convergence criterion for post-scf target method """ optstash = p4util.OptionsState( ['SCF', 'E_CONVERGENCE'], ['SCF', 'D_CONVERGENCE'], ['E_CONVERGENCE']) # Kind of want to move this out of here _method_exists(ptype, method_name) if verbose >= 2: print(' Setting convergence', end=' ') # Set method-dependent scf convergence criteria, check against energy routines if not core.has_option_changed('SCF', 'E_CONVERGENCE'): if procedures['energy'][method_name] == proc.run_scf: core.set_local_option('SCF', 'E_CONVERGENCE', scf_Ec) if verbose >= 2: print(scf_Ec, end=' ') else: core.set_local_option('SCF', 'E_CONVERGENCE', pscf_Ec) if verbose >= 2: print(pscf_Ec, end=' ') else: if verbose >= 2: print('CUSTOM', core.get_option('SCF', 'E_CONVERGENCE'), end=' ') if not core.has_option_changed('SCF', 'D_CONVERGENCE'): if procedures['energy'][method_name] == proc.run_scf: core.set_local_option('SCF', 'D_CONVERGENCE', scf_Dc) if verbose >= 2: print(scf_Dc, end=' ') else: core.set_local_option('SCF', 'D_CONVERGENCE', pscf_Dc) if verbose >= 2: print(pscf_Dc, end=' ') else: if verbose >= 2: print('CUSTOM', core.get_option('SCF', 'D_CONVERGENCE'), end=' ') # Set post-scf convergence criteria (global will cover all correlated modules) if not core.has_global_option_changed('E_CONVERGENCE'): if procedures['energy'][method_name] != proc.run_scf: core.set_global_option('E_CONVERGENCE', gen_Ec) if verbose >= 2: print(gen_Ec, end=' ') else: if procedures['energy'][method_name] != proc.run_scf: if verbose >= 2: print('CUSTOM', core.get_global_option('E_CONVERGENCE'), end=' ') if verbose >= 2: print('') return optstash
def scf_print_energies(self): enuc = self.get_energies('Nuclear') e1 = self.get_energies('One-Electron') e2 = self.get_energies('Two-Electron') exc = self.get_energies('XC') ed = self.get_energies('-D') self.del_variable('-D Energy') evv10 = self.get_energies('VV10') eefp = self.get_energies('EFP') epcm = self.get_energies('PCM Polarization') hf_energy = enuc + e1 + e2 dft_energy = hf_energy + exc + ed + evv10 total_energy = dft_energy + eefp + epcm core.print_out(" => Energetics <=\n\n") core.print_out( " Nuclear Repulsion Energy = {:24.16f}\n".format(enuc)) core.print_out( " One-Electron Energy = {:24.16f}\n".format(e1)) core.print_out( " Two-Electron Energy = {:24.16f}\n".format(e2)) if self.functional().needs_xc(): core.print_out( " DFT Exchange-Correlation Energy = {:24.16f}\n".format(exc)) core.print_out( " Empirical Dispersion Energy = {:24.16f}\n".format(ed)) core.print_out( " VV10 Nonlocal Energy = {:24.16f}\n".format(evv10)) if core.get_option('SCF', 'PCM'): core.print_out( " PCM Polarization Energy = {:24.16f}\n".format(epcm)) if hasattr(self.molecule(), 'EFP'): core.print_out( " EFP Energy = {:24.16f}\n".format(eefp)) core.print_out(" Total Energy = {:24.16f}\n".format( total_energy)) self.set_variable('NUCLEAR REPULSION ENERGY', enuc) self.set_variable('ONE-ELECTRON ENERGY', e1) self.set_variable('TWO-ELECTRON ENERGY', e2) if self.functional().needs_xc(): self.set_variable('DFT XC ENERGY', exc) self.set_variable('DFT VV10 ENERGY', evv10) self.set_variable('DFT FUNCTIONAL TOTAL ENERGY', hf_energy + exc + evv10) #self.set_variable(self.functional().name() + ' FUNCTIONAL TOTAL ENERGY', hf_energy + exc + evv10) self.set_variable('DFT TOTAL ENERGY', dft_energy) # overwritten later for DH else: self.set_variable('HF TOTAL ENERGY', hf_energy) if hasattr(self, "_disp_functor"): self.set_variable('DISPERSION CORRECTION ENERGY', ed) #if abs(ed) > 1.0e-14: # for pv, pvv in self.variables().items(): # if abs(pvv - ed) < 1.0e-14: # if pv.endswith('DISPERSION CORRECTION ENERGY') and pv.startswith(self.functional().name()): # fctl_plus_disp_name = pv.split()[0] # self.set_variable(fctl_plus_disp_name + ' TOTAL ENERGY', dft_energy) # overwritten later for DH #else: # self.set_variable(self.functional().name() + ' TOTAL ENERGY', dft_energy) # overwritten later for DH self.set_variable('SCF ITERATIONS', self.iteration_)
def fcidump(wfn, fname='INTDUMP', oe_ints=None): """Save integrals to file in FCIDUMP format as defined in Comp. Phys. Commun. 54 75 (1989) Additional one-electron integrals, including orbital energies, can also be saved. This latter format can be used with the HANDE QMC code but is not standard. :returns: None :raises: ValidationError when SCF wavefunction is not RHF :type wfn: :py:class:`~psi4.core.Wavefunction` :param wfn: set of molecule, basis, orbitals from which to generate cube files :param fname: name of the integrals file, defaults to INTDUMP :param oe_ints: list of additional one-electron integrals to save to file. So far only EIGENVALUES is a valid option. :examples: >>> # [1] Save one- and two-electron integrals to standard FCIDUMP format >>> E, wfn = energy('scf', return_wfn=True) >>> fcidump(wfn) >>> # [2] Save orbital energies, one- and two-electron integrals. >>> E, wfn = energy('scf', return_wfn=True) >>> fcidump(wfn, oe_ints=['EIGENVALUES']) """ # Get some options reference = core.get_option('SCF', 'REFERENCE') ints_tolerance = core.get_global_option('INTS_TOLERANCE') # Some sanity checks if reference not in ['RHF', 'UHF']: raise ValidationError('FCIDUMP not implemented for {} references\n'.format(reference)) if oe_ints is None: oe_ints = [] molecule = wfn.molecule() docc = wfn.doccpi() frzcpi = wfn.frzcpi() frzvpi = wfn.frzvpi() active_docc = docc - frzcpi active_socc = wfn.soccpi() active_mopi = wfn.nmopi() - frzcpi - frzvpi nbf = active_mopi.sum() if wfn.same_a_b_orbs() else 2 * active_mopi.sum() nirrep = wfn.nirrep() nelectron = 2 * active_docc.sum() + active_socc.sum() core.print_out('Writing integrals in FCIDUMP format to ' + fname + '\n') # Generate FCIDUMP header header = '&FCI\n' header += 'NORB={:d},\n'.format(nbf) header += 'NELEC={:d},\n'.format(nelectron) header += 'MS2={:d},\n'.format(wfn.nalpha() - wfn.nbeta()) header += 'UHF=.{}.,\n'.format(not wfn.same_a_b_orbs()).upper() orbsym = '' for h in range(active_mopi.n()): for n in range(frzcpi[h], frzcpi[h] + active_mopi[h]): orbsym += '{:d},'.format(h + 1) if not wfn.same_a_b_orbs(): orbsym += '{:d},'.format(h + 1) header += 'ORBSYM={}\n'.format(orbsym) header += '&END\n' with open(fname, 'w') as intdump: intdump.write(header) # Get an IntegralTransform object check_iwl_file_from_scf_type(core.get_global_option('SCF_TYPE'), wfn) spaces = [core.MOSpace.all()] trans_type = core.IntegralTransform.TransformationType.Restricted if not wfn.same_a_b_orbs(): trans_type = core.IntegralTransform.TransformationType.Unrestricted ints = core.IntegralTransform(wfn, spaces, trans_type) ints.transform_tei(core.MOSpace.all(), core.MOSpace.all(), core.MOSpace.all(), core.MOSpace.all()) core.print_out('Integral transformation complete!\n') DPD_info = {'instance_id': ints.get_dpd_id(), 'alpha_MO': ints.DPD_ID('[A>=A]+'), 'beta_MO': 0} if not wfn.same_a_b_orbs(): DPD_info['beta_MO'] = ints.DPD_ID("[a>=a]+") # Write TEI to fname in FCIDUMP format core.fcidump_tei_helper(nirrep, wfn.same_a_b_orbs(), DPD_info, ints_tolerance, fname) # Read-in OEI and write them to fname in FCIDUMP format # Indexing functions to translate from zero-based (C and Python) to # one-based (Fortran) mo_idx = lambda x: x + 1 alpha_mo_idx = lambda x: 2 * x + 1 beta_mo_idx = lambda x: 2 * (x + 1) with open(fname, 'a') as intdump: core.print_out('Writing frozen core operator in FCIDUMP format to ' + fname + '\n') if reference == 'RHF': PSIF_MO_FZC = 'MO-basis Frozen-Core Operator' moH = core.Matrix(PSIF_MO_FZC, wfn.nmopi(), wfn.nmopi()) moH.load(core.IO.shared_object(), psif.PSIF_OEI) mo_slice = core.Slice(frzcpi, active_mopi) MO_FZC = moH.get_block(mo_slice, mo_slice) offset = 0 for h, block in enumerate(MO_FZC.nph): il = np.tril_indices(block.shape[0]) for index, x in np.ndenumerate(block[il]): row = mo_idx(il[0][index] + offset) col = mo_idx(il[1][index] + offset) if (abs(x) > ints_tolerance): intdump.write('{:29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(x, row, col, 0, 0)) offset += block.shape[0] # Additional one-electron integrals as requested in oe_ints # Orbital energies core.print_out('Writing orbital energies in FCIDUMP format to ' + fname + '\n') if 'EIGENVALUES' in oe_ints: eigs_dump = write_eigenvalues(wfn.epsilon_a().get_block(mo_slice).to_array(), mo_idx) intdump.write(eigs_dump) else: PSIF_MO_A_FZC = 'MO-basis Alpha Frozen-Core Oper' moH_A = core.Matrix(PSIF_MO_A_FZC, wfn.nmopi(), wfn.nmopi()) moH_A.load(core.IO.shared_object(), psif.PSIF_OEI) mo_slice = core.Slice(frzcpi, active_mopi) MO_FZC_A = moH_A.get_block(mo_slice, mo_slice) offset = 0 for h, block in enumerate(MO_FZC_A.nph): il = np.tril_indices(block.shape[0]) for index, x in np.ndenumerate(block[il]): row = alpha_mo_idx(il[0][index] + offset) col = alpha_mo_idx(il[1][index] + offset) if (abs(x) > ints_tolerance): intdump.write('{:29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(x, row, col, 0, 0)) offset += block.shape[0] PSIF_MO_B_FZC = 'MO-basis Beta Frozen-Core Oper' moH_B = core.Matrix(PSIF_MO_B_FZC, wfn.nmopi(), wfn.nmopi()) moH_B.load(core.IO.shared_object(), psif.PSIF_OEI) mo_slice = core.Slice(frzcpi, active_mopi) MO_FZC_B = moH_B.get_block(mo_slice, mo_slice) offset = 0 for h, block in enumerate(MO_FZC_B.nph): il = np.tril_indices(block.shape[0]) for index, x in np.ndenumerate(block[il]): row = beta_mo_idx(il[0][index] + offset) col = beta_mo_idx(il[1][index] + offset) if (abs(x) > ints_tolerance): intdump.write('{:29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(x, row, col, 0, 0)) offset += block.shape[0] # Additional one-electron integrals as requested in oe_ints # Orbital energies core.print_out('Writing orbital energies in FCIDUMP format to ' + fname + '\n') if 'EIGENVALUES' in oe_ints: alpha_eigs_dump = write_eigenvalues(wfn.epsilon_a().get_block(mo_slice).to_array(), alpha_mo_idx) beta_eigs_dump = write_eigenvalues(wfn.epsilon_b().get_block(mo_slice).to_array(), beta_mo_idx) intdump.write(alpha_eigs_dump + beta_eigs_dump) # Dipole integrals #core.print_out('Writing dipole moment OEI in FCIDUMP format to ' + fname + '\n') # Traceless quadrupole integrals #core.print_out('Writing traceless quadrupole moment OEI in FCIDUMP format to ' + fname + '\n') # Frozen core + nuclear repulsion energy core.print_out('Writing frozen core + nuclear repulsion energy in FCIDUMP format to ' + fname + '\n') e_fzc = ints.get_frozen_core_energy() e_nuc = molecule.nuclear_repulsion_energy(wfn.get_dipole_field_strength()) intdump.write('{: 29.20E} {:4d} {:4d} {:4d} {:4d}\n'.format(e_fzc + e_nuc, 0, 0, 0, 0)) core.print_out('Done generating {} with integrals in FCIDUMP format.\n'.format(fname))
def mcscf_solver(ref_wfn): # Build CIWavefunction core.prepare_options_for_module("DETCI") ciwfn = core.CIWavefunction(ref_wfn) ciwfn.set_module("detci") # Hush a lot of CI output ciwfn.set_print(0) # Begin with a normal two-step step_type = 'Initial CI' total_step = core.Matrix("Total step", ciwfn.get_dimension('OA'), ciwfn.get_dimension('AV')) start_orbs = ciwfn.get_orbitals("ROT").clone() ciwfn.set_orbitals("ROT", start_orbs) # Grab da options mcscf_orb_grad_conv = core.get_option("DETCI", "MCSCF_R_CONVERGENCE") mcscf_e_conv = core.get_option("DETCI", "MCSCF_E_CONVERGENCE") mcscf_max_macroiteration = core.get_option("DETCI", "MCSCF_MAXITER") mcscf_type = core.get_option("DETCI", "MCSCF_TYPE") mcscf_d_file = core.get_option("DETCI", "CI_FILE_START") + 3 mcscf_nroots = core.get_option("DETCI", "NUM_ROOTS") mcscf_wavefunction_type = core.get_option("DETCI", "WFN") mcscf_ndet = ciwfn.ndet() mcscf_nuclear_energy = ciwfn.molecule().nuclear_repulsion_energy() mcscf_steplimit = core.get_option("DETCI", "MCSCF_MAX_ROT") mcscf_rotate = core.get_option("DETCI", "MCSCF_ROTATE") # DIIS info mcscf_diis_start = core.get_option("DETCI", "MCSCF_DIIS_START") mcscf_diis_freq = core.get_option("DETCI", "MCSCF_DIIS_FREQ") mcscf_diis_error_type = core.get_option("DETCI", "MCSCF_DIIS_ERROR_TYPE") mcscf_diis_max_vecs = core.get_option("DETCI", "MCSCF_DIIS_MAX_VECS") # One-step info mcscf_target_conv_type = core.get_option("DETCI", "MCSCF_ALGORITHM") mcscf_so_start_grad = core.get_option("DETCI", "MCSCF_SO_START_GRAD") mcscf_so_start_e = core.get_option("DETCI", "MCSCF_SO_START_E") mcscf_current_step_type = 'Initial CI' # Start with SCF energy and other params scf_energy = ciwfn.variable("HF TOTAL ENERGY") eold = scf_energy norb_iter = 1 converged = False ah_step = False qc_step = False approx_integrals_only = True # Fake info to start with the initial diagonalization ediff = 1.e-4 orb_grad_rms = 1.e-3 # Grab needed objects diis_obj = solvers.DIIS(mcscf_diis_max_vecs) mcscf_obj = ciwfn.mcscf_object() # Execute the rotate command for rot in mcscf_rotate: if len(rot) != 4: raise p4util.PsiException("Each element of the MCSCF rotate command requires 4 arguements (irrep, orb1, orb2, theta).") irrep, orb1, orb2, theta = rot if irrep > ciwfn.Ca().nirrep(): raise p4util.PsiException("MCSCF_ROTATE: Expression %s irrep number is larger than the number of irreps" % (str(rot))) if max(orb1, orb2) > ciwfn.Ca().coldim()[irrep]: raise p4util.PsiException("MCSCF_ROTATE: Expression %s orbital number exceeds number of orbitals in irrep" % (str(rot))) theta = np.deg2rad(theta) x = ciwfn.Ca().nph[irrep][:, orb1].copy() y = ciwfn.Ca().nph[irrep][:, orb2].copy() xp = np.cos(theta) * x - np.sin(theta) * y yp = np.sin(theta) * x + np.cos(theta) * y ciwfn.Ca().nph[irrep][:, orb1] = xp ciwfn.Ca().nph[irrep][:, orb2] = yp # Limited RAS functionality if core.get_local_option("DETCI", "WFN") == "RASSCF" and mcscf_target_conv_type != "TS": core.print_out("\n Warning! Only the TS algorithm for RASSCF wavefunction is currently supported.\n") core.print_out(" Switching to the TS algorithm.\n\n") mcscf_target_conv_type = "TS" # Print out headers if mcscf_type == "CONV": mtype = " @MCSCF" core.print_out("\n ==> Starting MCSCF iterations <==\n\n") core.print_out(" Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n") elif mcscf_type == "DF": mtype = " @DF-MCSCF" core.print_out("\n ==> Starting DF-MCSCF iterations <==\n\n") core.print_out(" Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n") else: mtype = " @AO-MCSCF" core.print_out("\n ==> Starting AO-MCSCF iterations <==\n\n") core.print_out(" Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n") # Iterate ! for mcscf_iter in range(1, mcscf_max_macroiteration + 1): # Transform integrals, diagonalize H ciwfn.transform_mcscf_integrals(approx_integrals_only) nci_iter = ciwfn.diag_h(abs(ediff) * 1.e-2, orb_grad_rms * 1.e-3) # After the first diag we need to switch to READ ciwfn.set_ci_guess("DFILE") ciwfn.form_opdm() ciwfn.form_tpdm() ci_grad_rms = ciwfn.variable("DETCI AVG DVEC NORM") # Update MCSCF object Cocc = ciwfn.get_orbitals("DOCC") Cact = ciwfn.get_orbitals("ACT") Cvir = ciwfn.get_orbitals("VIR") opdm = ciwfn.get_opdm(-1, -1, "SUM", False) tpdm = ciwfn.get_tpdm("SUM", True) mcscf_obj.update(Cocc, Cact, Cvir, opdm, tpdm) current_energy = ciwfn.variable("MCSCF TOTAL ENERGY") orb_grad_rms = mcscf_obj.gradient_rms() ediff = current_energy - eold # Print iterations print_iteration(mtype, mcscf_iter, current_energy, ediff, orb_grad_rms, ci_grad_rms, nci_iter, norb_iter, mcscf_current_step_type) eold = current_energy if mcscf_current_step_type == 'Initial CI': mcscf_current_step_type = 'TS' # Check convergence if (orb_grad_rms < mcscf_orb_grad_conv) and (abs(ediff) < abs(mcscf_e_conv)) and\ (mcscf_iter > 3) and not qc_step: core.print_out("\n %s has converged!\n\n" % mtype); converged = True break # Which orbital convergence are we doing? if ah_step: converged, norb_iter, step = ah_iteration(mcscf_obj, print_micro=False) norb_iter += 1 if converged: mcscf_current_step_type = 'AH' else: core.print_out(" !Warning. Augmented Hessian did not converge. Taking an approx step.\n") step = mcscf_obj.approx_solve() mcscf_current_step_type = 'TS, AH failure' else: step = mcscf_obj.approx_solve() step_type = 'TS' maxstep = step.absmax() if maxstep > mcscf_steplimit: core.print_out(' Warning! Maxstep = %4.2f, scaling to %4.2f\n' % (maxstep, mcscf_steplimit)) step.scale(mcscf_steplimit / maxstep) xstep = total_step.clone() total_step.add(step) # Do or add DIIS if (mcscf_iter >= mcscf_diis_start) and ("TS" in mcscf_current_step_type): # Figure out DIIS error vector if mcscf_diis_error_type == "GRAD": error = core.triplet(ciwfn.get_orbitals("OA"), mcscf_obj.gradient(), ciwfn.get_orbitals("AV"), False, False, True) else: error = step diis_obj.add(total_step, error) if not (mcscf_iter % mcscf_diis_freq): total_step = diis_obj.extrapolate() mcscf_current_step_type = 'TS, DIIS' # Build the rotation by continuous updates if mcscf_iter == 1: totalU = mcscf_obj.form_rotation_matrix(total_step) else: xstep.axpy(-1.0, total_step) xstep.scale(-1.0) Ustep = mcscf_obj.form_rotation_matrix(xstep) totalU = core.doublet(totalU, Ustep, False, False) # Build the rotation directly (not recommended) # orbs_mat = mcscf_obj.Ck(start_orbs, total_step) # Finally rotate and set orbitals orbs_mat = core.doublet(start_orbs, totalU, False, False) ciwfn.set_orbitals("ROT", orbs_mat) # Figure out what the next step should be if (orb_grad_rms < mcscf_so_start_grad) and (abs(ediff) < abs(mcscf_so_start_e)) and\ (mcscf_iter >= 2): if mcscf_target_conv_type == 'AH': approx_integrals_only = False ah_step = True elif mcscf_target_conv_type == 'OS': approx_integrals_only = False mcscf_current_step_type = 'OS, Prep' break else: continue #raise p4util.PsiException("") # If we converged do not do onestep if converged or (mcscf_target_conv_type != 'OS'): one_step_iters = [] # If we are not converged load in Dvec and build iters array else: one_step_iters = range(mcscf_iter + 1, mcscf_max_macroiteration + 1) dvec = ciwfn.D_vector() dvec.init_io_files(True) dvec.read(0, 0) dvec.symnormalize(1.0, 0) ci_grad = ciwfn.new_civector(1, mcscf_d_file + 1, True, True) ci_grad.set_nvec(1) ci_grad.init_io_files(True) # Loop for onestep for mcscf_iter in one_step_iters: # Transform integrals and update the MCSCF object ciwfn.transform_mcscf_integrals(ciwfn.H(), False) ciwfn.form_opdm() ciwfn.form_tpdm() # Update MCSCF object Cocc = ciwfn.get_orbitals("DOCC") Cact = ciwfn.get_orbitals("ACT") Cvir = ciwfn.get_orbitals("VIR") opdm = ciwfn.get_opdm(-1, -1, "SUM", False) tpdm = ciwfn.get_tpdm("SUM", True) mcscf_obj.update(Cocc, Cact, Cvir, opdm, tpdm) orb_grad_rms = mcscf_obj.gradient_rms() # Warning! Does not work for SA-MCSCF current_energy = mcscf_obj.current_total_energy() current_energy += mcscf_nuclear_energy ciwfn.set_variable("CI ROOT %d TOTAL ENERGY" % 1, current_energy) ciwfn.set_variable("CURRENT ENERGY", current_energy) ciwfn.set_energy(current_energy) docc_energy = mcscf_obj.current_docc_energy() ci_energy = mcscf_obj.current_ci_energy() # Compute CI gradient ciwfn.sigma(dvec, ci_grad, 0, 0) ci_grad.scale(2.0, 0) ci_grad.axpy(-2.0 * ci_energy, dvec, 0, 0) ci_grad_rms = ci_grad.norm(0) orb_grad_rms = mcscf_obj.gradient().rms() ediff = current_energy - eold print_iteration(mtype, mcscf_iter, current_energy, ediff, orb_grad_rms, ci_grad_rms, nci_iter, norb_iter, mcscf_current_step_type) mcscf_current_step_type = 'OS' eold = current_energy if (orb_grad_rms < mcscf_orb_grad_conv) and (abs(ediff) < abs(mcscf_e_conv)): core.print_out("\n %s has converged!\n\n" % mtype); converged = True break # Take a step converged, norb_iter, nci_iter, step = qc_iteration(dvec, ci_grad, ciwfn, mcscf_obj) # Rotate integrals to new frame total_step.add(step) orbs_mat = mcscf_obj.Ck(ciwfn.get_orbitals("ROT"), step) ciwfn.set_orbitals("ROT", orbs_mat) core.print_out(mtype + " Final Energy: %20.15f\n" % current_energy) # Die if we did not converge if (not converged): if core.get_global_option("DIE_IF_NOT_CONVERGED"): raise p4util.PsiException("MCSCF: Iterations did not converge!") else: core.print_out("\nWarning! MCSCF iterations did not converge!\n\n") # Print out CI vector information if mcscf_target_conv_type == 'OS': dvec.close_io_files() ci_grad.close_io_files() # For orbital invariant methods we transform the orbitals to the natural or # semicanonical basis. Frozen doubly occupied and virtual orbitals are not # modified. if core.get_option("DETCI", "WFN") == "CASSCF": # Do we diagonalize the opdm? if core.get_option("DETCI", "NAT_ORBS"): ciwfn.ci_nat_orbs() else: ciwfn.semicanonical_orbs() # Retransform intragrals and update CI coeffs., OPDM, and TPDM ciwfn.transform_mcscf_integrals(approx_integrals_only) nci_iter = ciwfn.diag_h(abs(ediff) * 1.e-2, orb_grad_rms * 1.e-3) ciwfn.set_ci_guess("DFILE") ciwfn.form_opdm() ciwfn.form_tpdm() proc_util.print_ci_results(ciwfn, "MCSCF", scf_energy, current_energy, print_opdm_no=True) # Set final energy ciwfn.set_variable("CURRENT ENERGY", ciwfn.variable("MCSCF TOTAL ENERGY")) ciwfn.set_energy(ciwfn.variable("MCSCF TOTAL ENERGY")) # What do we need to cleanup? if core.get_option("DETCI", "MCSCF_CI_CLEANUP"): ciwfn.cleanup_ci() if core.get_option("DETCI", "MCSCF_DPD_CLEANUP"): ciwfn.cleanup_dpd() del diis_obj del mcscf_obj return ciwfn
def df_fdds_dispersion(primary, auxiliary, cache, leg_points=10, leg_lambda=0.3, do_print=True): rho_thresh = core.get_option("SAPT", "SAPT_FDDS_V2_RHO_CUTOFF") if do_print: core.print_out("\n ==> E20 Dispersion (CHF FDDS) <== \n\n") core.print_out(" Legendre Points: % 10d\n" % leg_points) core.print_out(" Lambda Shift: % 10.3f\n" % leg_lambda) core.print_out(" Fxc Kernal: % 10s\n" % "ALDA") core.print_out(" (P|Fxc|Q) Thresh: % 8.3e\n" % rho_thresh) # Build object df_matrix_keys = ["Cocc_A", "Cvir_A", "Cocc_B", "Cvir_B"] fdds_matrix_cache = {key: cache[key] for key in df_matrix_keys} df_vector_keys = ["eps_occ_A", "eps_vir_A", "eps_occ_B", "eps_vir_B"] fdds_vector_cache = {key: cache[key] for key in df_vector_keys} fdds_obj = core.FDDS_Dispersion(primary, auxiliary, fdds_matrix_cache, fdds_vector_cache) # Aux Densities D = fdds_obj.project_densities([cache["D_A"], cache["D_B"]]) # Temps half_Saux = fdds_obj.aux_overlap().clone() half_Saux.power(-0.5, 1.e-12) halfp_Saux = fdds_obj.aux_overlap().clone() halfp_Saux.power(0.5, 1.e-12) # Builds potentials W_A = fdds_obj.metric().clone() W_A.axpy(1.0, _compute_fxc(D[0], half_Saux, halfp_Saux, rho_thresh=rho_thresh)) W_B = fdds_obj.metric().clone() W_B.axpy(1.0, _compute_fxc(D[1], half_Saux, halfp_Saux, rho_thresh=rho_thresh)) # Nuke the densities del D metric = fdds_obj.metric() metric_inv = fdds_obj.metric_inv() # Integrate core.print_out("\n => Time Integration <= \n\n") val_pack = ("Omega", "Weight", "Disp20,u", "Disp20", "time [s]") core.print_out("% 12s % 12s % 14s % 14s % 10s\n" % val_pack) # print("% 12s % 12s % 14s % 14s % 10s" % val_pack) start_time = time.time() total_uc = 0 total_c = 0 for point, weight in zip(*np.polynomial.legendre.leggauss(leg_points)): omega = leg_lambda * (1.0 - point) / (1.0 + point) lambda_scale = ((2.0 * leg_lambda) / (point + 1.0)**2) # Monomer A X_A = fdds_obj.form_unc_amplitude("A", omega) # Coupled A X_A_coupled = X_A.clone() XSW_A = core.triplet(X_A, metric_inv, W_A, False, False, False) amplitude_inv = metric.clone() amplitude_inv.axpy(1.0, XSW_A) nremoved = 0 amplitude = amplitude_inv.pseudoinverse(1.e-13, nremoved) amplitude.transpose_this() # Why is this coming out transposed? X_A_coupled.axpy(-1.0, core.triplet(XSW_A, amplitude, X_A, False, False, False)) del XSW_A, amplitude X_B = fdds_obj.form_unc_amplitude("B", omega) # print(np.linalg.norm(X_B)) # Coupled B X_B_coupled = X_B.clone() XSW_B = core.triplet(X_B, metric_inv, W_B, False, False, False) amplitude_inv = metric.clone() amplitude_inv.axpy(1.0, XSW_B) amplitude = amplitude_inv.pseudoinverse(1.e-13, nremoved) amplitude.transpose_this() # Why is this coming out transposed? X_B_coupled.axpy(-1.0, core.triplet(XSW_B, amplitude, X_B, False, False, False)) del XSW_B, amplitude # Make sure the results are symmetrized for tensor in [X_A, X_B, X_A_coupled, X_B_coupled]: tensor.add(tensor.transpose()) tensor.scale(0.5) # Combine tmp_uc = core.triplet(metric_inv, X_A, metric_inv, False, False, False) value_uc = tmp_uc.vector_dot(X_B) del tmp_uc tmp_c = core.triplet(metric_inv, X_A_coupled, metric_inv, False, False, False) value_c = tmp_c.vector_dot(X_B_coupled) del tmp_c # Tally total_uc += value_uc * weight * lambda_scale total_c += value_c * weight * lambda_scale if do_print: tmp_disp_unc = value_uc * weight * lambda_scale tmp_disp = value_c * weight * lambda_scale fdds_time = time.time() - start_time val_pack = (omega, weight, tmp_disp_unc, tmp_disp, fdds_time) core.print_out("% 12.3e % 12.3e % 14.3e % 14.3e %10d\n" % val_pack) # print("% 12.3e % 12.3e % 14.3e % 14.3e %10d" % val_pack) Disp20_uc = -1.0 / (2.0 * np.pi) * total_uc Disp20_c = -1.0 / (2.0 * np.pi) * total_c core.print_out("\n") core.print_out(print_sapt_var("Disp20,u", Disp20_uc, short=True) + "\n") core.print_out(print_sapt_var("Disp20", Disp20_c, short=True) + "\n") return {"Disp20,FDDS (unc)": Disp20_uc, "Disp20": Disp20_c}
def _core_jk_build(orbital_basis: core.BasisSet, aux: core.BasisSet = None, jk_type: str = None, do_wK: bool = None, memory: int = None) -> core.JK: """ Constructs a Psi4 JK object from an input basis. Parameters ---------- orbital_basis Orbital basis to use in the JK object. aux Optional auxiliary basis set for density-fitted tensors. Defaults to the DF_BASIS_SCF if set, otherwise the correspond JKFIT basis to the passed in `orbital_basis`. jk_type Type of JK object to build (DF, Direct, PK, etc). Defaults to the current global SCF_TYPE option. Returns ------- JK Uninitialized JK object. Example ------- jk = psi4.core.JK.build(bas) jk.set_memory(int(5e8)) # 4GB of memory jk.initialize() ... jk.C_left_add(matirx) jk.compute() jk.C_clear() ... """ optstash = optproc.OptionsState(["SCF_TYPE"]) if jk_type is not None: core.set_global_option("SCF_TYPE", jk_type) if aux is None: if core.get_global_option("SCF_TYPE") == "DF": aux = core.BasisSet.build(orbital_basis.molecule(), "DF_BASIS_SCF", core.get_option("SCF", "DF_BASIS_SCF"), "JKFIT", orbital_basis.name(), orbital_basis.has_puream()) else: aux = core.BasisSet.zero_ao_basis_set() if (do_wK is None) or (memory is None): jk = core.JK.build_JK(orbital_basis, aux) else: jk = core.JK.build_JK(orbital_basis, aux, bool(do_wK), int(memory)) optstash.restore() return jk
def print_ci_results(ciwfn, rname, scf_e, ci_e, print_opdm_no=False): """ Printing for all CI Wavefunctions """ # Print out energetics core.print_out("\n ==> Energetics <==\n\n") core.print_out(" SCF energy = %20.15f\n" % scf_e) if "CI" in rname: core.print_out(" Total CI energy = %20.15f\n" % ci_e) elif "MP" in rname: core.print_out(" Total MP energy = %20.15f\n" % ci_e) elif "ZAPT" in rname: core.print_out(" Total ZAPT energy = %20.15f\n" % ci_e) else: core.print_out(" Total MCSCF energy = %20.15f\n" % ci_e) # Nothing to be done for ZAPT or MP if ("MP" in rname) or ("ZAPT" in rname): core.print_out("\n") return # Initial info ci_nroots = core.get_option("DETCI", "NUM_ROOTS") irrep_labels = ciwfn.molecule().irrep_labels() # Grab the D-vector dvec = ciwfn.D_vector() dvec.init_io_files(True) for root in range(ci_nroots): core.print_out("\n ==> %s root %d information <==\n\n" % (rname, root)) # Print total energy root_e = core.variable("CI ROOT %d TOTAL ENERGY" % (root)) core.print_out(" %s Root %d energy = %20.15f\n" % (rname, root, root_e)) # Print natural occupations if print_opdm_no: core.print_out("\n Active Space Natural occupation numbers:\n\n") occs_list = [] r_opdm = ciwfn.get_opdm(root, root, "SUM", False) for h in range(len(r_opdm.nph)): if 0 in r_opdm.nph[h].shape: continue nocc, rot = np.linalg.eigh(r_opdm.nph[h]) for e in nocc: occs_list.append((e, irrep_labels[h])) occs_list.sort(key=lambda x: -x[0]) cnt = 0 for value, label in occs_list: value, label = occs_list[cnt] core.print_out(" %4s % 8.6f" % (label, value)) cnt += 1 if (cnt % 3) == 0: core.print_out("\n") if (cnt % 3): core.print_out("\n") # Print CIVector information ciwfn.print_vector(dvec, root) # True to keep the file dvec.close_io_files(True)
def run_sapt_dft(name, **kwargs): optstash = p4util.OptionsState(['SCF', 'SCF_TYPE'], ['SCF', 'REFERENCE'], ['SCF', 'DFT_FUNCTIONAL'], ['SCF', 'DFT_GRAC_SHIFT'], ['SCF', 'SAVE_JK']) core.tstart() # Alter default algorithm if not core.has_option_changed('SCF', 'SCF_TYPE'): core.set_local_option('SCF', 'SCF_TYPE', 'DF') core.prepare_options_for_module("SAPT") # Get the molecule of interest ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: sapt_dimer = kwargs.pop('molecule', core.get_active_molecule()) else: core.print_out( 'Warning! SAPT argument "ref_wfn" is only able to use molecule information.' ) sapt_dimer = ref_wfn.molecule() # Shifting to C1 so we need to copy the active molecule if sapt_dimer.schoenflies_symbol() != 'c1': core.print_out( ' SAPT does not make use of molecular symmetry, further calculations in C1 point group.\n' ) # Make sure the geometry doesnt shift or rotate sapt_dimer = sapt_dimer.clone() sapt_dimer.reset_point_group('c1') sapt_dimer.fix_orientation(True) sapt_dimer.fix_com(True) sapt_dimer.update_geometry() # Grab overall settings mon_a_shift = core.get_option("SAPT", "SAPT_DFT_GRAC_SHIFT_A") mon_b_shift = core.get_option("SAPT", "SAPT_DFT_GRAC_SHIFT_B") do_delta_hf = core.get_option("SAPT", "SAPT_DFT_DO_DHF") sapt_dft_functional = core.get_option("SAPT", "SAPT_DFT_FUNCTIONAL") # Print out the title and some information core.print_out("\n") core.print_out( " ---------------------------------------------------------\n") core.print_out(" " + "SAPT(DFT) Procedure".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith".center(58) + "\n") core.print_out( " ---------------------------------------------------------\n") core.print_out("\n") core.print_out(" ==> Algorithm <==\n\n") core.print_out(" SAPT DFT Functional %12s\n" % str(sapt_dft_functional)) core.print_out(" Monomer A GRAC Shift %12.6f\n" % mon_a_shift) core.print_out(" Monomer B GRAC Shift %12.6f\n" % mon_b_shift) core.print_out(" Delta HF %12s\n" % ("True" if do_delta_hf else "False")) core.print_out(" JK Algorithm %12s\n" % core.get_option("SCF", "SCF_TYPE")) core.print_out("\n") core.print_out(" Required computations:\n") if (do_delta_hf): core.print_out(" HF (Dimer)\n") core.print_out(" HF (Monomer A)\n") core.print_out(" HF (Monomer B)\n") core.print_out(" DFT (Monomer A)\n") core.print_out(" DFT (Monomer B)\n") core.print_out("\n") if (mon_a_shift == 0.0) or (mon_b_shift == 0.0): raise ValidationError( 'SAPT(DFT): must set both "SAPT_DFT_GRAC_SHIFT_A" and "B".') if (core.get_option('SCF', 'REFERENCE') != 'RHF'): raise ValidationError( 'SAPT(DFT) currently only supports restricted references.') nfrag = sapt_dimer.nfragments() if nfrag != 2: raise ValidationError( 'SAPT requires active molecule to have 2 fragments, not %s.' % (nfrag)) monomerA = sapt_dimer.extract_subsets(1, 2) monomerA.set_name('monomerA') monomerB = sapt_dimer.extract_subsets(2, 1) monomerB.set_name('monomerB') core.IO.set_default_namespace('dimer') data = {} core.set_global_option("SAVE_JK", True) if (core.get_option('SCF', 'SCF_TYPE') == 'DF'): # core.set_global_option('DF_INTS_IO', 'LOAD') core.set_global_option('DF_INTS_IO', 'SAVE') # # Compute dimer wavefunction hf_cache = {} hf_wfn_dimer = None if do_delta_hf: if (core.get_option('SCF', 'SCF_TYPE') == 'DF'): core.set_global_option('DF_INTS_IO', 'SAVE') hf_data = {} hf_wfn_dimer = scf_helper("SCF", molecule=sapt_dimer, banner="SAPT(DFT): delta HF Dimer", **kwargs) hf_data["HF DIMER"] = core.get_variable("CURRENT ENERGY") if (core.get_option('SCF', 'SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'dimer', 'monomerA') hf_wfn_A = scf_helper("SCF", molecule=monomerA, banner="SAPT(DFT): delta HF Monomer A", **kwargs) hf_data["HF MONOMER A"] = core.get_variable("CURRENT ENERGY") if (core.get_option('SCF', 'SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'monomerA', 'monomerB') hf_wfn_B = scf_helper("SCF", molecule=monomerB, banner="SAPT(DFT): delta HF Monomer B", **kwargs) hf_data["HF MONOMER B"] = core.get_variable("CURRENT ENERGY") # Move it back to monomer A if (core.get_option('SCF', 'SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'monomerB', 'dimer') core.print_out("\n") core.print_out( " ---------------------------------------------------------\n" ) core.print_out(" " + "SAPT(DFT): delta HF Segement".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith and Rob Parrish".center(58) + "\n") core.print_out( " ---------------------------------------------------------\n" ) core.print_out("\n") # Build cache and JK sapt_jk = hf_wfn_B.jk() hf_cache = sapt_jk_terms.build_sapt_jk_cache(hf_wfn_A, hf_wfn_B, sapt_jk, True) # Electostatics elst = sapt_jk_terms.electrostatics(hf_cache, True) hf_data.update(elst) # Exchange exch = sapt_jk_terms.exchange(hf_cache, sapt_jk, True) hf_data.update(exch) # Induction ind = sapt_jk_terms.induction( hf_cache, sapt_jk, True, maxiter=core.get_option("SAPT", "MAXITER"), conv=core.get_option("SAPT", "D_CONVERGENCE")) hf_data.update(ind) dhf_value = hf_data["HF DIMER"] - hf_data["HF MONOMER A"] - hf_data[ "HF MONOMER B"] core.print_out("\n") core.print_out( print_sapt_hf_summary(hf_data, "SAPT(HF)", delta_hf=dhf_value)) data["Delta HF Correction"] = core.get_variable("SAPT(DFT) Delta HF") if hf_wfn_dimer is None: dimer_wfn = core.Wavefunction.build(sapt_dimer, core.get_global_option("BASIS")) else: dimer_wfn = hf_wfn_dimer # Set the primary functional core.set_global_option("DFT_FUNCTIONAL", core.get_option("SAPT", "SAPT_DFT_FUNCTIONAL")) core.set_local_option('SCF', 'REFERENCE', 'RKS') # Compute Monomer A wavefunction if (core.get_option('SCF', 'SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'dimer', 'monomerA') if mon_a_shift: core.set_global_option("DFT_GRAC_SHIFT", mon_a_shift) # Save the JK object core.IO.set_default_namespace('monomerA') wfn_A = scf_helper("SCF", molecule=monomerA, banner="SAPT(DFT): DFT Monomer A", **kwargs) data["DFT MONOMERA"] = core.get_variable("CURRENT ENERGY") core.set_global_option("DFT_GRAC_SHIFT", 0.0) # Compute Monomer B wavefunction if (core.get_option('SCF', 'SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'monomerA', 'monomerB') if mon_b_shift: core.set_global_option("DFT_GRAC_SHIFT", mon_b_shift) core.IO.set_default_namespace('monomerB') wfn_B = scf_helper("SCF", molecule=monomerB, banner="SAPT(DFT): DFT Monomer B", **kwargs) data["DFT MONOMERB"] = core.get_variable("CURRENT ENERGY") core.set_global_option("DFT_GRAC_SHIFT", 0.0) # Print out the title and some information core.print_out("\n") core.print_out( " ---------------------------------------------------------\n") core.print_out(" " + "SAPT(DFT): Intermolecular Interaction Segment".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith and Rob Parrish".center(58) + "\n") core.print_out( " ---------------------------------------------------------\n") core.print_out("\n") core.print_out(" ==> Algorithm <==\n\n") core.print_out(" SAPT DFT Functional %12s\n" % str(sapt_dft_functional)) core.print_out(" Monomer A GRAC Shift %12.6f\n" % mon_a_shift) core.print_out(" Monomer B GRAC Shift %12.6f\n" % mon_b_shift) core.print_out(" Delta HF %12s\n" % ("True" if do_delta_hf else "False")) core.print_out(" JK Algorithm %12s\n" % core.get_option("SCF", "SCF_TYPE")) # Build cache and JK sapt_jk = wfn_B.jk() cache = sapt_jk_terms.build_sapt_jk_cache(wfn_A, wfn_B, sapt_jk, True) # Electostatics elst = sapt_jk_terms.electrostatics(cache, True) data.update(elst) # Exchange exch = sapt_jk_terms.exchange(cache, sapt_jk, True) data.update(exch) # Induction ind = sapt_jk_terms.induction(cache, sapt_jk, True, maxiter=core.get_option("SAPT", "MAXITER"), conv=core.get_option("SAPT", "D_CONVERGENCE")) data.update(ind) # Dispersion primary_basis = wfn_A.basisset() core.print_out("\n") aux_basis = core.BasisSet.build(sapt_dimer, "DF_BASIS_MP2", core.get_option("DFMP2", "DF_BASIS_MP2"), "RIFIT", core.get_global_option('BASIS')) fdds_disp = sapt_mp2_terms.df_fdds_dispersion(primary_basis, aux_basis, cache) data.update(fdds_disp) if core.get_option("SAPT", "SAPT_DFT_MP2_DISP_ALG") == "FISAPT": mp2_disp = sapt_mp2_terms.df_mp2_fisapt_dispersion(wfn_A, primary_basis, aux_basis, cache, do_print=True) else: mp2_disp = sapt_mp2_terms.df_mp2_sapt_dispersion(dimer_wfn, wfn_A, wfn_B, primary_basis, aux_basis, cache, do_print=True) data.update(mp2_disp) # Print out final data core.print_out("\n") core.print_out(print_sapt_dft_summary(data, "SAPT(DFT)")) core.tstop() return dimer_wfn
def run_sapt_dft(name, **kwargs): optstash = p4util.OptionsState(['SCF_TYPE'], ['SCF', 'REFERENCE'], ['SCF', 'DFT_GRAC_SHIFT'], ['SCF', 'SAVE_JK']) core.tstart() # Alter default algorithm if not core.has_global_option_changed('SCF_TYPE'): core.set_global_option('SCF_TYPE', 'DF') core.prepare_options_for_module("SAPT") # Get the molecule of interest ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: sapt_dimer = kwargs.pop('molecule', core.get_active_molecule()) else: core.print_out( 'Warning! SAPT argument "ref_wfn" is only able to use molecule information.' ) sapt_dimer = ref_wfn.molecule() sapt_dimer, monomerA, monomerB = proc_util.prepare_sapt_molecule( sapt_dimer, "dimer") # Grab overall settings mon_a_shift = core.get_option("SAPT", "SAPT_DFT_GRAC_SHIFT_A") mon_b_shift = core.get_option("SAPT", "SAPT_DFT_GRAC_SHIFT_B") do_delta_hf = core.get_option("SAPT", "SAPT_DFT_DO_DHF") sapt_dft_functional = core.get_option("SAPT", "SAPT_DFT_FUNCTIONAL") # Print out the title and some information core.print_out("\n") core.print_out( " ---------------------------------------------------------\n") core.print_out(" " + "SAPT(DFT) Procedure".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith".center(58) + "\n") core.print_out( " ---------------------------------------------------------\n") core.print_out("\n") core.print_out( " !!! WARNING: SAPT(DFT) capability is in beta. Please use with caution. !!!\n\n" ) core.print_out(" ==> Algorithm <==\n\n") core.print_out(" SAPT DFT Functional %12s\n" % str(sapt_dft_functional)) core.print_out(" Monomer A GRAC Shift %12.6f\n" % mon_a_shift) core.print_out(" Monomer B GRAC Shift %12.6f\n" % mon_b_shift) core.print_out(" Delta HF %12s\n" % ("True" if do_delta_hf else "False")) core.print_out(" JK Algorithm %12s\n" % core.get_global_option("SCF_TYPE")) core.print_out("\n") core.print_out(" Required computations:\n") if (do_delta_hf): core.print_out(" HF (Dimer)\n") core.print_out(" HF (Monomer A)\n") core.print_out(" HF (Monomer B)\n") core.print_out(" DFT (Monomer A)\n") core.print_out(" DFT (Monomer B)\n") core.print_out("\n") if (sapt_dft_functional != "HF") and ((mon_a_shift == 0.0) or (mon_b_shift == 0.0)): raise ValidationError( 'SAPT(DFT): must set both "SAPT_DFT_GRAC_SHIFT_A" and "B".') if (core.get_option('SCF', 'REFERENCE') != 'RHF'): raise ValidationError( 'SAPT(DFT) currently only supports restricted references.') core.IO.set_default_namespace('dimer') data = {} if (core.get_global_option('SCF_TYPE') == 'DF'): # core.set_global_option('DF_INTS_IO', 'LOAD') core.set_global_option('DF_INTS_IO', 'SAVE') # # Compute dimer wavefunction hf_wfn_dimer = None if do_delta_hf: if (core.get_global_option('SCF_TYPE') == 'DF'): core.set_global_option('DF_INTS_IO', 'SAVE') core.timer_on("SAPT(DFT): Dimer SCF") hf_data = {} hf_wfn_dimer = scf_helper("SCF", molecule=sapt_dimer, banner="SAPT(DFT): delta HF Dimer", **kwargs) hf_data["HF DIMER"] = core.get_variable("CURRENT ENERGY") core.timer_off("SAPT(DFT): Dimer SCF") core.timer_on("SAPT(DFT): Monomer A SCF") if (core.get_global_option('SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'dimer', 'monomerA') hf_wfn_A = scf_helper("SCF", molecule=monomerA, banner="SAPT(DFT): delta HF Monomer A", **kwargs) hf_data["HF MONOMER A"] = core.get_variable("CURRENT ENERGY") core.timer_off("SAPT(DFT): Monomer A SCF") core.timer_on("SAPT(DFT): Monomer B SCF") core.set_global_option("SAVE_JK", True) if (core.get_global_option('SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'monomerA', 'monomerB') hf_wfn_B = scf_helper("SCF", molecule=monomerB, banner="SAPT(DFT): delta HF Monomer B", **kwargs) hf_data["HF MONOMER B"] = core.get_variable("CURRENT ENERGY") core.set_global_option("SAVE_JK", False) core.timer_off("SAPT(DFT): Monomer B SCF") # Grab JK object and set to A (so we do not save many JK objects) sapt_jk = hf_wfn_B.jk() hf_wfn_A.set_jk(sapt_jk) core.set_global_option("SAVE_JK", False) # Move it back to monomer A if (core.get_global_option('SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'monomerB', 'dimer') core.print_out("\n") core.print_out( " ---------------------------------------------------------\n" ) core.print_out(" " + "SAPT(DFT): delta HF Segment".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith and Rob Parrish".center(58) + "\n") core.print_out( " ---------------------------------------------------------\n" ) core.print_out("\n") # Build cache hf_cache = sapt_jk_terms.build_sapt_jk_cache(hf_wfn_A, hf_wfn_B, sapt_jk, True) # Electrostatics core.timer_on("SAPT(DFT):SAPT:elst") elst = sapt_jk_terms.electrostatics(hf_cache, True) hf_data.update(elst) core.timer_off("SAPT(DFT):SAPT:elst") # Exchange core.timer_on("SAPT(DFT):SAPT:exch") exch = sapt_jk_terms.exchange(hf_cache, sapt_jk, True) hf_data.update(exch) core.timer_off("SAPT(DFT):SAPT:exch") # Induction core.timer_on("SAPT(DFT):SAPT:ind") ind = sapt_jk_terms.induction( hf_cache, sapt_jk, True, maxiter=core.get_option("SAPT", "MAXITER"), conv=core.get_option("SAPT", "D_CONVERGENCE"), Sinf=core.get_option("SAPT", "DO_IND_EXCH_SINF")) hf_data.update(ind) core.timer_off("SAPT(DFT):SAPT:ind") dhf_value = hf_data["HF DIMER"] - hf_data["HF MONOMER A"] - hf_data[ "HF MONOMER B"] core.print_out("\n") core.print_out( print_sapt_hf_summary(hf_data, "SAPT(HF)", delta_hf=dhf_value)) data["Delta HF Correction"] = core.get_variable("SAPT(DFT) Delta HF") sapt_jk.finalize() del hf_wfn_A, hf_wfn_B, sapt_jk if hf_wfn_dimer is None: dimer_wfn = core.Wavefunction.build(sapt_dimer, core.get_global_option("BASIS")) else: dimer_wfn = hf_wfn_dimer # Set the primary functional core.set_local_option('SCF', 'REFERENCE', 'RKS') # Compute Monomer A wavefunction core.timer_on("SAPT(DFT): Monomer A DFT") if (core.get_global_option('SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'dimer', 'monomerA') if mon_a_shift: core.set_global_option("DFT_GRAC_SHIFT", mon_a_shift) core.IO.set_default_namespace('monomerA') wfn_A = scf_helper(sapt_dft_functional, post_scf=False, molecule=monomerA, banner="SAPT(DFT): DFT Monomer A", **kwargs) data["DFT MONOMERA"] = core.get_variable("CURRENT ENERGY") core.set_global_option("DFT_GRAC_SHIFT", 0.0) core.timer_off("SAPT(DFT): Monomer A DFT") # Compute Monomer B wavefunction core.timer_on("SAPT(DFT): Monomer B DFT") if (core.get_global_option('SCF_TYPE') == 'DF'): core.IO.change_file_namespace(97, 'monomerA', 'monomerB') if mon_b_shift: core.set_global_option("DFT_GRAC_SHIFT", mon_b_shift) core.set_global_option("SAVE_JK", True) core.IO.set_default_namespace('monomerB') wfn_B = scf_helper(sapt_dft_functional, post_scf=False, molecule=monomerB, banner="SAPT(DFT): DFT Monomer B", **kwargs) data["DFT MONOMERB"] = core.get_variable("CURRENT ENERGY") # Save JK object sapt_jk = wfn_B.jk() wfn_A.set_jk(sapt_jk) core.set_global_option("SAVE_JK", False) core.set_global_option("DFT_GRAC_SHIFT", 0.0) core.timer_off("SAPT(DFT): Monomer B DFT") # Write out header scf_alg = core.get_global_option("SCF_TYPE") sapt_dft_header(sapt_dft_functional, mon_a_shift, mon_b_shift, bool(do_delta_hf), scf_alg) # Call SAPT(DFT) sapt_jk = wfn_B.jk() sapt_dft(dimer_wfn, wfn_A, wfn_B, sapt_jk=sapt_jk, data=data, print_header=False) # Copy data back into globals for k, v in data.items(): core.set_variable(k, v) core.tstop() return dimer_wfn
def build_superfunctional(alias, restricted): name = alias.lower() npoints = core.get_option("SCF", "DFT_BLOCK_MAX_POINTS") deriv = 1 # Default depth for now # Grab out superfunctional if name in ["gen", ""]: sup = (core.get_option("DFT_CUSTOM_FUNCTIONAL"), False) if not isinstance(sup[0], core.SuperFunctional): raise KeyError( "SCF: Custom Functional requested, but nothing provided in DFT_CUSTOM_FUNCTIONAL" ) elif name in superfunctionals.keys(): sup = superfunctionals[name](name, npoints, deriv, restricted) elif name.upper() in superfunctionals.keys(): sup = superfunctionals[name.upper()](name, npoints, deriv, restricted) elif any(name.endswith(al) for al in dftd3.full_dash_keys): # Odd hack for b97-d if 'b97-d' in name: name = name.replace('b97', 'b97-d') dashparam = [x for x in dftd3.full_dash_keys if name.endswith(x)] if len(dashparam) > 1: raise Exception("Dashparam %s is ambiguous.") else: dashparam = dashparam[0] base_name = name.replace('-' + dashparam, '') if dashparam in ['d2', 'd']: dashparam = 'd2p4' if dashparam == 'd3': dashparam = 'd3zero' if dashparam == 'd3m': dashparam = 'd3mzero' if base_name not in superfunctionals.keys(): raise KeyError("SCF: Functional (%s) with base (%s) not found!" % (alias, base_name)) func = superfunctionals[base_name](base_name, npoints, deriv, restricted)[0] base_name = base_name.replace('wpbe', 'lcwpbe') sup = (func, (base_name, dashparam)) else: raise KeyError("SCF: Functional (%s) not found!" % alias) if (core.get_global_option('INTEGRAL_PACKAGE') == 'ERD') and (sup[0].is_x_lrc() or sup[0].is_c_lrc()): raise ValidationError( "INTEGRAL_PACKAGE ERD does not play nicely with omega ERI's, so stopping." ) # Set options if core.has_option_changed("SCF", "DFT_OMEGA") and sup[0].is_x_lrc(): sup[0].set_x_omega(core.get_option("SCF", "DFT_OMEGA")) if core.has_option_changed("SCF", "DFT_OMEGA_C") and sup[0].is_c_lrc(): sup[0].set_c_omega(core.get_option("SCF", "DFT_OMEGA_C")) if core.has_option_changed("SCF", "DFT_ALPHA"): sup[0].set_x_alpha(core.get_option("SCF", "DFT_ALPHA")) if core.has_option_changed("SCF", "DFT_ALPHA_C"): sup[0].set_c_alpha(core.get_option("SCF", "DFT_ALPHA_C")) # Check SCF_TYPE if sup[0].is_x_lrc() and (core.get_option("SCF", "SCF_TYPE") not in ["DIRECT", "DF", "OUT_OF_CORE", "PK"]): raise KeyError( "SCF: SCF_TYPE (%s) not supported for range-seperated functionals." % core.get_option("SCF", "SCF_TYPE")) if (core.get_global_option('INTEGRAL_PACKAGE') == 'ERD') and (sup[0].is_x_lrc()): raise ValidationError( 'INTEGRAL_PACKAGE ERD does not play nicely with LRC DFT functionals, so stopping.' ) return sup