def cubeprop(wfn, **kwargs):
"""Evaluate properties on a grid and generate cube files.
.. versionadded:: 0.5
*wfn* parameter passed explicitly
:returns: None
:type wfn: :py:class:`~psi4.core.Wavefunction`
:param wfn: set of molecule, basis, orbitals from which to generate cube files
:examples:
>>> # [1] Cube files for all orbitals
>>> E, wfn = energy('b3lyp', return_wfn=True)
>>> cubeprop(wfn)
>>> # [2] Cube files for density (alpha, beta, total, spin) and four orbitals
>>> # (two alpha, two beta)
>>> set cubeprop_tasks ['orbitals', 'density']
>>> set cubeprop_orbitals [5, 6, -5, -6]
>>> E, wfn = energy('scf', return_wfn=True)
>>> cubeprop(wfn)
"""
# By default compute the orbitals
if not core.has_global_option_changed('CUBEPROP_TASKS'):
core.set_global_option('CUBEPROP_TASKS', ['ORBITALS'])
if ((core.get_global_option('INTEGRAL_PACKAGE') == 'ERD') and ('ESP' in core.get_global_option('CUBEPROP_TASKS'))):
raise ValidationError('INTEGRAL_PACKAGE ERD does not play nicely with electrostatic potential, so stopping.')
cp = core.CubeProperties(wfn)
cp.compute_properties()
def pybuild_basis(mol, key=None, target=None, fitrole='BASIS', other=None, puream=-1, return_atomlist=False):
horde = qcdb.libmintsbasisset.basishorde
if key == 'ORBITAL':
key = 'BASIS'
if horde and key:
tmp = horde.get(core.get_global_option(key), None)
if tmp:
target = tmp
elif target:
pass
elif tmp is None:
target = None
elif target:
pass
elif key is None:
target = core.get_global_option("BASIS")
else:
target = core.get_global_option(key)
basisdict = qcdb.BasisSet.pyconstruct(mol.create_psi4_string_from_molecule(),
key, target, fitrole, other, return_atomlist=return_atomlist)
if return_atomlist:
atom_basis_list = []
for atbs in basisdict:
atommol = core.Molecule.create_molecule_from_string(atbs['molecule'])
lmbs = core.BasisSet.construct_from_pydict(atommol, atbs, puream)
atom_basis_list.append(lmbs)
#lmbs.print_detail_out()
return atom_basis_list
psibasis = core.BasisSet.construct_from_pydict(mol, basisdict, puream)
return psibasis
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
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 : str, optional
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_global_option("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 check_disk_df(name, optstash):
optstash.add_option(['SCF_TYPE'])
# Alter default algorithm
if not core.has_global_option_changed('SCF_TYPE'):
core.set_global_option('SCF_TYPE', 'DISK_DF')
core.print_out(""" Method '%s' requires SCF_TYPE = DISK_DF, setting.\n""" % name)
elif core.get_global_option('SCF_TYPE') == "DF":
core.set_global_option('SCF_TYPE', 'DISK_DF')
core.print_out(""" Method '%s' requires SCF_TYPE = DISK_DF, setting.\n""" % name)
else:
if core.get_global_option('SCF_TYPE') != "DISK_DF":
raise ValidationError(" %s requires SCF_TYPE = DISK_DF, please use SCF_TYPE = DF to automatically choose the correct DFJK implementation." % name)
def format_options_for_input(molecule=None, **kwargs):
"""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.
- Does not cover local (as opposed to global) options.
"""
if molecule is not None:
symmetry = molecule.find_point_group(0.00001).symbol()
commands = ''
commands += """\ncore.set_memory_bytes(%s)\n\n""" % (core.get_memory())
for chgdopt in core.get_global_option_list():
if core.has_global_option_changed(chgdopt):
chgdoptval = core.get_global_option(chgdopt)
if molecule is not None:
if chgdopt.lower() in kwargs:
if symmetry in kwargs[chgdopt.lower()]:
chgdoptval = kwargs[chgdopt.lower()][symmetry]
if isinstance(chgdoptval, str):
commands += """core.set_global_option('%s', '%s')\n""" % (chgdopt, chgdoptval)
# Next four lines were conflict between master and roa branches (TDC, 10/29/2014)
elif isinstance(chgdoptval, int) or isinstance(chgdoptval, float):
commands += """core.set_global_option('%s', %s)\n""" % (chgdopt, chgdoptval)
elif isinstance(chgdoptval, list):
commands += """core.set_global_option('%s', %s)\n""" % (chgdopt, chgdoptval)
else:
commands += """core.set_global_option('%s', %s)\n""" % (chgdopt, chgdoptval)
return commands
def expand_psivars(pvdefs):
"""Dictionary *pvdefs* has keys with names of PsiVariables to be
created and values with dictionary of two keys: 'args', the
PsiVariables that contribute to the key and 'func', a function (or
lambda) to combine them. This function builds those PsiVariables if
all the contributors are available. Helpful printing is available when
PRINT > 2.
"""
verbose = core.get_global_option('PRINT')
for pvar, action in pvdefs.items():
if verbose >= 2:
print("""building %s %s""" % (pvar, '.' * (50 - len(pvar))), end='')
psivars = core.scalar_variables()
data_rich_args = []
for pv in action['args']:
if isinstance(pv, str):
if pv in psivars:
data_rich_args.append(psivars[pv])
else:
if verbose >= 2:
print("""EMPTY, missing {}""".format(pv))
break
else:
data_rich_args.append(pv)
else:
result = action['func'](data_rich_args)
core.set_variable(pvar, result)
if verbose >= 2:
print("""SUCCESS""")
def pybuild_basis(mol, key=None, target=None, fitrole='ORBITAL', other=None, puream=-1, return_atomlist=False, quiet=False):
horde = qcdb.libmintsbasisset.basishorde
if key == 'ORBITAL':
key = 'BASIS'
if horde and key:
tmp = horde.get(core.get_global_option(key), None)
if tmp:
target = tmp
elif target:
pass
elif tmp is None:
target = None
elif target:
pass
elif key is None:
target = core.get_global_option("BASIS")
key = 'BASIS'
else:
target = core.get_global_option(key)
basisdict = qcdb.BasisSet.pyconstruct(mol.create_psi4_string_from_molecule(),
key, target, fitrole, other, return_atomlist=return_atomlist)
if return_atomlist:
atom_basis_list = []
for atbs in basisdict:
atommol = core.Molecule.create_molecule_from_string(atbs['molecule'])
lmbs = core.BasisSet.construct_from_pydict(atommol, atbs, puream)
atom_basis_list.append(lmbs)
#lmbs.print_detail_out()
return atom_basis_list
if not quiet:
core.print_out(basisdict['message'])
psibasis = core.BasisSet.construct_from_pydict(mol, basisdict, puream)
ecpbasis = None
if 'ecp_shell_map' in basisdict:
ecpbasis = core.BasisSet.construct_ecp_from_pydict(mol, basisdict, puream)
if key == 'BASIS':
# For orbitals basis sets, we need to return ECP also
return psibasis, ecpbasis
else:
# There is no ECP basis for auxilliary basis sets
return psibasis
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 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 check_non_symmetric_jk_density(name):
"""
Ensure non-symmetric density matrices are supported for the selected JK routine.
"""
scf_type = core.get_global_option('SCF_TYPE')
supp_jk_type = ['DF', 'DISK_DF', 'MEM_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 _resolve_target(key, target):
"""Figure out exactly what basis set was intended by (key, target)
"""
horde = qcdb.libmintsbasisset.basishorde
if not target:
if not key:
key = 'BASIS'
target = core.get_global_option(key)
if target in horde:
return horde[target]
return target
def cubeprop_compute_properties(self):
"""Filesystem wrapper for CubeProperties::raw_compute_properties."""
filepath = core.get_global_option("CUBEPROP_FILEPATH")
# Is filepath a valid directory?
if not os.path.isdir(os.path.abspath(os.path.expandvars(filepath))):
raise ValidationError("""Filepath "{}" is not valid. Please create this directory.""".format(filepath))
geomfile = filepath + os.sep + 'geom.xyz'
xyz = self.basisset().molecule().to_string(dtype='xyz', units='Angstrom')
with open(geomfile, 'w') as fh:
fh.write(xyz)
self.raw_compute_properties()
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 compare_csx():
"""Function to validate energies in CSX files against PSIvariables. Only
active if write_csx flag on.
"""
warnings.warn(
"Using `psi4.driver.p4util.compare_csx` is deprecated (silently in 1.2), and in 1.3 it will stop working\n",
category=FutureWarning,
stacklevel=2)
if 'csx4psi' in sys.modules.keys():
if core.get_global_option('WRITE_CSX'):
enedict = csx2endict()
compare_integers(len(enedict) >= 2, True, 'CSX harvested')
for pv, en in enedict.items():
compare_values(core.variable(pv), en, 6, 'CSX ' + pv + ' ' + str(round(en, 4)))
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 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 __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_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_ = self.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')
# 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")
incfock_performed = hasattr(
self.jk(), "do_incfock_iter") and self.jk().do_incfock_iter()
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) # P::e PCM
self.set_energies("PCM Polarization", upcm)
upe = 0.0
if core.get_option('SCF', 'PE'):
Dt = self.Da().clone()
Dt.add(self.Db())
upe, Vpe = self.pe_state.get_pe_contribution(Dt, elec_only=False)
SCFE += upe
self.push_back_external_potential(Vpe)
self.set_variable("PE ENERGY", upe) # P::e PE
self.set_energies("PE Energy", upe)
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. The reset is necessary because SAD
# nalpha_ and nbeta_ are not guaranteed physical.
# 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:
for engine_used in self.diis(Dnorm):
status.append(engine_used)
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")
level_shift = core.get_option("SCF", "LEVEL_SHIFT")
if level_shift > 0 and Dnorm > core.get_option(
'SCF', 'LEVEL_SHIFT_CUTOFF'):
status.append("SHIFT")
self.form_C(level_shift)
else:
self.form_C()
core.timer_off("HF: Form C")
if self.MOM_performed_:
status.append("MOM")
if self.frac_performed_:
status.append("FRAC")
if incfock_performed:
status.append("INCFOCK")
# 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)
core.set_variable("SCF D NORM", Dnorm)
# 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 core.has_option_changed("SCF", "ORBITALS_WRITE"):
filename = core.get_option("SCF", "ORBITALS_WRITE")
self.to_file(filename)
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
# Note that MOM_performed_ just checks initialization, and our convergence measures used the pre-MOM orbitals
if self.MOM_excited_ and ((not self.MOM_performed_) or self.iteration_
== core.get_option('SCF', "MOM_START")):
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] == 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 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
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 = {}
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,
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)
# Blow away JK object before doing MP2 for memory considerations
if cleanup_jk:
sapt_jk.finalize()
# Dispersion
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)
# Print out final data
core.print_out("\n")
core.print_out(print_sapt_dft_summary(data, "SAPT(DFT)"))
return data
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 = dft_builder.build_superfunctional_from_dictionary(name, npoints, deriv, restricted)
# Check for pre-defined dict-based functionals
elif name.lower() in dft_builder.functionals:
sup = dft_builder.build_superfunctional_from_dictionary(dft_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 not isinstance(name, dict):
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 not isinstance(name, dict):
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 _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 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 compute_dipole_derivatives(self,
wfn,
prog='psi4',
geom=None,
disp_points=3,
disp_size=0.001,
c4kw={}):
Natom = self.mol.natom()
if prog.upper() == 'PSI4':
# Lacking analytic derivatives, we will do fd of applied electric fields. We
# alternately apply + and - electric fields in the x, y, and z directions, and
# then take finite differences to get the dipole moment derivatives.
self.pr(
"(ROA) Computing dipole moment derivatives with Psi4 by f.d...\n"
)
#Prepare geometry
if geom is None:
geom = self.analysis_geom_2D
self.mol.set_geometry(core.Matrix.from_array(geom))
self.mol.fix_com(True)
self.mol.fix_orientation(True)
self.mol.reset_point_group('c1')
N = self.mol.natom()
if disp_points == 3:
lambdas = [-1.0 * disp_size, 1.0 * disp_size]
elif disp_points == 5:
lambdas = [
-2.0 * disp_size, -1.0 * disp_size, 1.0 * disp_size,
+2.0 * disp_size
]
DmuxDx = psi4.core.Matrix("Dipole derivatives mu_x", N, 3)
DmuyDx = psi4.core.Matrix("Dipole derivatives mu_y", N, 3)
DmuzDx = psi4.core.Matrix("Dipole derivatives mu_z", N, 3)
for dipole_xyz, dipole_vector in enumerate([[1, 0, 0], [0, 1, 0],
[0, 0, 1]]):
dx = []
for l in lambdas:
core.set_global_option('perturb_h', True)
core.set_global_option('perturb_with', 'dipole')
scaled_dipole_vector = []
for x in dipole_vector:
scaled_dipole_vector.append(x * l)
core.set_global_option('perturb_dipole',
scaled_dipole_vector)
dx.append(psi4.gradient(wfn))
for A in range(N):
for xyz in range(3):
if disp_points == 3:
val = (dx[1].get(A, xyz) -
dx[0].get(A, xyz)) / (2.0 * disp_size)
elif disp_points == 5:
val = (dx[0].get(A,xyz) - 8.0*dx[1].get(A,xyz) \
+ 8.0*dx[2].get(A,xyz) - dx[3].get(A,xyz)) / (12.0*disp_size)
if dipole_xyz == 0:
DmuxDx.set(A, xyz, val)
elif dipole_xyz == 1:
DmuyDx.set(A, xyz, val)
elif dipole_xyz == 2:
DmuzDx.set(A, xyz, val)
core.set_global_option('PERTURB_H', 0)
core.set_global_option('PERTURB_DIPOLE', '')
# write out a file17 with the dipole moment derivatives
f = open('file17.dat', 'w')
for i in range(N):
f.write('{0:20.10f}{1:20.10f}{2:20.10f}\n'.format(
DmuxDx.get(i, 0), DmuxDx.get(i, 1), DmuxDx.get(i, 2)))
for i in range(N):
f.write('{0:20.10f}{1:20.10f}{2:20.10f}\n'.format(
DmuyDx.get(i, 0), DmuyDx.get(i, 1), DmuyDx.get(i, 2)))
for i in range(N):
f.write('{0:20.10f}{1:20.10f}{2:20.10f}\n'.format(
DmuzDx.get(i, 0), DmuzDx.get(i, 1), DmuzDx.get(i, 2)))
f.close()
elif prog.upper() == 'CFOUR':
self.pr(
"(ROA) Reading dipole moment derivatives from CFOUR's DIPDER.\n"
)
kw = {
'CALC': wfn.upper(),
'BASIS': core.get_global_option('BASIS'),
'VIB': 'EXACT',
'UNITS': 'BOHR',
'VIB': 'EXACT',
'UNITS': 'BOHR',
'SCF_CONV': 9,
'MEM_UNIT': 'GB',
'MEMORY_SIZE': round(core.get_memory() // 1e9),
'SCF_DAMP': 600, # CFOUR's SCF is really poor at converging.
'SCF_EXPSTART': 300,
'SCF_MAXCYC': 600,
}
kw.update(c4kw)
atom_symbols = [
self.mol.symbol(at) for at in range(self.mol.natom())
]
c4 = CFOUR(self.analysis_geom_2D, atom_symbols, kw,
"input for DIPDIR read")
(c4dipx, c4dipy, c4dipz) = c4.parseDIPDER()
# Now rotate to input orientation
c4coord = c4.parseGeometry()
rmsd, mill = qcel.molutil.B787(c4coord,
self.analysis_geom_2D,
None,
None,
atoms_map=True,
verbose=False)
RotMat = mill.rotation
# For each atom for field direction by nuclear direction 3x3 and transform it.
for at in range(Natom):
DIPDERatom = np.zeros((3, 3))
DIPDERatom[0, :] = c4dipx[at, :]
DIPDERatom[1, :] = c4dipy[at, :]
DIPDERatom[2, :] = c4dipz[at, :]
DIPDERatom[:] = np.dot(RotMat.T, np.dot(DIPDERatom, RotMat))
c4dipx[at][:] = DIPDERatom[0, :]
c4dipy[at][:] = DIPDERatom[1, :]
c4dipz[at][:] = DIPDERatom[2, :]
c4.writeFile17(c4dipx, c4dipy, c4dipz)
else:
raise Exception('Other muder prog not yet implemented')
return
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()
# Normal string based data
elif name.lower() in superfunctionals.keys():
sup = superfunctionals[name.lower()](name, npoints, deriv, restricted)
elif name.upper() in superfunctionals.keys():
sup = superfunctionals[name.upper()](name, npoints, deriv, restricted)
# Check if we are dispersion
elif any(name.lower().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 ValidationError(
"SCF: Functional (%s) with base (%s) not found!" %
(name, 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 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"))
# 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 ValidationError(
"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.'
)
sup[0].set_lock(True)
return sup
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 analyze_ROA(self,
name='CC',
gauge='VELOCITY',
geom=None,
masses=None,
print_lvl=2):
"""
name is just a label for the dictionary output, could be driver/wfn
gauge one or more gauges to analyze
These only need set if doing a restart without remaking displacements
geometry: only used here if normal mode analysis not get done.
"""
self.pr('(ROA) Analyzing ROA spectrum.\n')
self.update_status_fd_db()
if not self.alldone_fd_db:
self.pr('Finite difference computations not all complete.\n')
self.update_status_fd_db() #pr=True)
return
Natom = self.mol.natom()
fd_pol = roa.psi4_read_polarizabilities(self.db['jobs'].keys(),
self.db['omega'])
fd_pol = np.array(fd_pol)
if print_lvl > 2:
self.pr("Electric-Dipole/Dipole Polarizabilities\n")
self.pr(str(fd_pol))
fd_quad_list = roa.psi4_read_dipole_quadrupole_polarizability(
self.db['jobs'].keys(), self.db['omega'])
fd_quad = []
for row in fd_quad_list:
fd_quad.append(np.array(row).reshape(9, 3))
if print_lvl > 2:
self.pr("Electric-Dipole/Quadrupole Polarizabilities\n")
self.pr(str(fd_quad) + '\n')
# required for IR intensities; could be omitted if absent
dipder = roa.psi4_read_dipole_derivatives(Natom)
if print_lvl > 2:
self.pr("Dipole Moment Derivatives\n")
self.pr(str(dipder) + '\n')
gauge_todo_options = {
'LENGTH': ['Length'],
'VELOCITY': ['Modified Velocity'],
'BOTH': ['Length', 'Modified Velocity']
}
for g in gauge_todo_options[gauge.upper()]:
self.pr('Doing analysis (scatter function) for %s\n' % g)
fd_rot = roa.psi4_read_optical_rotation_tensor(
self.db['jobs'].keys(), self.db['omega'], g)
fd_rot = np.array(fd_rot)
if print_lvl > 2:
self.pr("Optical Rotation Tensor\n")
self.pr(str(fd_rot) + '\n')
self.pr(
'\n\n----------------------------------------------------------------------\n'
)
self.pr('\t%%%%%%%%%% {} Results %%%%%%%%%%\n'.format(g))
self.pr(
'----------------------------------------------------------------------\n\n'
)
# Create a name for an output spectral dictionary file
bas = core.get_global_option('BASIS')
# Like to put number of basis functions in the output too.
NBF = core.BasisSet.build(self.mol, 'BASIS', bas).nbf()
lbl = (name + '/' + bas).upper()
sp_outfile = core.get_output_file()
if sp_outfile[-4:] in ['.out', '.dat']:
sp_outfile = sp_outfile[:-4]
sp_outfile = sp_outfile + '.sp.out'
if geom is None:
geom = self.analysis_geom_2D
if masses is None:
masses = np.array([self.mol.mass(i) for i in range(Natom)])
if self.coord_using_atomic_Cartesians:
# If we displaced along 3N Cartesians, then we don't need
# hessian until here.
hessian = roa.psi4_read_hessian(Natom)
roa.scatter(geom,
masses,
hessian,
dipder,
self.db['omega'],
self.db['ROA_disp_size'],
fd_pol,
fd_rot,
fd_quad,
print_lvl=2,
ROAdictName=sp_outfile,
pr=self.pr,
calc_type=lbl,
nbf=NBF)
else:
roa.modeScatter(self.vib_modes,
self.coord_xyzs,
self.vib_freqs,
geom,
masses,
dipder,
self.db['omega'],
self.db['ROA_disp_size'],
fd_pol,
fd_rot,
fd_quad,
print_lvl=2,
ROAdictName=sp_outfile,
pr=self.pr,
calc_type=lbl,
nbf=NBF)
self.db['roa_computed'] = True
def pybuild_basis(mol,
key=None,
target=None,
fitrole='ORBITAL',
other=None,
puream=-1,
return_atomlist=False,
quiet=False):
horde = qcdb.libmintsbasisset.basishorde
if key == 'ORBITAL':
key = 'BASIS'
if horde and key:
tmp = horde.get(core.get_global_option(key), None)
if tmp:
target = tmp
elif target:
pass
elif tmp is None:
target = None
elif target:
pass
elif key is None:
target = core.get_global_option("BASIS")
key = 'BASIS'
else:
target = core.get_global_option(key)
basisdict = qcdb.BasisSet.pyconstruct(
mol.create_psi4_string_from_molecule(),
key,
target,
fitrole,
other,
return_atomlist=return_atomlist)
if return_atomlist:
atom_basis_list = []
for atbs in basisdict:
atommol = core.Molecule.create_molecule_from_string(
atbs['molecule'])
lmbs = core.BasisSet.construct_from_pydict(atommol, atbs, puream)
atom_basis_list.append(lmbs)
#lmbs.print_detail_out()
return atom_basis_list
if not quiet:
core.print_out(basisdict['message'])
psibasis = core.BasisSet.construct_from_pydict(mol, basisdict, puream)
ecpbasis = None
if 'ecp_shell_map' in basisdict:
ecpbasis = core.BasisSet.construct_ecp_from_pydict(
mol, basisdict, puream)
if key == 'BASIS':
# For orbitals basis sets, we need to return ECP also
return psibasis, ecpbasis
else:
# There is no ECP basis for auxilliary basis sets
return psibasis
def database(name, db_name, **kwargs):
r"""Function to access the molecule objects and reference energies of
popular chemical databases.
:aliases: db()
:returns: (*float*) Mean absolute deviation of the database in kcal/mol
:PSI variables:
.. hlist::
:columns: 1
* :psivar:`db_name DATABASE MEAN SIGNED DEVIATION`
* :psivar:`db_name DATABASE MEAN ABSOLUTE DEVIATION`
* :psivar:`db_name DATABASE ROOT-MEAN-SQUARE DEVIATION`
* Python dictionaries of results accessible as ``DB_RGT`` and ``DB_RXN``.
.. note:: It is very easy to make a database from a collection of xyz files
using the script :source:`psi4/share/psi4/scripts/ixyz2database.py`.
See :ref:`sec:createDatabase` for details.
.. caution:: Some features are not yet implemented. Buy a developer some coffee.
- In sow/reap mode, use only global options (e.g., the local option set by ``set scf scf_type df`` will not be respected).
.. note:: To access a database that is not embedded in a |PSIfour|
distribution, add the path to the directory containing the database
to the environment variable :envvar:`PYTHONPATH`.
:type name: str
:param name: ``'scf'`` || ``'sapt0'`` || ``'ccsd(t)'`` || etc.
First argument, usually unlabeled. Indicates the computational method
to be applied to the database. May be any valid argument to
:py:func:`psi4.driver.energy`.
:type db_name: str
:param db_name: ``'BASIC'`` || ``'S22'`` || ``'HTBH'`` || etc.
Second argument, usually unlabeled. Indicates the requested database
name, matching (case insensitive) the name of a python file in
``psi4/share/databases`` or :envvar:`PYTHONPATH`. Consult that
directory for available databases and literature citations.
:type func: :ref:`function <op_py_function>`
:param func: |dl| ``energy`` |dr| || ``optimize`` || ``cbs``
Indicates the type of calculation to be performed on each database
member. The default performs a single-point ``energy('name')``, while
``optimize`` perfoms a geometry optimization on each reagent, and
``cbs`` performs a compound single-point energy. If a nested series
of python functions is intended (see :ref:`sec:intercalls`), use
keyword ``db_func`` instead of ``func``.
:type mode: str
:param mode: |dl| ``'continuous'`` |dr| || ``'sow'`` || ``'reap'``
Indicates whether the calculations required to complete the
database are to be run in one file (``'continuous'``) or are to be
farmed out in an embarrassingly parallel fashion
(``'sow'``/``'reap'``). For the latter, run an initial job with
``'sow'`` and follow instructions in its output file.
:type cp: :ref:`boolean <op_py_boolean>`
:param cp: ``'on'`` || |dl| ``'off'`` |dr|
Indicates whether counterpoise correction is employed in computing
interaction energies. Use this option and NOT the ``bsse_type="cp"``
function for BSSE correction in database(). Option available
(See :ref:`sec:availableDatabases`) only for databases of bimolecular complexes.
:type rlxd: :ref:`boolean <op_py_boolean>`
:param rlxd: ``'on'`` || |dl| ``'off'`` |dr|
Indicates whether correction for deformation energy is
employed in computing interaction energies. Option available
(See :ref:`sec:availableDatabases`) only for databases of bimolecular complexes
with non-frozen monomers, e.g., HBC6.
:type symm: :ref:`boolean <op_py_boolean>`
:param symm: |dl| ``'on'`` |dr| || ``'off'``
Indicates whether the native symmetry of the database reagents is
employed (``'on'``) or whether it is forced to :math:`C_1` symmetry
(``'off'``). Some computational methods (e.g., SAPT) require no
symmetry, and this will be set by database().
:type zpe: :ref:`boolean <op_py_boolean>`
:param zpe: ``'on'`` || |dl| ``'off'`` |dr|
Indicates whether zero-point-energy corrections are appended to
single-point energy values. Option valid only for certain
thermochemical databases. Disabled until Hessians ready.
:type benchmark: str
:param benchmark: |dl| ``'default'`` |dr| || ``'S22A'`` || etc.
Indicates whether a non-default set of reference energies, if
available (See :ref:`sec:availableDatabases`), are employed for the
calculation of error statistics.
:type tabulate: List[str]
:param tabulate: |dl| ``[]`` |dr| || ``['scf total energy', 'natom']`` || etc.
Indicates whether to form tables of variables other than the
primary requested energy. Available for any PSI variable.
:type subset: Union[str, List[str]]
:param subset:
Indicates a subset of the full database to run. This is a very
flexible option and can be used in three distinct ways, outlined
below. Note that two take a string and the last takes an array.
See :ref:`sec:availableDatabases` for available values.
* ``'small'`` || ``'large'`` || ``'equilibrium'``
Calls predefined subsets of the requested database, either
``'small'``, a few of the smallest database members,
``'large'``, the largest of the database members, or
``'equilibrium'``, the equilibrium geometries for a database
composed of dissociation curves.
* ``'BzBz_S'`` || ``'FaOOFaON'`` || ``'ArNe'`` || ``'HB'`` || etc.
For databases composed of dissociation curves, or otherwise
divided into subsets, individual curves and subsets can be
called by name. Consult the database python files for available
molecular systems (case insensitive).
* ``[1,2,5]`` || ``['1','2','5']`` || ``['BzMe-3.5', 'MeMe-5.0']`` || etc.
Specify a list of database members to run. Consult the
database python files for available molecular systems. This
is the only portion of database input that is case sensitive;
choices for this keyword must match the database python file.
:examples:
>>> # [1] Two-stage SCF calculation on short, equilibrium, and long helium dimer
>>> db('scf','RGC10',cast_up='sto-3g',subset=['HeHe-0.85','HeHe-1.0','HeHe-1.5'], tabulate=['scf total energy','natom'])
>>> # [2] Counterpoise-corrected interaction energies for three complexes in S22
>>> # Error statistics computed wrt an old benchmark, S22A
>>> database('mp2','S22',cp=1,subset=[16,17,8],benchmark='S22A')
>>> # [3] SAPT0 on the neon dimer dissociation curve
>>> db('sapt0',subset='NeNe',cp=0,symm=0,db_name='RGC10')
>>> # [4] Optimize system 1 in database S22, producing tables of scf and mp2 energy
>>> db('mp2','S22',db_func=optimize,subset=[1], tabulate=['mp2 total energy','current energy'])
>>> # [5] CCSD on the smallest systems of HTBH, a hydrogen-transfer database
>>> database('ccsd','HTBH',subset='small', tabulate=['ccsd total energy', 'mp2 total energy'])
"""
lowername = name #TODO
kwargs = p4util.kwargs_lower(kwargs)
# Wrap any positional arguments into kwargs (for intercalls among wrappers)
if not ('name' in kwargs) and name:
kwargs['name'] = name #.lower()
if not ('db_name' in kwargs) and db_name:
kwargs['db_name'] = db_name
# Establish function to call
func = kwargs.pop('db_func', kwargs.pop('func', energy))
kwargs['db_func'] = func
# Bounce to CP if bsse kwarg (someday)
if kwargs.get('bsse_type', None) is not None:
raise ValidationError(
"""Database: Cannot specify bsse_type for database. Use the cp keyword withing database instead."""
)
allowoptexceeded = kwargs.get('allowoptexceeded', False)
optstash = p4util.OptionsState(['WRITER_FILE_LABEL'], ['SCF', 'REFERENCE'])
# Wrapper wholly defines molecule. discard any passed-in
kwargs.pop('molecule', None)
# Paths to search for database files: here + PSIPATH + library + PYTHONPATH
db_paths = []
db_paths.append(os.getcwd())
db_paths.extend(os.environ.get('PSIPATH', '').split(os.path.pathsep))
db_paths.append(os.path.join(core.get_datadir(), 'databases'))
db_paths.append(os.path.dirname(__file__))
db_paths = list(map(os.path.abspath, db_paths))
sys.path[1:1] = db_paths
# TODO this should be modernized a la interface_cfour
# Define path and load module for requested database
database = p4util.import_ignorecase(db_name)
if database is None:
core.print_out('\nPython module for database %s failed to load\n\n' %
(db_name))
core.print_out('\nSearch path that was tried:\n')
core.print_out(", ".join(map(str, sys.path)))
raise ValidationError("Python module loading problem for database " +
str(db_name))
else:
dbse = database.dbse
HRXN = database.HRXN
ACTV = database.ACTV
RXNM = database.RXNM
BIND = database.BIND
TAGL = database.TAGL
GEOS = database.GEOS
try:
DATA = database.DATA
except AttributeError:
DATA = {}
user_writer_file_label = core.get_global_option('WRITER_FILE_LABEL')
user_reference = core.get_global_option('REFERENCE')
# Configuration based upon e_name & db_name options
# Force non-supramolecular if needed
if not hasattr(lowername, '__call__') and re.match(r'^.*sapt', lowername):
try:
database.ACTV_SA
except AttributeError:
raise ValidationError(
'Database %s not suitable for non-supramolecular calculation.'
% (db_name))
else:
ACTV = database.ACTV_SA
# Force open-shell if needed
openshell_override = 0
if user_reference in ['RHF', 'RKS']:
try:
database.isOS
except AttributeError:
pass
else:
if p4util.yes.match(str(database.isOS)):
openshell_override = 1
core.print_out(
'\nSome reagents in database %s require an open-shell reference; will be reset to UHF/UKS as needed.\n'
% (db_name))
# Configuration based upon database keyword options
# Option symmetry- whether symmetry treated normally or turned off (currently req'd for dfmp2 & dft)
db_symm = kwargs.get('symm', True)
symmetry_override = 0
if db_symm is False:
symmetry_override = 1
elif db_symm is True:
pass
else:
raise ValidationError("""Symmetry mode '%s' not valid.""" % (db_symm))
# Option mode of operation- whether db run in one job or files farmed out
db_mode = kwargs.pop('db_mode', kwargs.pop('mode', 'continuous')).lower()
kwargs['db_mode'] = db_mode
if db_mode == 'continuous':
pass
elif db_mode == 'sow':
pass
elif db_mode == 'reap':
db_linkage = kwargs.get('linkage', None)
if db_linkage is None:
raise ValidationError(
"""Database execution mode 'reap' requires a linkage option."""
)
else:
raise ValidationError("""Database execution mode '%s' not valid.""" %
(db_mode))
# Option counterpoise- whether for interaction energy databases run in bsse-corrected or not
db_cp = kwargs.get('cp', False)
if db_cp is True:
try:
database.ACTV_CP
except AttributeError:
raise ValidationError(
"""Counterpoise correction mode 'yes' invalid for database %s."""
% (db_name))
else:
ACTV = database.ACTV_CP
elif db_cp is False:
pass
else:
raise ValidationError(
"""Counterpoise correction mode '%s' not valid.""" % (db_cp))
# Option relaxed- whether for non-frozen-monomer interaction energy databases include deformation correction or not?
db_rlxd = kwargs.get('rlxd', False)
if db_rlxd is True:
if db_cp is True:
try:
database.ACTV_CPRLX
database.RXNM_CPRLX
except AttributeError:
raise ValidationError(
'Deformation and counterpoise correction mode \'yes\' invalid for database %s.'
% (db_name))
else:
ACTV = database.ACTV_CPRLX
RXNM = database.RXNM_CPRLX
elif db_cp is False:
try:
database.ACTV_RLX
except AttributeError:
raise ValidationError(
'Deformation correction mode \'yes\' invalid for database %s.'
% (db_name))
else:
ACTV = database.ACTV_RLX
elif db_rlxd is False:
#elif no.match(str(db_rlxd)):
pass
else:
raise ValidationError('Deformation correction mode \'%s\' not valid.' %
(db_rlxd))
# Option zero-point-correction- whether for thermochem databases jobs are corrected by zpe
db_zpe = kwargs.get('zpe', False)
if db_zpe is True:
raise ValidationError(
'Zero-point-correction mode \'yes\' not yet implemented.')
elif db_zpe is False:
pass
else:
raise ValidationError('Zero-point-correction \'mode\' %s not valid.' %
(db_zpe))
# Option benchmark- whether error statistics computed wrt alternate reference energies
db_benchmark = 'default'
if 'benchmark' in kwargs:
db_benchmark = kwargs['benchmark']
if db_benchmark.lower() == 'default':
pass
else:
BIND = p4util.getattr_ignorecase(database, 'BIND_' + db_benchmark)
if BIND is None:
raise ValidationError(
'Special benchmark \'%s\' not available for database %s.' %
(db_benchmark, db_name))
# Option tabulate- whether tables of variables other than primary energy method are formed
# TODO db(func=cbs,tabulate=[non-current-energy]) # broken
db_tabulate = []
if 'tabulate' in kwargs:
db_tabulate = kwargs['tabulate']
# Option subset- whether all of the database or just a portion is run
db_subset = HRXN
if 'subset' in kwargs:
db_subset = kwargs['subset']
if isinstance(db_subset, (str, bytes)):
if db_subset.lower() == 'small':
try:
database.HRXN_SM
except AttributeError:
raise ValidationError(
"""Special subset 'small' not available for database %s."""
% (db_name))
else:
HRXN = database.HRXN_SM
elif db_subset.lower() == 'large':
try:
database.HRXN_LG
except AttributeError:
raise ValidationError(
"""Special subset 'large' not available for database %s."""
% (db_name))
else:
HRXN = database.HRXN_LG
elif db_subset.lower() == 'equilibrium':
try:
database.HRXN_EQ
except AttributeError:
raise ValidationError(
"""Special subset 'equilibrium' not available for database %s."""
% (db_name))
else:
HRXN = database.HRXN_EQ
else:
HRXN = p4util.getattr_ignorecase(database, db_subset)
if HRXN is None:
HRXN = p4util.getattr_ignorecase(database, 'HRXN_' + db_subset)
if HRXN is None:
raise ValidationError(
"""Special subset '%s' not available for database %s."""
% (db_subset, db_name))
else:
temp = []
for rxn in db_subset:
if rxn in HRXN:
temp.append(rxn)
else:
raise ValidationError(
"""Subset element '%s' not a member of database %s.""" %
(str(rxn), db_name))
HRXN = temp
temp = []
for rxn in HRXN:
temp.append(ACTV['%s-%s' % (dbse, rxn)])
HSYS = p4util.drop_duplicates(sum(temp, []))
# Sow all the necessary reagent computations
core.print_out("\n\n")
p4util.banner(("Database %s Computation" % (db_name)))
core.print_out("\n")
# write index of calcs to output file
instructions = """\n The database single-job procedure has been selected through mode='continuous'.\n"""
instructions += """ Calculations for the reagents will proceed in the order below and will be followed\n"""
instructions += """ by summary results for the database.\n\n"""
for rgt in HSYS:
instructions += """ %-s\n""" % (rgt)
core.print_out(instructions)
# Loop through chemical systems
ERGT = {}
ERXN = {}
VRGT = {}
VRXN = {}
for rgt in HSYS:
VRGT[rgt] = {}
core.print_out('\n')
p4util.banner(' Database {} Computation: Reagent {} \n {}'.format(
db_name, rgt, TAGL[rgt]))
core.print_out('\n')
molecule = core.Molecule.from_dict(GEOS[rgt].to_dict())
molecule.set_name(rgt)
molecule.update_geometry()
if symmetry_override:
molecule.reset_point_group('c1')
molecule.fix_orientation(True)
molecule.fix_com(True)
molecule.update_geometry()
if (openshell_override) and (molecule.multiplicity() != 1):
if user_reference == 'RHF':
core.set_global_option('REFERENCE', 'UHF')
elif user_reference == 'RKS':
core.set_global_option('REFERENCE', 'UKS')
core.set_global_option(
'WRITER_FILE_LABEL', user_writer_file_label +
('' if user_writer_file_label == '' else '-') + rgt)
if allowoptexceeded:
try:
ERGT[rgt] = func(molecule=molecule, **kwargs)
except ConvergenceError:
core.print_out(f"Optimization exceeded cycles for {rgt}")
ERGT[rgt] = 0.0
else:
ERGT[rgt] = func(molecule=molecule, **kwargs)
core.print_variables()
core.print_out(" Database Contributions Map:\n {}\n".format('-' *
75))
for rxn in HRXN:
db_rxn = dbse + '-' + str(rxn)
if rgt in ACTV[db_rxn]:
core.print_out(
' reagent {} contributes by {:.4f} to reaction {}\n'.
format(rgt, RXNM[db_rxn][rgt], db_rxn))
core.print_out('\n')
for envv in db_tabulate:
VRGT[rgt][envv.upper()] = core.variable(envv)
core.set_global_option("REFERENCE", user_reference)
core.clean()
#core.opt_clean()
core.clean_variables()
# Reap all the necessary reaction computations
core.print_out("\n")
p4util.banner(("Database %s Results" % (db_name)))
core.print_out("\n")
maxactv = []
for rxn in HRXN:
maxactv.append(len(ACTV[dbse + '-' + str(rxn)]))
maxrgt = max(maxactv)
table_delimit = '-' * (62 + 20 * maxrgt)
tables = ''
# find any reactions that are incomplete
FAIL = collections.defaultdict(int)
for rxn in HRXN:
db_rxn = dbse + '-' + str(rxn)
for i in range(len(ACTV[db_rxn])):
if abs(ERGT[ACTV[db_rxn][i]]) < 1.0e-12:
if not allowoptexceeded:
FAIL[rxn] = 1
# tabulate requested process::environment variables
tables += """ For each VARIABLE requested by tabulate, a 'Reaction Value' will be formed from\n"""
tables += """ 'Reagent' values according to weightings 'Wt', as for the REQUESTED ENERGY below.\n"""
tables += """ Depending on the nature of the variable, this may or may not make any physical sense.\n"""
for rxn in HRXN:
db_rxn = dbse + '-' + str(rxn)
VRXN[db_rxn] = {}
for envv in db_tabulate:
envv = envv.upper()
tables += """\n ==> %s <==\n\n""" % (envv.title())
tables += _tblhead(maxrgt, table_delimit, 2)
for rxn in HRXN:
db_rxn = dbse + '-' + str(rxn)
if FAIL[rxn]:
tables += """\n%23s %8s %8s %8s %8s""" % (db_rxn, '', '****',
'', '')
for i in range(len(ACTV[db_rxn])):
tables += """ %16.8f %2.0f""" % (VRGT[
ACTV[db_rxn][i]][envv], RXNM[db_rxn][ACTV[db_rxn][i]])
else:
VRXN[db_rxn][envv] = 0.0
for i in range(len(ACTV[db_rxn])):
VRXN[db_rxn][envv] += VRGT[
ACTV[db_rxn][i]][envv] * RXNM[db_rxn][ACTV[db_rxn][i]]
tables += """\n%23s %16.8f """ % (
db_rxn, VRXN[db_rxn][envv])
for i in range(len(ACTV[db_rxn])):
tables += """ %16.8f %2.0f""" % (VRGT[
ACTV[db_rxn][i]][envv], RXNM[db_rxn][ACTV[db_rxn][i]])
tables += """\n %s\n""" % (table_delimit)
# tabulate primary requested energy variable with statistics
count_rxn = 0
minDerror = 100000.0
maxDerror = 0.0
MSDerror = 0.0
MADerror = 0.0
RMSDerror = 0.0
tables += """\n ==> %s <==\n\n""" % ('Requested Energy')
tables += _tblhead(maxrgt, table_delimit, 1)
for rxn in HRXN:
db_rxn = dbse + '-' + str(rxn)
if FAIL[rxn]:
tables += """\n%23s %8.4f %8s %10s %10s""" % (
db_rxn, BIND[db_rxn], '****', '****', '****')
for i in range(len(ACTV[db_rxn])):
tables += """ %16.8f %2.0f""" % (ERGT[ACTV[db_rxn][i]],
RXNM[db_rxn][ACTV[db_rxn][i]])
else:
ERXN[db_rxn] = 0.0
for i in range(len(ACTV[db_rxn])):
ERXN[db_rxn] += ERGT[ACTV[db_rxn][i]] * RXNM[db_rxn][
ACTV[db_rxn][i]]
error = constants.hartree2kcalmol * ERXN[db_rxn] - BIND[db_rxn]
tables += """\n%23s %8.4f %8.4f %10.4f %10.4f""" % (
db_rxn, BIND[db_rxn], constants.hartree2kcalmol * ERXN[db_rxn],
error, error * constants.cal2J)
for i in range(len(ACTV[db_rxn])):
tables += """ %16.8f %2.0f""" % (ERGT[ACTV[db_rxn][i]],
RXNM[db_rxn][ACTV[db_rxn][i]])
if abs(error) < abs(minDerror):
minDerror = error
if abs(error) > abs(maxDerror):
maxDerror = error
MSDerror += error
MADerror += abs(error)
RMSDerror += error * error
count_rxn += 1
tables += """\n %s\n""" % (table_delimit)
if count_rxn:
MSDerror /= float(count_rxn)
MADerror /= float(count_rxn)
RMSDerror = math.sqrt(RMSDerror / float(count_rxn))
tables += """%23s %19s %10.4f %10.4f\n""" % (
'Minimal Dev', '', minDerror, minDerror * constants.cal2J)
tables += """%23s %19s %10.4f %10.4f\n""" % (
'Maximal Dev', '', maxDerror, maxDerror * constants.cal2J)
tables += """%23s %19s %10.4f %10.4f\n""" % (
'Mean Signed Dev', '', MSDerror, MSDerror * constants.cal2J)
tables += """%23s %19s %10.4f %10.4f\n""" % (
'Mean Absolute Dev', '', MADerror, MADerror * constants.cal2J)
tables += """%23s %19s %10.4f %10.4f\n""" % (
'RMS Dev', '', RMSDerror, RMSDerror * constants.cal2J)
tables += """ %s\n""" % (table_delimit)
core.set_variable('%s DATABASE MEAN SIGNED DEVIATION' % (db_name),
MSDerror)
core.set_variable('%s DATABASE MEAN ABSOLUTE DEVIATION' % (db_name),
MADerror)
core.set_variable('%s DATABASE ROOT-MEAN-SQUARE DEVIATION' % (db_name),
RMSDerror)
core.print_out(tables)
finalenergy = MADerror
else:
finalenergy = 0.0
optstash.restore()
DB_RGT.clear()
DB_RGT.update(VRGT)
DB_RXN.clear()
DB_RXN.update(VRXN)
return finalenergy
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')
if self.iteration_ < 2:
core.print_out(" ==> Iterations <==\n\n")
core.print_out("%s Total Energy Delta E RMS |[F,P]|\n\n" % (" "
if is_dfjk else ""))
# SCF iterations!
SCFE_old = 0.0
SCFE = 0.0
Drms = 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
mints = core.MintsHelper(self.basisset())
Vefp = modify_Fock_induced(self.molecule().EFP, mints, 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")
# reset fractional SAD occupation
if (self.iteration_ == 0) and self.reset_occ_:
self.reset_occupation()
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")
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
# EFP: Add efp contribution to energy
efp_Dt = self.Da().clone()
efp_Dt.add(self.Db())
SCFE += self.molecule().EFP.get_wavefunction_dependent_energy()
self.set_energies("Total Energy", SCFE)
Ediff = SCFE - SCFE_old
SCFE_old = SCFE
status = []
# We either do SOSCF or DIIS
if (soscf_enabled and (self.iteration_ > 3) and (Drms < core.get_option('SCF', 'SOSCF_START_CONVERGENCE'))):
Drms = 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, Drms, 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 nmicro > 0:
# if zero, the soscf call bounced for some reason
self.find_occupation()
status.append(base_name + str(nmicro))
soscf_performed = True # Stops DIIS
else:
if verbose > 0:
core.print_out("Did not take a SOSCF step, using normal convergence methods\n")
soscf_performed = False # Back to DIIS
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
core.timer_on("HF: DIIS")
diis_performed = False
add_to_diis_subspace = False
if self.diis_enabled_ and self.iteration_ >= self.diis_start_:
add_to_diis_subspace = True
Drms = self.compute_orbital_gradient(add_to_diis_subspace, core.get_option('SCF', 'DIIS_MAX_VECS'))
if (self.diis_enabled_
and self.iteration_ >= self.diis_start_ + 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")
core.timer_on("HF: Form D")
self.form_D()
core.timer_off("HF: Form D")
core.set_variable("SCF ITERATION ENERGY", SCFE)
# After we've built the new D, damp the update
if (damping_enabled and self.iteration_ > 1 and Drms > 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 %3d: %20.14f %12.5e %-11.5e %s\n" %
("DF-" if is_dfjk else "", reference, self.iteration_, SCFE, Ediff, Drms, '/'.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 _converged(Ediff, Drms, e_conv=e_conv, d_conv=d_conv):
break
if self.iteration_ >= core.get_option('SCF', 'MAXITER'):
raise ConvergenceError("""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 compute_hessian(self,
wfn,
prog='psi4',
geom=None,
disp_points=3,
disp_size=0.005,
c4executable=None,
c4kw={}):
Natom = self.mol.natom()
if prog.upper() == 'PSI4':
self.pr("(ROA) Computing hessian with Psi4...\n")
#Prepare geometry
if geom is None:
geom = self.analysis_geom_2D
self.mol.set_geometry(core.Matrix.from_array(geom))
self.mol.fix_com(True)
self.mol.fix_orientation(True)
self.mol.reset_point_group('c1')
# core.set_global_option('hessian_write', True)
# compute the hessian, put in numpy format, then write out file15.dat file.
psi4_hess = psi4.hessian(wfn, molecule=self.mol)
npHess = psi4_hess.clone().np
npHess = np.reshape(npHess, (3 * Natom * Natom, 3))
f = open('file15.dat', 'w')
for i in range(npHess.shape[0]):
f.write('{0:20.10f}{1:20.10f}{2:20.10f}\n'.format(
npHess[i][0], npHess[i][1], npHess[i][2]))
f.close()
elif prog.upper() == 'CFOUR':
self.pr("(ROA) Computing hessian with CFOUR...\n")
kw = {
'CALC': wfn.upper(),
# if basis not builtin C4, set BASIS=SPECIAL and SPECIAL_BASIS='name'
'BASIS': core.get_global_option('BASIS'),
#'SPECIAL_BASIS' : '6-31G'
'VIB': 'EXACT',
'UNITS': 'BOHR',
'SCF_CONV': 9,
'MEM_UNIT': 'GB',
'MEMORY_SIZE': round(core.get_memory() // 1e9),
'SCF_DAMP': 600, # CFOUR's SCF is really poor at converging.
'SCF_EXPSTART': 300,
'SCF_MAXCYC': 600,
}
kw.update(c4kw)
atom_symbols = [
self.mol.symbol(at) for at in range(self.mol.natom())
]
if c4executable is None:
c4executable = 'run-cfour'
c4 = CFOUR(self.analysis_geom_2D,
atom_symbols,
kw,
title="hess-calc",
executable=c4executable)
c4.run()
c4h = c4.parseHessian() # read the hessian output file (FCMFINAL)
# Now rotate the Hessian into the original input orientation; fancy!
c4coord = c4.parseGeometry()
rmsd, mill = qcel.molutil.B787(c4coord,
self.analysis_geom_2D,
None,
None,
atoms_map=True,
verbose=False)
c4h[:] = mill.align_hessian(c4h)
c4.writeFile15(c4h)
else:
raise Exception('Other hessian prog not yet implemented')
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 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()
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(" ==> 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 (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 = {}
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)"))
# Copy data back into globals
for k, v in data.items():
core.set_variable(k, v)
core.tstop()
return dimer_wfn
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 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):Build 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):Build 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()
# Hybrid xc kernel check
do_hybrid = core.get_option("SAPT", "SAPT_DFT_DO_HYBRID")
is_x_hybrid = wfn_B.functional().is_x_hybrid()
is_x_lrc = wfn_B.functional().is_x_lrc()
hybrid_specified = core.has_option_changed("SAPT", "SAPT_DFT_DO_HYBRID")
if is_x_lrc:
if do_hybrid:
if hybrid_specified:
raise ValidationError(
"SAPT(DFT): Hybrid xc kernel not yet implemented for range-separated funtionals."
)
else:
core.print_out(
"Warning: Hybrid xc kernel not yet implemented for range-separated funtionals; hybrid kernel capability is turned off.\n"
)
is_hybrid = False
else:
if do_hybrid:
is_hybrid = is_x_hybrid
else:
is_hybrid = False
# 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'))
x_alpha = wfn_B.functional().x_alpha()
if not is_hybrid:
x_alpha = 0.0
fdds_disp = sapt_mp2_terms.df_fdds_dispersion(primary_basis, aux_basis,
cache, is_hybrid, x_alpha)
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 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 run_cfour(name, **kwargs):
"""Function that prepares environment and input files
for a calculation calling Stanton and Gauss's CFOUR code.
Also processes results back into Psi4 format.
This function is not called directly but is instead called by
:py:func:`~psi4.driver.energy` or :py:func:`~psi4.driver.optimize` when a Cfour
method is requested (through *name* argument). In order to function
correctly, the Cfour executable ``xcfour`` must be present in
:envvar:`PATH` or :envvar:`PSIPATH`.
.. hlist::
:columns: 1
* Many :ref:`PSI Variables <apdx:cfour_psivar>` extracted from the Cfour output
* Python dictionary of associated file constants accessible as ``P4C4_INFO['zmat']``, ``P4C4_INFO['output']``, ``P4C4_INFO['grd']``, *etc.*
:type name: str
:param name: ``'c4-scf'`` || ``'c4-ccsd(t)'`` || ``'cfour'`` || etc.
First argument, usually unlabeled. Indicates the computational
method to be applied to the system.
:type keep: :ref:`boolean <op_py_boolean>`
:param keep: ``'on'`` || |dl| ``'off'`` |dr|
Indicates whether to delete the Cfour scratch directory upon
completion of the Cfour job.
:type path: str
:param path:
Indicates path to Cfour scratch directory (with respect to Psi4
scratch directory). Otherwise, the default is a subdirectory
within the Psi4 scratch directory.
If specified, GENBAS and/or ZMAT within will be used.
:type genbas: str
:param genbas:
Indicates that contents should be used for GENBAS file.
GENBAS is a complicated topic. It is quite unnecessary if the
molecule is from a molecule {...} block and basis is set through
|Psifours| BASIS keyword. In that case, a GENBAS is written from
LibMints and all is well. Otherwise, a GENBAS is looked for in
the usual places: PSIPATH, PATH, PSIDATADIR/basis. If path kwarg is
specified, also looks there preferentially for a GENBAS. Can
also specify GENBAS within an input file through a string and
setting the genbas kwarg. Note that due to the input parser's
aggression, blank lines need to be replaced by the text blankline.
"""
lowername = name.lower()
internal_p4c4_info = {}
return_wfn = kwargs.pop('return_wfn', False)
# Make sure the molecule the user provided is the active one
molecule = kwargs.pop('molecule', core.get_active_molecule())
molecule.update_geometry()
optstash = p4util.OptionsState(['CFOUR', 'TRANSLATE_PSI4'])
# Determine calling function and hence dertype
calledby = inspect.stack()[1][3]
dertype = ['energy', 'gradient', 'hessian'].index(calledby)
#print('I am %s called by %s called by %s.\n' %
# (inspect.stack()[0][3], inspect.stack()[1][3], inspect.stack()[2][3]))
# Save submission directory
current_directory = os.getcwd()
# Move into job scratch directory
psioh = core.IOManager.shared_object()
psio = core.IO.shared_object()
os.chdir(psioh.get_default_path())
# Construct and move into cfour subdirectory of job scratch directory
cfour_tmpdir = kwargs['path'] if 'path' in kwargs else \
'psi.' + str(os.getpid()) + '.' + psio.get_default_namespace() + \
'.cfour.' + str(uuid.uuid4())[:8]
if not os.path.exists(cfour_tmpdir):
os.mkdir(cfour_tmpdir)
os.chdir(cfour_tmpdir)
# 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') + ':' + core.get_datadir() +
'/basis',
'GENBAS_PATH':
core.get_datadir() + '/basis',
'CFOUR_NUM_CORES':
os.environ.get('CFOUR_NUM_CORES'),
'MKL_NUM_THREADS':
os.environ.get('MKL_NUM_THREADS'),
'OMP_NUM_THREADS':
os.environ.get('OMP_NUM_THREADS'),
'LD_LIBRARY_PATH':
os.environ.get('LD_LIBRARY_PATH')
}
if 'path' in kwargs:
lenv['PATH'] = kwargs['path'] + ':' + lenv['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}
# Load the GENBAS file
genbas_path = qcdb.search_file('GENBAS', lenv['GENBAS_PATH'])
if genbas_path:
try:
shutil.copy2(genbas_path, psioh.get_default_path() + cfour_tmpdir)
except shutil.Error: # should only fail if src and dest equivalent
pass
core.print_out("\n GENBAS loaded from %s\n" % (genbas_path))
core.print_out(" CFOUR to be run from %s\n" %
(psioh.get_default_path() + cfour_tmpdir))
else:
message = """
GENBAS file for CFOUR interface not found. Either:
[1] Supply a GENBAS by placing it in PATH or PSIPATH
[1a] Use cfour {} block with molecule and basis directives.
[1b] Use molecule {} block and CFOUR_BASIS keyword.
[2] Allow Psi4's internal basis sets to convert to GENBAS
[2a] Use molecule {} block and BASIS keyword.
"""
core.print_out(message)
core.print_out(' Search path that was tried:\n')
core.print_out(lenv['PATH'].replace(':', ', '))
# Generate the ZMAT input file in scratch
if 'path' in kwargs and os.path.isfile('ZMAT'):
core.print_out(" ZMAT loaded from %s\n" %
(psioh.get_default_path() + kwargs['path'] + '/ZMAT'))
else:
with open('ZMAT', 'w') as cfour_infile:
cfour_infile.write(write_zmat(lowername, dertype, molecule))
internal_p4c4_info['zmat'] = open('ZMAT', 'r').read()
#core.print_out('\n====== Begin ZMAT input for CFOUR ======\n')
#core.print_out(open('ZMAT', 'r').read())
#core.print_out('======= End ZMAT input for CFOUR =======\n\n')
#print('\n====== Begin ZMAT input for CFOUR ======')
#print(open('ZMAT', 'r').read())
#print('======= End ZMAT input for CFOUR =======\n')
if 'genbas' in kwargs:
with open('GENBAS', 'w') as cfour_basfile:
cfour_basfile.write(kwargs['genbas'].replace(
'\nblankline\n', '\n\n'))
core.print_out(' GENBAS loaded from kwargs string\n')
# Close psi4 output file and reopen with filehandle
print('output in', current_directory + '/' + core.outfile_name())
pathfill = '' if os.path.isabs(
core.outfile_name()) else current_directory + os.path.sep
# Handle threading
# OMP_NUM_THREADS from env is in lenv from above
# threads from psi4 -n (core.get_num_threads()) is ignored
# CFOUR_OMP_NUM_THREADS psi4 option takes precedence, handled below
if core.has_option_changed('CFOUR', 'CFOUR_OMP_NUM_THREADS'):
lenv['OMP_NUM_THREADS'] = str(
core.get_option('CFOUR', 'CFOUR_OMP_NUM_THREADS'))
#print("""\n\n<<<<< RUNNING CFOUR ... >>>>>\n\n""")
# Call executable xcfour, directing cfour output to the psi4 output file
cfour_executable = kwargs['c4exec'] if 'c4exec' in kwargs else 'xcfour'
try:
retcode = subprocess.Popen([cfour_executable],
bufsize=0,
stdout=subprocess.PIPE,
env=lenv)
except OSError as e:
sys.stderr.write(
'Program %s not found in path or execution failed: %s\n' %
(cfour_executable, e.strerror))
message = ('Program %s not found in path or execution failed: %s\n' %
(cfour_executable, e.strerror))
raise ValidationError(message)
c4out = ''
while True:
data = retcode.stdout.readline()
data = data.decode('utf-8')
if not data:
break
core.print_out(data)
c4out += data
internal_p4c4_info['output'] = c4out
c4files = {}
core.print_out('\n')
for item in ['GRD', 'FCMFINAL', 'DIPOL']:
try:
with open(psioh.get_default_path() + cfour_tmpdir + '/' + item,
'r') as handle:
c4files[item] = handle.read()
core.print_out(' CFOUR scratch file %s has been read\n' %
(item))
core.print_out('%s\n' % c4files[item])
internal_p4c4_info[item.lower()] = c4files[item]
except IOError:
pass
core.print_out('\n')
if molecule.name() == 'blank_molecule_psi4_yo':
qcdbmolecule = None
else:
molecule.update_geometry()
qcdbmolecule = qcdb.Molecule(
molecule.create_psi4_string_from_molecule())
qcdbmolecule.update_geometry()
# c4mol, if it exists, is dinky, just a clue to geometry of cfour results
psivar, c4grad, c4mol = qcdb.cfour.harvest(qcdbmolecule, c4out, **c4files)
# Absorb results into psi4 data structures
for key in psivar.keys():
core.set_variable(key.upper(), float(psivar[key]))
if qcdbmolecule is None and c4mol is not None:
molrec = qcel.molparse.from_string(
c4mol.create_psi4_string_from_molecule(),
enable_qm=True,
missing_enabled_return_qm='minimal',
enable_efp=False,
missing_enabled_return_efp='none',
)
molecule = core.Molecule.from_dict(molrec['qm'])
molecule.set_name('blank_molecule_psi4_yo')
core.set_active_molecule(molecule)
molecule.update_geometry()
# This case arises when no Molecule going into calc (cfour {} block) but want
# to know the orientation at which grad, properties, etc. are returned (c4mol).
# c4mol is dinky, w/o chg, mult, dummies and retains name
# blank_molecule_psi4_yo so as to not interfere with future cfour {} blocks
if c4grad is not None:
mat = core.Matrix.from_list(c4grad)
core.set_gradient(mat)
#print ' <<< [3] C4-GRD-GRAD >>>'
#mat.print()
# exit(1)
# # Things needed core.so module to do
# collect c4out string
# read GRD
# read FCMFINAL
# see if theres an active molecule
# # Things delegatable to qcdb
# parsing c4out
# reading GRD and FCMFINAL strings
# reconciling p4 and c4 molecules (orient)
# reconciling c4out and GRD and FCMFINAL results
# transforming frame of results back to p4
# # Things run_cfour needs to have back
# psivar
# qcdb.Molecule of c4?
# coordinates?
# gradient in p4 frame
# # Process the cfour output
# psivar, c4coord, c4grad = qcdb.cfour.cfour_harvest(c4out)
# for key in psivar.keys():
# core.set_variable(key.upper(), float(psivar[key]))
#
# # Awful Hack - Go Away TODO
# if c4grad:
# molecule = core.get_active_molecule()
# molecule.update_geometry()
#
# if molecule.name() == 'blank_molecule_psi4_yo':
# p4grad = c4grad
# p4coord = c4coord
# else:
# qcdbmolecule = qcdb.Molecule(molecule.create_psi4_string_from_molecule())
# #p4grad = qcdbmolecule.deorient_array_from_cfour(c4coord, c4grad)
# #p4coord = qcdbmolecule.deorient_array_from_cfour(c4coord, c4coord)
#
# with open(psioh.get_default_path() + cfour_tmpdir + '/GRD', 'r') as cfour_grdfile:
# c4outgrd = cfour_grdfile.read()
# print('GRD\n',c4outgrd)
# c4coordGRD, c4gradGRD = qcdb.cfour.cfour_harvest_files(qcdbmolecule, grd=c4outgrd)
#
# p4mat = core.Matrix.from_list(p4grad)
# core.set_gradient(p4mat)
# print(' <<< P4 PSIVAR >>>')
# for item in psivar:
# print(' %30s %16.8f' % (item, psivar[item]))
#print(' <<< P4 COORD >>>')
#for item in p4coord:
# print(' %16.8f %16.8f %16.8f' % (item[0], item[1], item[2]))
# print(' <<< P4 GRAD >>>')
# for item in c4grad:
# print(' %16.8f %16.8f %16.8f' % (item[0], item[1], item[2]))
# Clean up cfour scratch directory unless user instructs otherwise
keep = yes.match(str(kwargs['keep'])) if 'keep' in kwargs else False
os.chdir('..')
try:
if keep or ('path' in kwargs):
core.print_out('\n CFOUR scratch files have been kept in %s\n' %
(psioh.get_default_path() + cfour_tmpdir))
else:
shutil.rmtree(cfour_tmpdir)
except OSError as e:
print('Unable to remove CFOUR temporary directory %s' % e,
file=sys.stderr)
exit(1)
# Return to submission directory and reopen output file
os.chdir(current_directory)
core.print_out('\n')
p4util.banner(' Cfour %s %s Results ' %
(name.lower(), calledby.capitalize()))
core.print_variables()
if c4grad is not None:
core.get_gradient().print_out()
core.print_out('\n')
p4util.banner(' Cfour %s %s Results ' %
(name.lower(), calledby.capitalize()))
core.print_variables()
if c4grad is not None:
core.get_gradient().print_out()
# Quit if Cfour threw error
if 'CFOUR ERROR CODE' in core.variables():
raise ValidationError("""Cfour exited abnormally.""")
P4C4_INFO.clear()
P4C4_INFO.update(internal_p4c4_info)
optstash.restore()
# new skeleton wavefunction w/mol, highest-SCF basis (just to choose one), & not energy
# Feb 2017 hack. Could get proper basis in skel wfn even if not through p4 basis kw
if core.get_global_option('BASIS') in ["", "(AUTO)"]:
gobas = "sto-3g"
else:
gobas = core.get_global_option('BASIS')
basis = core.BasisSet.build(molecule, "ORBITAL", gobas)
if basis.has_ECP():
raise ValidationError("""ECPs not hooked up for Cfour""")
wfn = core.Wavefunction(molecule, basis)
for k, v in psivar.items():
wfn.set_variable(k.upper(), float(v))
optstash.restore()
if dertype == 0:
finalquantity = psivar['CURRENT ENERGY']
elif dertype == 1:
finalquantity = core.get_gradient()
wfn.set_gradient(finalquantity)
if finalquantity.rows(0) < 20:
core.print_out('CURRENT GRADIENT')
finalquantity.print_out()
elif dertype == 2:
pass
#finalquantity = finalhessian
#wfn.set_hessian(finalquantity)
#if finalquantity.rows(0) < 20:
# core.print_out('CURRENT HESSIAN')
# finalquantity.print_out()
return wfn
def write_zmat(name, dertype, molecule):
"""Returns string with contents of Cfour ZMAT file as gathered from
active molecule, current keyword settings, and cfour {...} block.
"""
# Handle memory
mem = int(0.000001 * core.get_memory())
if mem == 524:
memcmd, memkw = '', {}
else:
memcmd, memkw = qcdb.cfour.muster_memory(mem)
# Handle molecule and basis set
if molecule.name() == 'blank_molecule_psi4_yo':
molcmd, molkw = '', {}
bascmd, baskw = '', {}
core.set_local_option('CFOUR', 'TRANSLATE_PSI4', False)
else:
molecule.update_geometry()
#print(molecule.create_psi4_string_from_molecule())
qcdbmolecule = qcdb.Molecule(
molecule.create_psi4_string_from_molecule())
qcdbmolecule.tagline = molecule.name()
molcmd, molkw = qcdbmolecule.format_molecule_for_cfour()
if core.get_global_option('BASIS') in ["", "(AUTO)"]:
bascmd, baskw = '', {}
else:
user_pg = molecule.schoenflies_symbol()
molecule.reset_point_group(
'c1') # need basis printed for *every* atom
qbs = core.BasisSet.build(molecule, "BASIS",
core.get_global_option('BASIS'))
if qbs.has_ECP():
raise ValidationError("""ECPs not hooked up for Cfour""")
with open('GENBAS', 'w') as cfour_basfile:
cfour_basfile.write(qbs.genbas())
core.print_out(
' GENBAS loaded from Psi4 LibMints for basis %s\n' %
(core.get_global_option('BASIS')))
molecule.reset_point_group(user_pg)
molecule.update_geometry()
bascmd, baskw = qcdbmolecule.format_basis_for_cfour(
qbs.has_puream())
# Handle psi4 keywords implying cfour keyword values
if core.get_option('CFOUR', 'TRANSLATE_PSI4'):
psicmd, psikw = qcdb.cfour.muster_psi4options(
p4util.prepare_options_for_modules(changedOnly=True))
else:
psicmd, psikw = '', {}
# Handle calc type and quantum chemical method
mdccmd, mdckw = qcdb.cfour.muster_modelchem(name, dertype)
# Handle calc type and quantum chemical method
mdccmd, mdckw = qcdb.cfour.muster_modelchem(name, dertype)
# Handle driver vs input/default keyword reconciliation
userkw = p4util.prepare_options_for_modules()
userkw = qcdb.options.reconcile_options(userkw, memkw)
userkw = qcdb.options.reconcile_options(userkw, molkw)
userkw = qcdb.options.reconcile_options(userkw, baskw)
userkw = qcdb.options.reconcile_options(userkw, psikw)
userkw = qcdb.options.reconcile_options(userkw, mdckw)
# Handle conversion of psi4 keyword structure into cfour format
optcmd = qcdb.options.prepare_options_for_cfour(userkw)
# Handle text to be passed untouched to cfour
litcmd = core.get_global_option('LITERAL_CFOUR')
# Assemble ZMAT pieces
zmat = memcmd + molcmd + optcmd + mdccmd + psicmd + bascmd + litcmd
if len(re.findall(r'^\*(ACES2|CFOUR|CRAPS)\(', zmat, re.MULTILINE)) != 1:
core.print_out('\n Faulty ZMAT constructed:\n%s' % (zmat))
raise ValidationError("""
Multiple *CFOUR(...) blocks in input. This usually arises
because molecule or options are specified both the psi4 way through
molecule {...} and set ... and the cfour way through cfour {...}.""")
return zmat
def sort_derivative_type(
target_dertype,
highest_analytic_dertype: int,
user_dertype: Union[int, None],
proc_messages: Dict[int, str],
verbose: int = 1,
) -> Tuple[int, int]:
r"""Find the best derivative level (0, 1, 2) and strategy (analytic, finite difference)
to achieve `target_dertype` within constraints of `user_dertype` and `highest_analytic_dertype`.
Parameters
----------
target_dertype: {'energy', 'gradient', 'hessian'}
Type of calculation targeted by driver.
highest_analytic_dertype
Highest derivative level program can provide analytically.
user_dertype
User input on which derivative level should be employed to achieve `target_dertype`.
proc_messages
Dertype-indexed detailed message to be appended to user error.
verbose
Control amount of output printing.
Returns
-------
tuple : (int, int)
"second" is highest accessible derivative level `highest_analytic_dertype` to achieve
`target_dertype` "first" within constraints of `user_dertype`. When
"first" == "second", analytic is the best strategy, otherwise finite
difference of target "first" by means of "second".
Raises
------
ValidationError
When input validation fails. When `user_dertype` exceeds `target_dertype`.
MissingMethodError
When `user_dertype` exceeds what available for `method`.
"""
egh = ['energy', 'gradient', 'hessian']
# Validate input dertypes
if target_dertype not in egh:
raise ValidationError(
f"target_dertype ({target_dertype}) must be in {egh}.")
if not (user_dertype is None or isinstance(user_dertype, int)):
raise ValidationError(
f"user_dertype ({user_dertype}) should only be None or int!")
dertype = highest_analytic_dertype
# Negotiations. In particular:
# * don't return higher derivative than targeted by driver
# * don't return higher derivative than spec'd by user. that is, user can downgrade derivative
# * alert user to conflict between driver and user_dertype
if user_dertype is not None and user_dertype > egh.index(target_dertype):
raise ValidationError(
f'User dertype ({user_dertype}) excessive for target calculation ({target_dertype})'
)
if egh.index(target_dertype) < dertype:
dertype = egh.index(target_dertype)
if user_dertype is not None:
if user_dertype <= dertype:
dertype = user_dertype
else:
msg = f"""Derivative level requested ({user_dertype}) exceeds that available ({highest_analytic_dertype})."""
if proc_messages.get(user_dertype, False):
msg += f""" Details: {proc_messages[user_dertype]}."""
raise MissingMethodError(msg)
# hack section
if core.get_global_option('PCM') and dertype != 0:
core.print_out(
'\nPCM analytic gradients are not implemented yet, re-routing to finite differences.\n'
)
dertype = 0
if core.get_global_option("RELATIVISTIC") in ["X2C", "DKH"]:
core.print_out(
"\nRelativistic analytic gradients are not implemented yet, re-routing to finite differences.\n"
)
dertype = 0
if verbose > 1:
print(
f'Derivative negotiations: target/driver={egh.index(target_dertype)}, best_available={highest_analytic_dertype}, user_dertype={user_dertype} -> FINAL={dertype}'
)
return (egh.index(target_dertype), dertype)
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"):
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":
# 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())
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'))
core.set_variable('EFP ELST ENERGY', efpene['electrostatic'] + efpene['charge_penetration'] + efpene['electrostatic_point_charges'])
core.set_variable('EFP IND ENERGY', efpene['polarization'])
core.set_variable('EFP DISP ENERGY', efpene['dispersion'])
core.set_variable('EFP EXCH ENERGY', efpene['exchange_repulsion'])
core.set_variable('EFP TOTAL ENERGY', efpene['total'])
core.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)
self.finalize()
core.print_out("\nComputation Completed\n")
return energy
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.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.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.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.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.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.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()
optstash.restore()
return dimer_wfn
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 build_superfunctional(name, restricted, npoints=None, deriv=1):
if npoints is None:
npoints = core.get_option("SCF", "DFT_BLOCK_MAX_POINTS")
# 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(sfunc[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 = dft_builder.build_superfunctional_from_dictionary(name, npoints, deriv, restricted)
# Check for pre-defined dict-based functionals
elif name.lower() in dft_builder.functionals:
sup = dft_builder.build_superfunctional_from_dictionary(dft_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 LibXC density screening
dens_tol = core.get_option("SCF", "DFT_DENSITY_TOLERANCE")
if (dens_tol > 0.0):
sup[0].set_density_tolerance(dens_tol)
# 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 not isinstance(name, dict):
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 not isinstance(name, dict):
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 ["DISK_DF", "MEM_DF", "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 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 = 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 = core.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.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.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 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 _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(f" Number of atoms is {n_atom}.\n")
if method_allowed_irreps != 0x1:
core.print_out(f" Number of irreps is {n_irrep}.\n")
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(f" Irrep {i}: {ndisp}\n")
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 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)
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(efp_field_fn)
# Initialize all integrals and perform the first guess
if self.attempt_number_ == 1:
mints = core.MintsHelper(self.basisset())
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.print_out("\n ==> Pre-Iterations <==\n\n")
core.timer_on("HF: Guess")
self.guess()
core.timer_off("HF: Guess")
# Print out initial docc/socc/etc data
if self.get_print():
lack_occupancy = core.get_local_option('SCF', 'GUESS') in ['SAD']
if core.get_global_option('GUESS') in ['SAD']:
lack_occupancy = core.get_local_option('SCF',
'GUESS') in ['AUTO']
self.print_preiterations(small=lack_occupancy)
else:
self.print_preiterations(small=lack_occupancy)
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)
# Print iteration header
is_dfjk = core.get_global_option('SCF_TYPE').endswith('DF')
diis_rms = core.get_option('SCF', 'DIIS_RMS_ERROR')
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"))
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 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
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']) # P::e EFP
self.set_variable("EFP IND ENERGY", efpene['polarization']) # P::e EFP
self.set_variable("EFP DISP ENERGY", efpene['dispersion']) # P::e EFP
self.set_variable("EFP EXCH ENERGY",
efpene['exchange_repulsion']) # P::e EFP
self.set_variable("EFP TOTAL ENERGY", efpene['total']) # P::e EFP
self.set_variable("CURRENT ENERGY", efpene['total']) # P::e EFP
core.print_out("\n ==> Post-Iterations <==\n\n")
if self.V_potential():
quad = self.V_potential().quadrature_values()
rho_a = quad['RHO_A'] / 2 if self.same_a_b_dens() else quad['RHO_A']
rho_b = quad['RHO_B'] / 2 if self.same_a_b_dens() else quad['RHO_B']
rho_ab = (rho_a + rho_b)
self.set_variable("GRID ELECTRONS TOTAL", rho_ab) # P::e SCF
self.set_variable("GRID ELECTRONS ALPHA", rho_a) # P::e SCF
self.set_variable("GRID ELECTRONS BETA", rho_b) # P::e SCF
dev_a = rho_a - self.nalpha()
dev_b = rho_b - self.nbeta()
core.print_out(f" Electrons on quadrature grid:\n")
if self.same_a_b_dens():
core.print_out(
f" Ntotal = {rho_ab:15.10f} ; deviation = {dev_b+dev_a:.3e} \n\n"
)
else:
core.print_out(
f" Nalpha = {rho_a:15.10f} ; deviation = {dev_a:.3e}\n")
core.print_out(
f" Nbeta = {rho_b:15.10f} ; deviation = {dev_b:.3e}\n")
core.print_out(
f" Ntotal = {rho_ab:15.10f} ; deviation = {dev_b+dev_a:.3e} \n\n"
)
if ((dev_b + dev_a) > 0.1):
core.print_out(
" WARNING: large deviation in the electron count on grid detected. Check grid size!"
)
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)
# Set callback function for CPSCF
self.set_external_cpscf_perturbation(
"PCM", lambda pert_dm: self.get_PCM().compute_V(pert_dm))
if core.get_option('SCF', 'PE'):
Dt = self.Da().clone()
Dt.add(self.Db())
_, Vpe = self.pe_state.get_pe_contribution(Dt, elec_only=False)
self.push_back_external_potential(Vpe)
# Set callback function for CPSCF
self.set_external_cpscf_perturbation(
"PE", lambda pert_dm: self.pe_state.get_pe_contribution(
pert_dm, elec_only=True)[1])
# 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")
core.del_variable("SCF D NORM")
return energy
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')
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_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.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)
# 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 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
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"),
Sinf=core.get_option("SAPT", "DO_IND_EXCH_SINF"))
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")
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
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)
# Save the JK object
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)
# Compute Monomer B wavefunction
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)
# 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 _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_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
scf_type = core.get_global_option('SCF_TYPE').upper()
nbf = self.get_basisset("ORBITAL").nbf()
naux = self.get_basisset("DF_BASIS_SCF").nbf()
if "DIRECT" == scf_type:
jk_size = total_memory * 0.1
elif scf_type.endswith('DF'):
jk_size = naux * nbf * nbf
else:
jk_size = nbf**4
# 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 core.get_option('SCF', "PRINT") > 0:
core.print_out(" ==> Pre-Iterations <==\n\n")
self.print_preiterations()
# 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_)
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())
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'], ['BASIS'],
['FREEZE_CORE'], ['MP2_TYPE'], ['SCF_TYPE'])
# override default scf_type
core.set_global_option('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.variable('THERMAL ENERGY CORRECTION')
dh = core.variable('ENTHALPY CORRECTION')
dg = core.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 / constants.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.variable("QCISD(T) TOTAL ENERGY")
emp4_6311gd = core.variable("MP4 TOTAL ENERGY")
emp2_6311gd = core.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.variable("MP4 TOTAL ENERGY")
emp2_6311pg_dp = core.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.variable("MP4 TOTAL ENERGY")
emp2_6311g2dfp = core.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.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')
if self.iteration_ < 2:
core.print_out(" ==> Iterations <==\n\n")
core.print_out("%s Total Energy Delta E RMS |[F,P]|\n\n" % (" "
if is_dfjk else ""))
# SCF iterations!
SCFE_old = 0.0
SCFE = 0.0
Drms = 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")
# reset fractional SAD occupation
if (self.iteration_ == 0) and self.reset_occ_:
self.reset_occupation()
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")
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)
Ediff = SCFE - SCFE_old
SCFE_old = SCFE
status = []
# We either do SOSCF or DIIS
if (soscf_enabled and (self.iteration_ > 3) and (Drms < core.get_option('SCF', 'SOSCF_START_CONVERGENCE'))):
Drms = 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, Drms, 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 nmicro > 0:
# if zero, the soscf call bounced for some reason
self.find_occupation()
status.append(base_name + str(nmicro))
soscf_performed = True # Stops DIIS
else:
if verbose > 0:
core.print_out("Did not take a SOSCF step, using normal convergence methods\n")
soscf_performed = False # Back to DIIS
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
core.timer_on("HF: DIIS")
diis_performed = False
add_to_diis_subspace = False
if self.diis_enabled_ and self.iteration_ >= self.diis_start_:
add_to_diis_subspace = True
Drms = self.compute_orbital_gradient(add_to_diis_subspace, core.get_option('SCF', 'DIIS_MAX_VECS'))
if (self.diis_enabled_
and self.iteration_ >= self.diis_start_ + 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")
core.timer_on("HF: Form D")
self.form_D()
core.timer_off("HF: Form D")
core.set_variable("SCF ITERATION ENERGY", SCFE)
# After we've built the new D, damp the update
if (damping_enabled and self.iteration_ > 1 and Drms > 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 %3d: %20.14f %12.5e %-11.5e %s\n" %
("DF-" if is_dfjk else "", reference, self.iteration_, SCFE, Ediff, Drms, '/'.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 _converged(Ediff, Drms, e_conv=e_conv, d_conv=d_conv):
break
if self.iteration_ >= core.get_option('SCF', 'MAXITER'):
raise ConvergenceError("""SCF iterations""", self.iteration_)
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
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)
# 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,
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)
# Blow away JK object before doing MP2 for memory considerations
if cleanup_jk:
sapt_jk.finalize()
# Dispersion
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)
# Print out final data
core.print_out("\n")
core.print_out(print_sapt_dft_summary(data, "SAPT(DFT)"))
return data
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
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 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 dict-based functionals
elif name.upper() in dict_builder.functionals.keys():
sup = dict_builder.build_superfunctional_from_dictionary(name.upper(), 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"))
# 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 ValidationError(
"SCF: SCF_TYPE (%s) not supported for range-separated 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.')
sup[0].set_lock(True)
return sup