+#
+# @BEGIN LICENSE
+#
+# Psi4: an open-source quantum chemistry software package
+#
+# Copyright (c) 2007-2023 The Psi4 Developers.
+#
+# The copyrights for code used from other parties are included in
+# the corresponding files.
+#
+# This file is part of Psi4.
+#
+# Psi4 is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# Psi4 is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with Psi4; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# @END LICENSE
+#
+
+"""Module with functions that encode the sequence of PSI module
+calls for each of the *name* values of the energy(), optimize(),
+response(), and frequency() function. *name* can be assumed lowercase by here.
+
+"""
+import os
+import re
+import shutil
+import subprocess
+import sys
+import warnings
+from typing import Dict, List, Union
+
+import numpy as np
+from qcelemental.util import parse_version, which
+
+from psi4 import core, extras
+
+from .. import p4util
+from .. import psifiles as psif
+from .. import qcdb
+from ..constants import constants
+from ..p4util.exceptions import (
+ ManagedMethodError,
+ PastureRequiredError,
+ UpgradeHelper,
+ ValidationError,
+ docs_table_link,
+)
+
+#from psi4.driver.molutil import *
+from ..qcdb.basislist import corresponding_basis
+from . import dft, empirical_dispersion, mcscf, proc_util, response, solvent
+from .proc_data import method_algorithm_type
+from .roa import run_roa
+
+# never import driver, wrappers, or aliases into this file
+
+
+
+# ADVICE on new additions:
+# * two choices: basic `def run` or managed `def select`
+# * consult http://psicode.org/psi4manual/master/proc_py.html --or-- <psi4-repo>/doc/sphinxman/source/proc_py.rst
+
+
+def select_scf_gradient(name, **kwargs):
+ """Function selecting the algorithm for an SCF gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type("scf") # `"scf"` instead of `name` avoids adding every functional to governing dict in proc_data.py
+ module = core.get_global_option('QC_MODULE')
+
+ if mtd_type == 'CD':
+ # manifestation of `"""No analytic derivatives for SCF_TYPE CD."""`.
+ # here, only hits upon `gradient("scf")` so above message also present in driver.py to catch e.g., mp2 gradient atop a cd reference.
+ func = None
+ else:
+ func = run_scf_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp2(name, **kwargs):
+ """Function selecting the algorithm for a MP2 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'DETCI':
+ func = run_detci
+ elif module == 'FNOCC':
+ func = run_fnocc
+ elif module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module == 'OCC':
+ func = run_dfocc
+ elif module in ['', 'DFMP2']:
+ func = run_dfmp2
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module == 'OCC':
+ func = run_dfocc
+ elif module in ['', 'DFMP2']:
+ func = run_dfmp2
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module == 'DETCI':
+ raise UpgradeHelper("energy('mp2')", "energy('zapt2')", 1.7,
+ " Replace method MP with method ZAPT for ROHF reference. DETCI is orders-of-magnitude inefficient for perturbation theory.")
+ elif module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module == 'OCC':
+ func = run_dfocc
+ elif module in ['', 'DFMP2']:
+ func = run_dfmp2
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif reference in ['RKS', 'UKS']:
+ if mtd_type == 'DF':
+ if module in ['', 'DFMP2']:
+ func = run_dfmp2
+
+ if module == 'DETCI':
+ core.print_out("""\nDETCI is ill-advised for method MP2 as it is available inefficiently as a """
+ """byproduct of a CISD computation.\n""")
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp2_gradient(name, **kwargs):
+ """Function selecting the algorithm for a MP2 gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+ all_electron = (core.get_global_option('FREEZE_CORE') == "FALSE")
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if all_electron:
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module == 'OCC':
+ func = run_dfocc_gradient
+ elif module in ['', 'DFMP2']:
+ func = run_dfmp2_gradient
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if all_electron:
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module, all_electron])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp2_property(name, **kwargs):
+ """Function selecting the algorithm for a MP2 property call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'DF':
+ #if module == 'OCC':
+ # func = run_dfocc_property
+ if module in ['', 'DFMP2']:
+ func = run_dfmp2_property
+ #elif reference == 'UHF':
+ # if mtd_type == 'DF':
+ # if module in ['', 'OCC']:
+ # func = run_dfocc_property
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp2(name, **kwargs):
+ """Function selecting the algorithm for an OMP2 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp2_gradient(name, **kwargs):
+ """Function selecting the algorithm for an OMP2 gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp2_property(name, **kwargs):
+ """Function selecting the algorithm for an OMP2 property call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_property
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp2p5_property(name, **kwargs):
+ """Function selecting the algorithm for an OMP2.5 property call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_property
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp3_property(name, **kwargs):
+ """Function selecting the algorithm for an OMP3 property call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_property
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_olccd_property(name, **kwargs):
+ """Function selecting the algorithm for an OLCCD property call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_property
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp3(name, **kwargs):
+ """Function selecting the algorithm for a MP3 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'DETCI':
+ func = run_detci
+ elif module == 'FNOCC':
+ func = run_fnocc
+ elif module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module == 'DETCI':
+ raise UpgradeHelper("energy('mp3')", "energy('zapt3')", 1.7,
+ " Replace method MP with method ZAPT for ROHF reference. DETCI is orders-of-magnitude inefficient for perturbation theory.")
+
+ if module == 'DETCI':
+ core.print_out("""\nDETCI is ill-advised for method MP3 as it is available inefficiently as a """
+ """byproduct of a CISD computation.\n""")
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp3_gradient(name, **kwargs):
+ """Function selecting the algorithm for a MP3 gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+ all_electron = (core.get_global_option('FREEZE_CORE') == "FALSE")
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if all_electron:
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if all_electron:
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module, all_electron])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp3(name, **kwargs):
+ """Function selecting the algorithm for an OMP3 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp3_gradient(name, **kwargs):
+ """Function selecting the algorithm for an OMP3 gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp2p5(name, **kwargs):
+ """Function selecting the algorithm for a MP2.5 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp2p5_gradient(name, **kwargs):
+ """Function selecting the algorithm for a MP2.5 gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+ all_electron = (core.get_global_option('FREEZE_CORE') == "FALSE")
+
+ func = None
+ if reference in ['RHF', 'UHF']:
+ if mtd_type == 'CONV':
+ if all_electron:
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module, all_electron])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp2p5(name, **kwargs):
+ """Function selecting the algorithm for an OMP2.5 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_omp2p5_gradient(name, **kwargs):
+ """Function selecting the algorithm for an OMP2.5 gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_lccd(name, **kwargs):
+ """Function selecting the algorithm for a LCCD energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'OCC':
+ func = run_occ
+ elif module in ['', 'FNOCC']:
+ func = run_cepa
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_lccd_gradient(name, **kwargs):
+ """Function selecting the algorithm for a LCCD gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+ all_electron = (core.get_global_option('FREEZE_CORE') == "FALSE")
+
+ func = None
+ if reference in ['RHF', 'UHF']:
+ if mtd_type == 'CONV':
+ if all_electron:
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module, all_electron])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_olccd(name, **kwargs):
+ """Function selecting the algorithm for an OLCCD energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_olccd_gradient(name, **kwargs):
+ """Function selecting the algorithm for an OLCCD gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF', 'UHF', 'ROHF', 'RKS', 'UKS']:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_fnoccsd(name, **kwargs):
+ """Function selecting the algorithm for a FNO-CCSD energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'FNOCC']:
+ func = run_fnocc
+ elif mtd_type == 'DF':
+ if module in ['', 'FNOCC']:
+ func = run_fnodfcc
+ elif mtd_type == 'CD':
+ if module in ['', 'FNOCC']:
+ func = run_fnodfcc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_ccsd(name, **kwargs):
+ """Function selecting the algorithm for a CCSD energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ # [Aug 2022] DF CCSD through CCENERGY for (RHF|ROHF) not enabled here since not advertised. It does run, though, see #2710
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'FNOCC':
+ func = run_fnocc
+ elif module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module == 'CCT3' and extras.addons("cct3"):
+ import cct3
+ func = cct3.run_cct3
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif mtd_type == 'DF':
+ if module == 'OCC':
+ func = run_dfocc
+ elif module in ['', 'FNOCC']:
+ func = run_fnodfcc
+ elif mtd_type == 'CD':
+ if module == 'OCC':
+ func = run_dfocc
+ elif module in ['', 'FNOCC']:
+ func = run_fnodfcc
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif mtd_type in ["DF", "CD"]:
+ if module in ["", "OCC"]:
+ func = run_dfocc
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module == 'CCT3' and extras.addons("cct3"):
+ import cct3
+ func = cct3.run_cct3
+ elif module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_ccsd_gradient(name, **kwargs):
+ """Function selecting the algorithm for a CCSD gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'CCENERGY']:
+ func = run_ccenergy_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'CCENERGY']:
+ func = run_ccenergy_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'CCENERGY']:
+ func = run_ccenergy_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_fnoccsd_t_(name, **kwargs):
+ """Function selecting the algorithm for a FNO-CCSD(T) energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'FNOCC']:
+ func = run_fnocc
+ elif mtd_type == 'DF':
+ if module in ['', 'FNOCC']:
+ func = run_fnodfcc
+ elif mtd_type == 'CD':
+ if module in ['', 'FNOCC']:
+ func = run_fnodfcc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_ccsd_t_(name, **kwargs):
+ """Function selecting the algorithm for a CCSD(T) energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'FNOCC':
+ func = run_fnocc
+ elif module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif mtd_type == 'DF':
+ if module == 'OCC':
+ func = run_dfocc
+ elif module in ['', 'FNOCC']:
+ func = run_fnodfcc
+ elif mtd_type == 'CD':
+ if module == 'OCC':
+ func = run_dfocc
+ elif module in ['', 'FNOCC']:
+ func = run_fnodfcc
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif mtd_type in ["DF", "CD"]:
+ if module in ["OCC"]: # SOON "",
+ func = run_dfocc
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_ccsd_t__gradient(name, **kwargs):
+ """Function selecting the algorithm for a CCSD(T) gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ['RHF']:
+ if mtd_type == 'CONV':
+ if module in ['CCENERGY']: # FORMERLY ""
+ func = run_ccenergy_gradient
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc_gradient
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module in ['CCENERGY']: # FORMERLY ""
+ func = run_ccenergy_gradient
+ elif mtd_type == 'DF':
+ if module in ['OCC']: # SOON "",
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_ccsd_at_(name, **kwargs):
+ """Function selecting the algorithm for a a-CCSD(T) energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ if name.lower() == "a-ccsd(t)":
+ pass
+ elif name.lower() in ["ccsd(at)", "lambda-ccsd(t)", "ccsd(t)_l"]:
+ core.print_out(f"""\nMethod "{name.lower()}" has been regularized to "a-ccsd(t)" for QCVariables.""")
+ name = "a-ccsd(t)"
+
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif reference == "UHF":
+ if mtd_type == 'CONV':
+ if module in ['', 'MRCC'] and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif mtd_type == "DF":
+ if module in ["OCC"]: # SOON "",
+ func = run_dfocc
+ elif mtd_type == "CD":
+ if module in ["OCC"]: # SOON "",
+ func = run_dfocc
+ elif reference == "ROHF":
+ if mtd_type == 'CONV':
+ if module in ['', 'MRCC'] and which("dmrcc", return_bool=True):
+ func = run_mrcc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_cisd(name, **kwargs):
+ """Function selecting the algorithm for a CISD energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'DETCI':
+ func = run_detci
+ elif module in ['', 'FNOCC']:
+ func = run_cepa
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'DETCI']:
+ func = run_detci
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mp4(name, **kwargs):
+ """Function selecting the algorithm for a MP4 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'DETCI':
+ func = run_detci
+ elif module in ['', 'FNOCC']:
+ func = run_fnocc
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module == 'DETCI':
+ raise UpgradeHelper("energy('mp4')", "energy('zapt4')", 1.7,
+ " Replace method MP with method ZAPT for ROHF reference. DETCI is orders-of-magnitude inefficient for perturbation theory.")
+
+ if module == 'DETCI':
+ core.print_out("""\nDETCI is ill-advised for method MP4 as it is available inefficiently as a """
+ """byproduct of a CISDT computation.\n""")
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_remp2(name, **kwargs):
+ """Function selecting the algorithm for a REMP2 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference in ["RHF", "UHF"]:
+ if mtd_type == 'CONV':
+ if module in ['', 'OCC']:
+ func = run_occ
+ elif mtd_type == 'DF':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+ elif mtd_type == 'CD':
+ if module in ['', 'OCC']:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_ccd(name, **kwargs):
+ """Function selecting the algorithm for a CCD energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option("SCF", "REFERENCE")
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option("QC_MODULE")
+
+ func = None
+ if reference in ["RHF", "UHF"]:
+ if mtd_type == "CONV":
+ if module in [""]:
+ core.print_out("""\nThis method is not available with conventional integrals. Add "set """
+ """cc_type df" or "set cc_type cd" to input to access this method.\n""")
+ elif mtd_type == "DF":
+ if module in ["", "OCC"]:
+ func = run_dfocc
+ elif mtd_type == "CD":
+ if module in ["", "OCC"]:
+ func = run_dfocc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_ccd_gradient(name, **kwargs):
+ """Function selecting the algorithm for a CCD gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option("SCF", "REFERENCE")
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option("QC_MODULE")
+
+ func = None
+ if reference in ["RHF", "UHF"]:
+ if mtd_type == "CONV":
+ if module in [""]:
+ core.print_out("""\nThis method is not available with conventional integrals. Add "set """
+ """cc_type df" or "set cc_type cd" to input to access this method.\n""")
+ elif mtd_type == "DF":
+ if module in ["", "OCC"]:
+ func = run_dfocc_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop("probe", False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_cc2(name, **kwargs):
+ """Function selecting the algorithm for a CC2 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ # [LAB Aug 2022] I'm leaving MRCC CC2 in as a route, but my c.2014 MRCC consistently yields:
+ # "Approximate CC methods are not implemented for excitation level 2!"
+ # [LAB Aug 2022] DF CC2 enabled for test_gradient but only by deliberate `set qc_module ccenergy`
+ # since not advertised. See #2710.
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif mtd_type == 'DF':
+ if module in ['CCENERGY']:
+ func = run_ccenergy
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_cc2_gradient(name, **kwargs):
+ """Function selecting the algorithm for a CC2 gradient call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ # [LAB Aug 2022] Both UHF and ROHF gradients run in ccenergy but ROHF is slightly off (1.e-5)
+ # and UHF is more off (1.e-4). Moreover, manual only claims RHF are working, so restricting here.
+ # [LAB Aug 2022] DF CC2 enabled for test_gradient but only by deliberate `set qc_module ccenergy`
+ # since not advertised. See #2710.
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'CCENERGY']:
+ func = run_ccenergy_gradient
+ elif mtd_type == 'DF':
+ if module in ['CCENERGY']:
+ func = run_ccenergy_gradient
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_cc3(name, **kwargs):
+ """Function selecting the algorithm for a CC3 energy call
+ and directing to specified or best-performance default modules.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module == 'MRCC' and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif module in ['', 'CCENERGY']:
+ func = run_ccenergy
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ # ROHF MRCC CC3 CCn methods are not implemented for ROHF reference!
+ if module in ['', 'CCENERGY']:
+ func = run_ccenergy
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def select_mrcc(name, **kwargs):
+ """Function selecting the algorithm for a CC* energy call
+ and directing to specified MRCC module.
+
+ This function is unusual among "select" functions in that it services multiple methods and a
+ single module. This function could have been skipped and the methods associated directly with
+ run_rmcc; however, routing through this function screens for conv only while
+ providing uniform error messages with other select functions.
+
+ """
+ reference = core.get_option('SCF', 'REFERENCE')
+ type_var, _, mtd_type = method_algorithm_type(name)
+ module = core.get_global_option('QC_MODULE')
+
+ # todo fix table link anchor
+
+ func = None
+ if reference == 'RHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'MRCC'] and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif reference == 'UHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'MRCC'] and which("dmrcc", return_bool=True):
+ func = run_mrcc
+ elif reference == 'ROHF':
+ if mtd_type == 'CONV':
+ if module in ['', 'MRCC'] and which("dmrcc", return_bool=True):
+ func = run_mrcc
+
+ if func is None:
+ raise ManagedMethodError([__name__, name, type_var, mtd_type, reference, module])
+
+ if kwargs.pop('probe', False):
+ return
+ else:
+ return func(name, **kwargs)
+
+
+def build_functional_and_disp(name, restricted, save_pairwise_disp=False, **kwargs):
+
+ if core.has_option_changed("SCF", "DFT_DISPERSION_PARAMETERS"):
+ modified_disp_params = core.get_option("SCF", "DFT_DISPERSION_PARAMETERS")
+ else:
+ modified_disp_params = None
+
+ # Figure out functional
+ superfunc, disp_type = dft.build_superfunctional(name, restricted)
+
+ if disp_type:
+ if isinstance(name, dict):
+ # user dft_functional={} spec - type for lookup, dict val for param defs,
+ # name & citation discarded so only param matches to existing defs will print labels
+ _disp_functor = empirical_dispersion.EmpiricalDispersion(name_hint='',
+ level_hint=disp_type["type"],
+ param_tweaks=disp_type["params"],
+ save_pairwise_disp=save_pairwise_disp,
+ engine=kwargs.get('engine', None))
+ else:
+ # dft/*functionals.py spec - name & type for lookup, option val for param tweaks
+ _disp_functor = empirical_dispersion.EmpiricalDispersion(name_hint=superfunc.name(),
+ level_hint=disp_type["type"],
+ param_tweaks=modified_disp_params,
+ save_pairwise_disp=save_pairwise_disp,
+ engine=kwargs.get('engine', None))
+
+ # [Aug 2018] there once was a breed of `disp_type` that quacked
+ # like a list rather than the more common dict handled above. if
+ # ever again sighted, make an issue so this code can accommodate.
+
+ _disp_functor.print_out()
+ return superfunc, _disp_functor
+
+ else:
+ return superfunc, None
+
+
+
[docs]
+
def scf_wavefunction_factory(name, ref_wfn, reference, **kwargs):
+
"""Builds the correct (R/U/RO/CU HF/KS) wavefunction from the
+
provided information, sets relevant auxiliary basis sets on it,
+
and prepares any empirical dispersion.
+
+
"""
+
# Figure out functional and dispersion
+
superfunc, _disp_functor = build_functional_and_disp(name, restricted=(reference in ["RKS", "RHF"]), **kwargs)
+
+
# Build the wavefunction
+
core.prepare_options_for_module("SCF")
+
if reference in ["RHF", "RKS"]:
+
wfn = core.RHF(ref_wfn, superfunc)
+
elif reference == "ROHF":
+
wfn = core.ROHF(ref_wfn, superfunc)
+
elif reference in ["UHF", "UKS"]:
+
wfn = core.UHF(ref_wfn, superfunc)
+
elif reference == "CUHF":
+
wfn = core.CUHF(ref_wfn, superfunc)
+
else:
+
raise ValidationError("SCF: Unknown reference (%s) when building the Wavefunction." % reference)
+
+
if _disp_functor and _disp_functor.engine != 'nl':
+
wfn._disp_functor = _disp_functor
+
+
# Set the DF basis sets
+
df_needed = core.get_global_option("SCF_TYPE") in ["DF", "MEM_DF", "DISK_DF" ]
+
df_needed |= "DFDIRJ" in core.get_global_option("SCF_TYPE")
+
df_needed |= (core.get_global_option("SCF_TYPE") == "DIRECT" and core.get_option("SCF", "DF_SCF_GUESS"))
+
if df_needed:
+
aux_basis = core.BasisSet.build(wfn.molecule(), "DF_BASIS_SCF",
+
core.get_option("SCF", "DF_BASIS_SCF"),
+
"JKFIT", core.get_global_option('BASIS'),
+
puream=wfn.basisset().has_puream())
+
wfn.set_basisset("DF_BASIS_SCF", aux_basis)
+
else:
+
wfn.set_basisset("DF_BASIS_SCF", core.BasisSet.zero_ao_basis_set())
+
+
# Set the relativistic basis sets
+
if core.get_global_option("RELATIVISTIC") in ["X2C", "DKH"]:
+
decon_basis = core.BasisSet.build(wfn.molecule(), "BASIS_RELATIVISTIC",
+
core.get_option("SCF", "BASIS_RELATIVISTIC"),
+
"DECON", core.get_global_option('BASIS'),
+
puream=wfn.basisset().has_puream())
+
wfn.set_basisset("BASIS_RELATIVISTIC", decon_basis)
+
+
# Set the multitude of SAD basis sets
+
if (core.get_option("SCF", "GUESS") in ["SAD", "SADNO", "HUCKEL", "MODHUCKEL"]):
+
sad_basis_list = core.BasisSet.build(wfn.molecule(), "ORBITAL",
+
core.get_global_option("BASIS"),
+
puream=wfn.basisset().has_puream(),
+
return_atomlist=True)
+
wfn.set_sad_basissets(sad_basis_list)
+
+
if ("DF" in core.get_option("SCF", "SAD_SCF_TYPE")):
+
# We need to force this to spherical regardless of any user or other demands.
+
optstash = p4util.OptionsState(['PUREAM'])
+
core.set_global_option('PUREAM', True)
+
sad_fitting_list = core.BasisSet.build(wfn.molecule(), "DF_BASIS_SAD",
+
core.get_option("SCF", "DF_BASIS_SAD"),
+
puream=True,
+
return_atomlist=True)
+
wfn.set_sad_fitting_basissets(sad_fitting_list)
+
optstash.restore()
+
+
if core.get_option("SCF", "GUESS") == "SAPGAU":
+
# Populate sapgau basis
+
sapgau = core.BasisSet.build(wfn.molecule(), "SAPGAU_BASIS", core.get_global_option("SAPGAU_BASIS"))
+
wfn.set_basisset("SAPGAU", sapgau)
+
+
if hasattr(core, "EXTERN") and 'external_potentials' in kwargs:
+
core.print_out("\n Warning! Both an external potential EXTERN object and the external_potential" +
+
" keyword argument are specified. The external_potentials keyword argument will be ignored.\n")
+
raise ValidationError("double extern")
+
+
ep = kwargs.get("external_potentials", None)
+
if ep is not None:
+
_set_external_potentials_to_wavefunction(ep, wfn)
+
+
return wfn
+
[docs]
+
def scf_helper(name, post_scf=True, **kwargs):
+
"""Function serving as helper to SCF, choosing whether to cast
+
up or just run SCF with a standard guess. This preserves
+
previous SCF options set by other procedures (e.g., SAPT
+
output file types for SCF). Most run_* functions should call
+
this function, common exceptions being when multireference
+
SCF is needed or when restarting from converged SCF.
+
+
"""
+
+
if post_scf:
+
name = "scf"
+
+
optstash = p4util.OptionsState(
+
['PUREAM'],
+
['BASIS'],
+
['QMEFP'],
+
['INTS_TOLERANCE'],
+
['DF_BASIS_SCF'],
+
['SCF', 'GUESS'],
+
['SCF', 'DF_INTS_IO'],
+
['SCF', 'ORBITALS_WRITE'],
+
['SCF_TYPE'], # Hack: scope gets changed internally with the Andy trick
+
)
+
+
optstash2 = p4util.OptionsState(
+
['BASIS'],
+
['DF_BASIS_SCF'],
+
['SCF_TYPE'],
+
['SCF', 'DF_INTS_IO'],
+
)
+
+
# Make sure we grab the correctly scoped integral threshold for SCF
+
core.set_global_option('INTS_TOLERANCE', core.get_option('SCF', 'INTS_TOLERANCE'))
+
+
# Grab a few kwargs
+
use_c1 = kwargs.get('use_c1', False)
+
scf_molecule = kwargs.get('molecule', core.get_active_molecule())
+
read_orbitals = core.get_option('SCF', 'GUESS') == "READ"
+
do_timer = kwargs.pop("do_timer", True)
+
ref_wfn = kwargs.pop('ref_wfn', None)
+
if ref_wfn is not None:
+
raise ValidationError("Cannot seed an SCF calculation with a reference wavefunction ('ref_wfn' kwarg).")
+
+
# decide if we keep the checkpoint file
+
_chkfile = kwargs.get('write_orbitals', True)
+
write_checkpoint_file = False
+
if isinstance(_chkfile, str):
+
write_checkpoint_file = True
+
filename = kwargs.get('write_orbitals')
+
core.set_local_option("SCF", "ORBITALS_WRITE", filename)
+
elif _chkfile is True:
+
write_checkpoint_file = True
+
+
# Continuum solvation needs to be run w/o symmetry
+
if core.get_option("SCF", "PCM") or core.get_option("SCF", "DDX"):
+
c1_molecule = scf_molecule.clone()
+
c1_molecule.reset_point_group('c1')
+
c1_molecule.update_geometry()
+
+
scf_molecule = c1_molecule
+
core.print_out(""" PCM or DDX continuum solvation does not make use of molecular symmetry: """
+
"""further calculations in C1 point group.\n""")
+
+
# PE needs to use exactly input orientation to correspond to potfile
+
if core.get_option("SCF", "PE") or "external_potentials" in kwargs:
+
c1_molecule = scf_molecule.clone()
+
if getattr(scf_molecule, "_initial_cartesian", None) is not None:
+
c1_molecule._initial_cartesian = scf_molecule._initial_cartesian.clone()
+
c1_molecule.set_geometry(c1_molecule._initial_cartesian)
+
c1_molecule.reset_point_group("c1")
+
c1_molecule.fix_orientation(True)
+
c1_molecule.fix_com(True)
+
c1_molecule.update_geometry()
+
else:
+
raise ValidationError("Set no_com/no_reorient/symmetry c1 by hand for PE or external potentials on non-Cartesian molecules.")
+
+
scf_molecule = c1_molecule
+
core.print_out(""" PE does not make use of molecular symmetry: """
+
"""further calculations in C1 point group.\n""")
+
core.print_out(""" PE geometry must align with POTFILE keyword: """
+
"""resetting coordinates with fixed origin and orientation.\n""")
+
+
# SCF Banner data
+
banner = kwargs.pop('banner', None)
+
bannername = name
+
+
# Did we pass in a DFT functional?
+
dft_func = kwargs.pop('dft_functional', None)
+
if dft_func is not None:
+
if name.lower() != "scf":
+
raise ValidationError("dft_functional was supplied to SCF, but method name was not SCF ('%s')" % name)
+
name = dft_func
+
bannername = name
+
if isinstance(name, dict):
+
bannername = name.get("name", "custom functional")
+
+
p4util.libint2_print_out()
+
+
# Setup the timer
+
if do_timer:
+
core.tstart()
+
+
# Second-order SCF requires non-symmetric density matrix support
+
if core.get_option('SCF', 'SOSCF'):
+
proc_util.check_non_symmetric_jk_density("Second-order SCF")
+
+
# sort out cast_up settings. no need to stash these since only read, never reset
+
cast = False
+
if core.has_option_changed('SCF', 'BASIS_GUESS'):
+
cast = core.get_option('SCF', 'BASIS_GUESS')
+
if p4util.yes.match(str(cast)):
+
cast = True
+
elif p4util.no.match(str(cast)):
+
cast = False
+
+
if cast:
+
+
# A user can set "BASIS_GUESS" to True and we default to 3-21G
+
if cast is True:
+
guessbasis = corresponding_basis(core.get_global_option('BASIS'), 'GUESS')[0]
+
if guessbasis is None:
+
guessbasis = '3-21G' # guess of last resort
+
else:
+
guessbasis = cast
+
core.set_global_option('BASIS', guessbasis)
+
+
castdf = 'DF' in core.get_global_option('SCF_TYPE')
+
+
if core.has_option_changed('SCF', 'DF_BASIS_GUESS'):
+
castdf = core.get_option('SCF', 'DF_BASIS_GUESS')
+
if p4util.yes.match(str(castdf)):
+
castdf = True
+
elif p4util.no.match(str(castdf)):
+
castdf = False
+
+
if castdf:
+
core.set_global_option('SCF_TYPE', 'DF')
+
core.set_local_option('SCF', 'DF_INTS_IO', 'none')
+
+
# Figure out the fitting basis set
+
if castdf is True:
+
core.set_global_option('DF_BASIS_SCF', '')
+
elif isinstance(castdf, str):
+
core.set_global_option('DF_BASIS_SCF', castdf)
+
else:
+
raise ValidationError("Unexpected castdf option (%s)." % castdf)
+
+
+
# Switch to the guess namespace
+
namespace = core.IO.get_default_namespace()
+
guesspace = namespace + '.guess'
+
if namespace == '':
+
guesspace = 'guess'
+
core.IO.set_default_namespace(guesspace)
+
+
# Print some info about the guess
+
core.print_out('\n')
+
p4util.banner('Guess SCF, %s Basis' % (guessbasis))
+
core.print_out('\n')
+
+
if cast and read_orbitals:
+
raise ValidationError("""Detected options to both cast and read orbitals""")
+
+
if (core.get_option('SCF', 'STABILITY_ANALYSIS') == 'FOLLOW') and (core.get_option('SCF', 'REFERENCE') != 'UHF'):
+
raise ValidationError(f"""Stability analysis root following is only available for unrestricted Hartree--Fock, not present {core.get_option('SCF', 'REFERENCE')}""")
+
+
# If GUESS is auto guess what it should be
+
if core.get_option('SCF', 'GUESS') == "AUTO":
+
if (scf_molecule.natom() > 1):
+
core.set_local_option('SCF', 'GUESS', 'SAD')
+
else:
+
core.set_local_option('SCF', 'GUESS', 'CORE')
+
+
if core.get_global_option('BASIS') in ['', '(AUTO)']:
+
if name in ['hf3c', 'hf-3c']:
+
core.set_global_option('BASIS', 'minix')
+
elif name in ['pbeh3c', 'pbeh-3c']:
+
core.set_global_option('BASIS', 'def2-msvp')
+
elif name in ['r2scan3c', 'r2scan-3c']:
+
core.set_global_option('BASIS', 'def2-mTZVPP')
+
elif name in ['b973c', 'b97-3c']:
+
core.set_global_option('BASIS', 'def2-mTZVP')
+
elif name in ['wb97x3c', 'wb97x-3c']:
+
core.set_global_option('BASIS', 'vdzp')
+
+
# the FIRST scf call
+
if cast:
+
# Cast is a special case
+
base_wfn = core.Wavefunction.build(scf_molecule, core.get_global_option('BASIS'))
+
core.print_out("\n ---------------------------------------------------------\n")
+
if banner:
+
core.print_out(" " + banner.center(58))
+
if cast:
+
core.print_out(" " + "SCF Castup computation".center(58))
+
ref_wfn = scf_wavefunction_factory(name, base_wfn, core.get_option('SCF', 'REFERENCE'), **kwargs)
+
+
# Compute additive correction: dftd3, mp2d, dftd4, etc.
+
if hasattr(ref_wfn, "_disp_functor"):
+
disp_energy = ref_wfn._disp_functor.compute_energy(ref_wfn.molecule())
+
ref_wfn.set_variable("-D Energy", disp_energy)
+
ref_wfn.compute_energy()
+
+
# cast clean-up
+
if cast:
+
+
# Move files to proper namespace
+
core.IO.change_file_namespace(180, guesspace, namespace)
+
core.IO.set_default_namespace(namespace)
+
+
optstash2.restore()
+
+
# Print the banner for the standard operation
+
core.print_out('\n')
+
p4util.banner(bannername.upper())
+
core.print_out('\n')
+
+
# the SECOND scf call
+
base_wfn = core.Wavefunction.build(scf_molecule, core.get_global_option('BASIS'))
+
if banner:
+
core.print_out("\n ---------------------------------------------------------\n")
+
core.print_out(" " + banner.center(58))
+
+
scf_wfn = scf_wavefunction_factory(name, base_wfn, core.get_option('SCF', 'REFERENCE'), **kwargs)
+
+
# The wfn from_file routine adds the npy suffix if needed, but we add it here so that
+
# we can use os.path.isfile to query whether the file exists before attempting to read
+
read_filename = scf_wfn.get_scratch_filename(180) + '.npy'
+
if ((core.get_option('SCF', 'GUESS') == 'READ') and os.path.isfile(read_filename)):
+
old_wfn = core.Wavefunction.from_file(read_filename)
+
+
Ca_occ = old_wfn.Ca_subset("SO", "OCC")
+
Cb_occ = old_wfn.Cb_subset("SO", "OCC")
+
+
if old_wfn.molecule().schoenflies_symbol() != scf_molecule.schoenflies_symbol():
+
raise ValidationError("Cannot compute projection of different symmetries.")
+
+
if old_wfn.basisset().name() == scf_wfn.basisset().name():
+
core.print_out(f" Reading orbitals from file {read_filename}, no projection.\n\n")
+
scf_wfn.guess_Ca(Ca_occ)
+
scf_wfn.guess_Cb(Cb_occ)
+
else:
+
core.print_out(f" Reading orbitals from file {read_filename}, projecting to new basis.\n\n")
+
core.print_out(" Computing basis projection from %s to %s\n\n" % (old_wfn.basisset().name(), scf_wfn.basisset().name()))
+
+
pCa = scf_wfn.basis_projection(Ca_occ, old_wfn.nalphapi(), old_wfn.basisset(), scf_wfn.basisset())
+
pCb = scf_wfn.basis_projection(Cb_occ, old_wfn.nbetapi(), old_wfn.basisset(), scf_wfn.basisset())
+
scf_wfn.guess_Ca(pCa)
+
scf_wfn.guess_Cb(pCb)
+
+
# Strip off headers to only get R, RO, U, CU
+
old_ref = old_wfn.name().replace("KS", "").replace("HF", "")
+
new_ref = scf_wfn.name().replace("KS", "").replace("HF", "")
+
if old_ref != new_ref:
+
scf_wfn.reset_occ_ = True
+
+
elif (core.get_option('SCF', 'GUESS') == 'READ') and not os.path.isfile(read_filename):
+
core.print_out(f"\n !!! Unable to find file {read_filename}, defaulting to SAD guess. !!!\n\n")
+
core.set_local_option('SCF', 'GUESS', 'SAD')
+
sad_basis_list = core.BasisSet.build(scf_wfn.molecule(), "ORBITAL",
+
core.get_global_option("BASIS"),
+
puream=scf_wfn.basisset().has_puream(),
+
return_atomlist=True)
+
scf_wfn.set_sad_basissets(sad_basis_list)
+
+
if ("DF" in core.get_option("SCF", "SAD_SCF_TYPE")):
+
sad_fitting_list = core.BasisSet.build(scf_wfn.molecule(), "DF_BASIS_SAD",
+
core.get_option("SCF", "DF_BASIS_SAD"),
+
puream=scf_wfn.basisset().has_puream(),
+
return_atomlist=True)
+
scf_wfn.set_sad_fitting_basissets(sad_fitting_list)
+
+
+
if cast:
+
core.print_out("\n Computing basis projection from %s to %s\n\n" % (ref_wfn.basisset().name(), base_wfn.basisset().name()))
+
if ref_wfn.basisset().n_ecp_core() != base_wfn.basisset().n_ecp_core():
+
raise ValidationError("Projecting from basis ({}) with ({}) ECP electrons to basis ({}) with ({}) ECP electrons will be a disaster. Select a compatible cast-up basis with `set guess_basis YOUR_BASIS_HERE`.".format(
+
ref_wfn.basisset().name(), ref_wfn.basisset().n_ecp_core(), base_wfn.basisset().name(), base_wfn.basisset().n_ecp_core()))
+
+
pCa = ref_wfn.basis_projection(ref_wfn.Ca(), ref_wfn.nalphapi(), ref_wfn.basisset(), scf_wfn.basisset())
+
pCb = ref_wfn.basis_projection(ref_wfn.Cb(), ref_wfn.nbetapi(), ref_wfn.basisset(), scf_wfn.basisset())
+
scf_wfn.guess_Ca(pCa)
+
scf_wfn.guess_Cb(pCb)
+
+
+
# Print basis set info
+
if core.get_option("SCF", "PRINT_BASIS"):
+
scf_wfn.basisset().print_detail_out()
+
+
# Compute additive correction: dftd3, mp2d, dftd4, etc.
+
if hasattr(scf_wfn, "_disp_functor"):
+
disp_energy = scf_wfn._disp_functor.compute_energy(scf_wfn.molecule(), scf_wfn)
+
scf_wfn.set_variable("-D Energy", disp_energy)
+
+
# PCM preparation
+
if core.get_option('SCF', 'PCM'):
+
if core.get_option('SCF', 'PE'):
+
raise ValidationError("""Error: 3-layer QM/MM/PCM not implemented.\n""")
+
pcmsolver_parsed_fname = core.get_local_option('PCM', 'PCMSOLVER_PARSED_FNAME')
+
pcm_print_level = core.get_option('SCF', "PRINT")
+
scf_wfn.set_PCM(core.PCM(pcmsolver_parsed_fname, pcm_print_level, scf_wfn.basisset()))
+
+
# DDPCM preparation
+
if core.get_option('SCF', 'DDX'):
+
if not solvent._have_ddx:
+
raise ModuleNotFoundError('Python module ddx not found. Solve by installing it: `conda install -c conda-forge pyddx` or `pip install pyddx`')
+
ddx_options = solvent.ddx.get_ddx_options(scf_molecule)
+
scf_wfn.ddx = solvent.ddx.DdxInterface(
+
molecule=scf_molecule, options=ddx_options,
+
basisset=scf_wfn.basisset()
+
)
+
scf_wfn.ddx_state = None
+
+
# PE preparation
+
if core.get_option('SCF', 'PE'):
+
if not solvent._have_pe:
+
raise ModuleNotFoundError('Python module cppe not found. Solve by installing it: `conda install -c conda-forge cppe`')
+
# PE needs information about molecule and basis set
+
pol_embed_options = solvent.pol_embed.get_pe_options()
+
core.print_out(f""" Using potential file
+
{pol_embed_options["potfile"]}
+
for Polarizable Embedding calculation.\n""")
+
scf_wfn.pe_state = solvent.pol_embed.CppeInterface(
+
molecule=scf_molecule, options=pol_embed_options,
+
basisset=scf_wfn.basisset()
+
)
+
+
e_scf = scf_wfn.compute_energy()
+
for obj in [core, scf_wfn]:
+
# set_variable("SCF TOTAL ENERGY") # P::e SCF
+
for pv in ["SCF TOTAL ENERGY", "CURRENT ENERGY", "CURRENT REFERENCE ENERGY"]:
+
obj.set_variable(pv, e_scf)
+
+
# We always would like to print a little property information
+
if kwargs.get('scf_do_properties', True):
+
oeprop = core.OEProp(scf_wfn)
+
oeprop.set_title("SCF")
+
+
# Figure our properties, if empty do dipole
+
props = [x.upper() for x in core.get_option("SCF", "SCF_PROPERTIES")]
+
if "DIPOLE" not in props:
+
props.append("DIPOLE")
+
+
proc_util.oeprop_validator(props)
+
for x in props:
+
oeprop.add(x)
+
+
# Populate free-atom volumes
+
# if we're doing MBIS
+
if 'MBIS_VOLUME_RATIOS' in props:
+
p4util.free_atom_volumes(scf_wfn)
+
+
# Compute properties
+
oeprop.compute()
+
for obj in [core, scf_wfn]:
+
with warnings.catch_warnings():
+
warnings.simplefilter("ignore")
+
obj.set_variable("CURRENT DIPOLE", obj.variable("SCF DIPOLE")) # P::e SCF
+
+
# Write out MO's
+
if core.get_option("SCF", "PRINT_MOS"):
+
mowriter = core.MOWriter(scf_wfn)
+
mowriter.write()
+
+
# Write out a molden file
+
if core.get_option("SCF", "MOLDEN_WRITE"):
+
filename = core.get_writer_file_prefix(scf_molecule.name()) + ".molden"
+
dovirt = bool(core.get_option("SCF", "MOLDEN_WITH_VIRTUAL"))
+
+
occa = scf_wfn.occupation_a()
+
occb = scf_wfn.occupation_a()
+
+
mw = core.MoldenWriter(scf_wfn)
+
mw.write(filename, scf_wfn.Ca(), scf_wfn.Cb(), scf_wfn.epsilon_a(),
+
scf_wfn.epsilon_b(), scf_wfn.occupation_a(),
+
scf_wfn.occupation_b(), dovirt)
+
+
# Write checkpoint file (orbitals and basis); Can be disabled, e.g., for findif displacements
+
if write_checkpoint_file and isinstance(_chkfile, str):
+
filename = kwargs['write_orbitals']
+
scf_wfn.to_file(filename)
+
# core.set_local_option("SCF", "ORBITALS_WRITE", filename)
+
elif write_checkpoint_file:
+
filename = scf_wfn.get_scratch_filename(180)
+
scf_wfn.to_file(filename)
+
extras.register_numpy_file(filename) # retain with -m (messy) option
+
+
if do_timer:
+
core.tstop()
+
+
optstash.restore()
+
+
if (not use_c1) or (scf_molecule.schoenflies_symbol() == 'c1'):
+
return scf_wfn
+
else:
+
# C1 copy quietly
+
c1_optstash = p4util.OptionsState(['PRINT'])
+
core.set_global_option("PRINT", 0)
+
+
# If we force c1 copy the active molecule
+
scf_molecule.update_geometry()
+
core.print_out("""\n A requested method does not make use of molecular symmetry: """
+
"""further calculations in C1 point group.\n\n""")
+
c1_molecule = scf_molecule.clone()
+
c1_molecule.reset_point_group('c1')
+
c1_molecule.fix_orientation(True)
+
c1_molecule.fix_com(True)
+
c1_molecule.update_geometry()
+
c1_basis = core.BasisSet.build(c1_molecule, "ORBITAL", core.get_global_option('BASIS'), quiet=True)
+
tmp = scf_wfn.c1_deep_copy(c1_basis)
+
if not scf_wfn.has_variable("-D ENERGY"):
+
tmp.del_variable("-D ENERGY")
+
c1_jkbasis = core.BasisSet.build(c1_molecule, "DF_BASIS_SCF",
+
core.get_global_option("DF_BASIS_SCF"),
+
"JKFIT", core.get_global_option('BASIS'), quiet=True)
+
tmp.set_basisset("DF_BASIS_SCF", c1_jkbasis)
+
c1_optstash.restore()
+
return tmp
+ 
+ 
+ 
+