def banner(text, type=1, width=35, strNotOutfile=False): """Function to print *text* to output file in a banner of minimum width *width* and minimum three-line height for *type* = 1 or one-line height for *type* = 2. If *strNotOutfile* is True, function returns string rather than printing it to output file. """ lines = text.split('\n') max_length = 0 for line in lines: if (len(line) > max_length): max_length = len(line) max_length = max([width, max_length]) null = '' if type == 1: banner = ' //' + null.center(max_length, '>') + '//\n' for line in lines: banner += ' //' + line.center(max_length) + '//\n' banner += ' //' + null.center(max_length, '<') + '//\n' if type == 2: banner = '' for line in lines: banner += (' ' + line + ' ').center(max_length, '=') if strNotOutfile: return banner else: core.print_out(banner)
def compute_hessian(self, molecule): """ #magic (if magic was easy) """ optstash = p4util.OptionsState(['PRINT']) core.set_global_option('PRINT', 0) core.print_out("\n\n Analytical Dispersion Hessians are not supported by dftd3 or gcp.\n") core.print_out(" Computing the Hessian through finite difference of gradients.\n\n") # Setup the molecule molclone = molecule.clone() molclone.reinterpret_coordentry(False) molclone.fix_orientation(True) molclone.fix_com(True) # Record undisplaced symmetry for projection of diplaced point groups core.set_parent_symmetry(molecule.schoenflies_symbol()) gradients = [] for geom in core.fd_geoms_freq_1(molecule, -1): molclone.set_geometry(geom) molclone.update_geometry() gradients.append(self.compute_gradient(molclone)) H = core.fd_freq_1(molecule, gradients, -1) # H.print_out() optstash.restore() return H
def compare_vectors(expected, computed, digits, label): """Function to compare two vectors. Prints :py:func:`util.success` when elements of vector *computed* match elements of vector *expected* to number of *digits*. Performs a system exit on failure to match symmetry structure, dimension, or element values. Used in input files in the test suite. """ if (expected.nirrep() != computed.nirrep()): message = ("\t%s has %d irreps, but %s has %d\n." % (expected.name(), expected.nirrep(), computed.name(), computed.nirrep())) raise TestComparisonError(message) nirreps = expected.nirrep() for irrep in range(nirreps): if (expected.dim(irrep) != computed.dim(irrep)): message = ("\tThe reference has %d entries in irrep %d, but the computed vector has %d\n." % (expected.dim(irrep), irrep, computed.dim(irrep))) raise TestComparisonError(message) dim = expected.dim(irrep) failed = 0 for entry in range(dim): if (abs(expected.get(irrep, entry) - computed.get(irrep, entry)) > 10**(-digits)): failed = 1 break if (failed): core.print_out("The computed vector\n") computed.print_out() core.print_out("The reference vector\n") expected.print_out() message = ("\t%s: computed value (%s) does not match (%s)." % (label, computed.get(irrep, entry), expected.get(irrep, entry))) raise TestComparisonError(message) success(label) return True
def geometry(geom, name="default"): """Function to create a molecule object of name *name* from the geometry in string *geom*. Permitted for user use but deprecated in driver in favor of explicit molecule-passing. Comments within the string are filtered. """ molrec = qcel.molparse.from_string( geom, enable_qm=True, missing_enabled_return_qm='minimal', enable_efp=True, missing_enabled_return_efp='none') molecule = core.Molecule.from_dict(molrec['qm']) molecule.set_name(name) if 'efp' in molrec: try: import pylibefp except ImportError as e: # py36 ModuleNotFoundError raise ImportError("""Install pylibefp to use EFP functionality. `conda install pylibefp -c psi4` Or build with `-DENABLE_libefp=ON`""") from e #print('Using pylibefp: {} (version {})'.format(pylibefp.__file__, pylibefp.__version__)) efpobj = pylibefp.from_dict(molrec['efp']) # pylibefp.core.efp rides along on molecule molecule.EFP = efpobj # Attempt to go ahead and construct the molecule try: molecule.update_geometry() except: core.print_out("Molecule: geometry: Molecule is not complete, please use 'update_geometry'\n" " once all variables are set.\n") activate(molecule) return molecule
def _diag_print_info(solver_name, info, verbose=1): """Print a message to the output file at each iteration""" if verbose < 1: # no printing return elif verbose == 1: # print iter maxde max|R| conv/restart flags = [] if info['collapse']: flags.append("Restart") if info['done']: flags.append("Converged") core.print_out(" {name} iter {ni:3d}: {m_de:-11.5e} {m_r:12.5e} {flgs}\n".format( name=solver_name, ni=info['count'], m_de=np.max(info['delta_val']), m_r=np.max(info['res_norm']), flgs="/".join(flags))) else: # print iter / ssdim folowed by de/|R| for each root core.print_out(" {name} iter {ni:3d}: {nv:4d} guess vectors\n".format( name=solver_name, ni=info['count'], nv=info['nvec'])) for i, (e, de, rn) in enumerate(zip(info['val'], info['delta_val'], info['res_norm'])): core.print_out(" {nr:2d}: {s:} {e:-11.5f} {de:-11.5e} {rn:12.5e}\n".format( nr=i + 1, s=" " * (len(solver_name) - 8), e=e, de=de, rn=rn)) if info['done']: core.print_out(" Solver Converged! all roots\n\n") elif info['collapse']: core.print_out(" Subspace limits exceeded restarting\n\n")
def __init__(self, circs): if circs[5] == '': msg = """{0}: Method '{1}' with {2} '{3}' and REFERENCE '{4}' not available{5}""".format(*circs) else: msg = """{0}: Method '{1}' with {2} '{3}' and REFERENCE '{4}' not directable to QC_MODULE '{5}'""".format(*circs) PsiException.__init__(self, msg) self.message = msg core.print_out('\nPsiException: %s\n\n' % (msg))
def pybuild_basis(mol, key=None, target=None, fitrole='ORBITAL', other=None, puream=-1, return_atomlist=False, quiet=False): if key == 'ORBITAL': key = 'BASIS' 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 # Figure out what exactly was meant by 'target'. resolved_target = _resolve_target(key, target) # resolved_target needs to be either a string or function for pyconstuct. # if a string, they search for a gbs file with that name. # if a function, it needs to apply a basis to each atom. bs, basisdict = qcdb.BasisSet.pyconstruct(mol.to_dict(), key, resolved_target, fitrole, other, return_dict=True, return_atomlist=return_atomlist) if return_atomlist: atom_basis_list = [] for atbs in basisdict: atommol = core.Molecule.from_dict(atbs['molecule']) lmbs = core.BasisSet.construct_from_pydict(atommol, atbs, puream) atom_basis_list.append(lmbs) return atom_basis_list if ((sys.version_info < (3, 0) and isinstance(resolved_target, basestring)) or (sys.version_info >= (3, 0) and isinstance(resolved_target, str))): basisdict['name'] = basisdict['name'].split('/')[-1].replace('.gbs', '') if callable(resolved_target): basisdict['name'] = resolved_target.__name__.replace('basisspec_psi4_yo__', '').upper() if not quiet: core.print_out(basisdict['message']) if 'ECP' in basisdict['message']: core.print_out(' !!! WARNING: ECP capability is in beta. Please check occupations closely. !!!\n\n') if basisdict['key'] is None: basisdict['key'] = 'BASIS' psibasis = core.BasisSet.construct_from_pydict(mol, basisdict, puream) return psibasis
def __init__(self, option): mods_str = ", ".join([m for m in PastureRequiredError.pasture_required_modules[option]]) msg = PastureRequiredError.msg_tmpl.format(opt=option, modlist=mods_str) PsiException.__init__(self, msg) module_cmake_args = " ".join( ["-DENABLE_{}=ON".format(module) for module in PastureRequiredError.pasture_required_modules[option]]) msg += PastureRequiredError.install_instructions.format(module_args=module_cmake_args) self.message = '\nPsiException: {}\n\n'.format(msg) core.print_out(self.message)
def success(label): """Function to print a '*label*...PASSED' line to screen. Used by :py:func:`util.compare_values` family when functions pass. """ msg = '\t{0:.<66}PASSED'.format(label) print(msg) sys.stdout.flush() core.print_out(msg + '\n')
def extract_sowreap_from_output(sowout, quantity, sownum, linkage, allvital=False, label='electronic energy'): """Function to examine file *sowout* from a sow/reap distributed job for formatted line with electronic energy information about index *sownum* to be used for construction of *quantity* computations as directed by master input file with *linkage* kwarg. When file *sowout* is missing or incomplete files, function will either return zero (*allvital* is ``False``) or terminate (*allvital* is ``True``) since some sow/reap procedures can produce meaningful results (database) from an incomplete set of sown files, while others cannot (gradient, hessian). """ warnings.warn( "Using `psi4.driver.p4util.extract_sowreap_from_output` is deprecated, and in 1.4 it will stop working\n", category=FutureWarning, stacklevel=2) E = 0.0 try: freagent = open('%s.out' % (sowout), 'r') except IOError: if allvital: raise ValidationError('Aborting upon output file \'%s.out\' not found.\n' % (sowout)) else: ValidationError('Aborting upon output file \'%s.out\' not found.\n' % (sowout)) return 0.0 else: while True: line = freagent.readline() if not line: if E == 0.0: if allvital: raise ValidationError( 'Aborting upon output file \'%s.out\' has no %s RESULT line.\n' % (sowout, quantity)) else: ValidationError( 'Aborting upon output file \'%s.out\' has no %s RESULT line.\n' % (sowout, quantity)) break s = line.strip().split(None, 10) if (len(s) != 0) and (s[0:3] == [quantity, 'RESULT:', 'computation']): if int(s[3]) != linkage: raise ValidationError( 'Output file \'%s.out\' has linkage %s incompatible with master.in linkage %s.' % (sowout, str(s[3]), str(linkage))) if s[6] != str(sownum + 1): raise ValidationError( 'Output file \'%s.out\' has nominal affiliation %s incompatible with item %s.' % (sowout, s[6], str(sownum + 1))) if label == 'electronic energy' and s[8:10] == ['electronic', 'energy']: E = float(s[10]) core.print_out('%s RESULT: electronic energy = %20.12f\n' % (quantity, E)) if label == 'electronic gradient' and s[8:10] == ['electronic', 'gradient']: E = ast.literal_eval(s[-1]) core.print_out('%s RESULT: electronic gradient = %r\n' % (quantity, E)) freagent.close() return E
def append_geoms(indices, steps): """Given a list of indices and a list of steps to displace each, append the corresponding geometry to the list.""" new_geom = ref_geom.clone().np # Next, to make this salc/magnitude composite. index_steps = zip(indices, steps) label = _displace_cart(mol, new_geom, data["salc_list"], index_steps, data["disp_size"]) if data["print_lvl"] > 2: core.print_out("\nDisplacement '{}'\n{}\n".format(label, np.array_str(new_geom, **array_format))) findifrec["displacements"][label] = {"geometry": new_geom.ravel().tolist()}
def _print_output(complete_dict, output): core.print_out('\n ==> Response Properties <==\n') for i, prop in enumerate(complete_dict): if not 'User' in prop['name']: core.print_out('\n => {} <=\n\n'.format(prop['name'])) directions = prop['printout_labels'] var_name = prop['name'].upper().replace("IES", "Y") _print_matrix(directions, output[i], var_name)
def prepare_sapt_molecule(sapt_dimer, sapt_basis): """ Prepares a dimer molecule for a SAPT computations. Returns the dimer, monomerA, and monomerB. """ # Shifting to C1 so we need to copy the active molecule sapt_dimer = sapt_dimer.clone() if sapt_dimer.schoenflies_symbol() != 'c1': core.print_out(' SAPT does not make use of molecular symmetry, further calculations in C1 point group.\n') sapt_dimer.reset_point_group('c1') sapt_dimer.fix_orientation(True) sapt_dimer.fix_com(True) sapt_dimer.update_geometry() else: sapt_dimer.update_geometry() # make sure since mol from wfn, kwarg, or P::e sapt_dimer.fix_orientation(True) sapt_dimer.fix_com(True) nfrag = sapt_dimer.nfragments() if nfrag == 3: # Midbond case if sapt_basis == 'monomer': raise ValidationError("SAPT basis cannot both be monomer centered and have midbond functions.") midbond = sapt_dimer.extract_subsets(3) ztotal = 0 for n in range(midbond.natom()): ztotal += midbond.Z(n) if ztotal > 0: raise ValidationError("SAPT third monomr must be a midbond function (all ghosts).") ghosts = ([2, 3], [1, 3]) elif nfrag == 2: # Classical dimer case ghosts = (2, 1) else: raise ValidationError('SAPT requires active molecule to have 2 fragments, not %s.' % (nfrag)) if sapt_basis == 'dimer': monomerA = sapt_dimer.extract_subsets(1, ghosts[0]) monomerA.set_name('monomerA') monomerB = sapt_dimer.extract_subsets(2, ghosts[1]) monomerB.set_name('monomerB') elif sapt_basis == 'monomer': monomerA = sapt_dimer.extract_subsets(1) monomerA.set_name('monomerA') monomerB = sapt_dimer.extract_subsets(2) monomerB.set_name('monomerB') else: raise ValidationError("SAPT basis %s not recognized" % sapt_basis) return (sapt_dimer, monomerA, monomerB)
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 _print_array(name, arr, verbose): """print an subspace quantity (numpy array) to the output file Parameters ---------- name : str The name to print above the array arr : :py:class:`np.ndarray` The array to print verbose : int The amount of information to print. Only prints for verbose > 2 """ if verbose > 2: core.print_out("\n\n{}:\n{}\n".format(name, str(arr)))
def df_mp2_fisapt_dispersion(wfn, primary, auxiliary, cache, do_print=True): if do_print: core.print_out("\n ==> E20 Dispersion (MP2) <== \n\n") # Build object df_matrix_keys = ["Cocc_A", "Cvir_A", "Cocc_B", "Cvir_B"] df_mfisapt_keys = ["Caocc0A", "Cvir0A", "Caocc0B", "Cvir0B"] matrix_cache = {fkey: cache[ckey] for ckey, fkey in zip(df_matrix_keys, df_mfisapt_keys)} other_keys = ["S", "D_A", "P_A", "V_A", "J_A", "K_A", "D_B", "P_B", "V_B", "J_B", "K_B", "K_O"] for key in other_keys: matrix_cache[key] = cache[key] # matrix_cache["K_O"] = matrix_cache["K_O"].transpose() df_vector_keys = ["eps_occ_A", "eps_vir_A", "eps_occ_B", "eps_vir_B"] df_vfisapt_keys = ["eps_aocc0A", "eps_vir0A", "eps_aocc0B", "eps_vir0B"] vector_cache = {fkey: cache[ckey] for ckey, fkey in zip(df_vector_keys, df_vfisapt_keys)} wfn.set_basisset("DF_BASIS_SAPT", auxiliary) fisapt = core.FISAPT(wfn) # Compute! fisapt.disp(matrix_cache, vector_cache, False) scalars = fisapt.scalars() core.print_out("\n") core.print_out(print_sapt_var("Disp20 (MP2)", scalars["Disp20"], short=True) + "\n") core.print_out(print_sapt_var("Exch-Disp20,u", scalars["Exch-Disp20"], short=True) + "\n") ret = {} ret["Exch-Disp20,u"] = scalars["Exch-Disp20"] ret["Disp20,u"] = scalars["Disp20"] return ret
def df_mp2_sapt_dispersion(dimer_wfn, wfn_A, wfn_B, primary_basis, aux_basis, cache, do_print=True): if do_print: core.print_out("\n ==> E20 Dispersion (MP2) <== \n\n") optstash = p4util.OptionsState(['SAPT', 'SAPT0_E10'], ['SAPT', 'SAPT0_E20IND'], ['SAPT', 'SAPT0_E20DISP'], ['SAPT', 'SAPT_QUIET']) core.set_local_option("SAPT", "SAPT0_E10", False) core.set_local_option("SAPT", "SAPT0_E20IND", False) core.set_local_option("SAPT", "SAPT0_E20DISP", True) core.set_local_option("SAPT", "SAPT_QUIET", True) if core.get_option('SCF', 'REFERENCE') == 'RHF': core.IO.change_file_namespace(psif.PSIF_SAPT_MONOMERA, 'monomerA', 'dimer') core.IO.change_file_namespace(psif.PSIF_SAPT_MONOMERB, 'monomerB', 'dimer') core.IO.set_default_namespace('dimer') dimer_wfn.set_basisset("DF_BASIS_SAPT", aux_basis) dimer_wfn.set_basisset("DF_BASIS_ELST", aux_basis) e_sapt = core.sapt(dimer_wfn, wfn_A, wfn_B) optstash.restore() svars = dimer_wfn.variables() core.print_out("\n") core.print_out(print_sapt_var("Disp20 (MP2)", svars["E DISP20"], short=True) + "\n") core.print_out(print_sapt_var("Exch-Disp20,u", svars["E EXCH-DISP20"], short=True) + "\n") ret = {} ret["Exch-Disp20,u"] = svars["E EXCH-DISP20"] ret["Disp20,u"] = svars["E DISP20"] return ret
def scf_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 _process_hessian_symmetry_block(H_block, B_block, massweighter, irrep, print_lvl): """Perform post-construction processing for a symmetry block of the Hessian. Statements need to be printed, and the Hessian must be made orthogonal. Parameters --------- H_block : ndarray A block of the Hessian for an irrep, in mass-weighted salcs. Dimensions # cdsalcs by # cdsalcs. B_block : ndarray A block of the B matrix for an irrep, which transforms CdSalcs to Cartesians. Dimensions # cdsalcs by # cartesians. massweighter : ndarray The mass associated with each atomic coordinate. Dimension # cartesians. Due to x, y, z, values appear in groups of three. irrep : str A string identifying the irrep H_block and B_block are of. print_lvl : int The level of printing information requested by the user. Returns ------- H_block : ndarray H_block, but made into an orthogonal array. """ # Symmetrize our Hessian block. # The symmetric structure is lost due to errors in the computation H_block = (H_block + H_block.T) / 2.0 if print_lvl >= 3: core.print_out("\n Force Constants for irrep {} in mass-weighted, ".format(irrep)) core.print_out("symmetry-adapted cartesian coordinates.\n") core.print_out("\n{}\n".format(np.array_str(H_block, **array_format))) evals, evects = np.linalg.eigh(H_block) # Get our eigenvalues and eigenvectors in descending order. idx = evals.argsort()[::-1] evals = evals[idx] evects = evects[:, idx] normal_irr = np.dot((B_block * massweighter).T, evects) if print_lvl >= 2: core.print_out("\n Normal coordinates (non-mass-weighted) for irrep {}:\n".format(irrep)) core.print_out("\n{}\n".format(np.array_str(normal_irr, **array_format))) return H_block
def _print_matrix(descriptors, content, title): length = len(descriptors) matrix_header = ' ' + ' {:^10}' * length + '\n' core.print_out(matrix_header.format(*descriptors)) core.print_out(' -----' + ' ----------' * length + '\n') for i, desc in enumerate(descriptors): core.print_out(' {:^5}'.format(desc)) for j in range(length): core.print_out(' {:>10.5f}'.format(content[i, j])) # Set the name var_name = title + " " + descriptors[i] + descriptors[j] core.set_variable(var_name, content[i, j]) core.print_out('\n')
def _psi4_true_raise_handler(passfail, label, message, return_message=False, quiet=False): """Handle comparison result by printing to screen, printing to Psi output file, raising TestComparisonError, and (incidently) returning.""" width = 66 if passfail: if not quiet: core.print_out(f' {label:.<{width}}PASSED\n') print(f' {label:.<{width}}PASSED') sys.stdout.flush() else: core.print_out(f' {label:.<{width}}FAILED') print(f' {label:.<{width}}FAILED') sys.stdout.flush() raise TestComparisonError(message) return passfail
def print_out(self): """Format dispersion parameters of `self` for output file.""" text = [] text.append(" => %s: Empirical Dispersion <=" % (self.fctldash.upper() if self.fctldash.upper() else 'Custom')) text.append('') text.append(self.description) text.append(self.dashlevel_citation.rstrip()) if self.dashparams_citation: text.append(" Parametrisation from:{}".format(self.dashparams_citation.rstrip())) text.append('') for op in self.ordered_params: text.append(" %6s = %14.6f" % (op, self.dashparams[op])) text.append('\n') core.print_out('\n'.join(text))
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 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 _diag_print_converged(solver_name, stats, vals, verbose=1, **kwargs): """Print a message to the output file when the solver is converged.""" if verbose < 1: # no printing return if verbose >= 1: # print values summary + number of iterations + # of "big" product evals core.print_out(" {} converged in {} iterations\n".format(solver_name, stats[-1]['count'])) core.print_out(" Root # eigenvalue\n") for (i, vi) in enumerate(vals): core.print_out(" {:^6} {:20.12f}\n".format(i + 1, vi)) max_nvec = max(istat['nvec'] for istat in stats) core.print_out(" Computed a total of {} Large products\n\n".format(stats[-1]['product_count']))
def _print_nbody_energy(energy_body_dict, header): core.print_out("""\n ==> N-Body: %s energies <==\n\n""" % header) core.print_out(""" n-Body Total Energy [Eh] I.E. [kcal/mol] Delta [kcal/mol]\n""") previous_e = energy_body_dict[1] nbody_range = list(energy_body_dict) nbody_range.sort() for n in nbody_range: delta_e = (energy_body_dict[n] - previous_e) delta_e_kcal = delta_e * constants.hartree2kcalmol int_e_kcal = (energy_body_dict[n] - energy_body_dict[1]) * constants.hartree2kcalmol core.print_out(""" %4s %20.12f %20.12f %20.12f\n""" % (n, energy_body_dict[n], int_e_kcal, delta_e_kcal)) previous_e = energy_body_dict[n] core.print_out("\n")
def _print_header(complete_dict, n_user): core.print_out('\n\n ---------------------------------------------------------\n' ' {:^57}\n'.format('CPSCF Linear Response Solver') + ' {:^57}\n'.format('by Marvin Lechner and Daniel Smith') + ' ---------------------------------------------------------\n') core.print_out('\n ==> Requested Responses <==\n\n') for prop in complete_dict: if 'User' not in prop['name']: core.print_out(' {}\n'.format(prop['name'])) if n_user != 0: core.print_out(' {} user-supplied vector(s)\n'.format(n_user))
def auto_fragments(**kwargs): r"""Detects fragments in unfragmented molecule using BFS algorithm. Currently only used for the WebMO implementation of SAPT. Parameters ---------- molecule : :ref:`molecule <op_py_molecule>`, optional The target molecule, if not the last molecule defined. seed_atoms : list, optional List of lists of atoms (0-indexed) belonging to independent fragments. Useful to prompt algorithm or to define intramolecular fragments through border atoms. Example: `[[1, 0], [2]]` Returns ------- :py:class:`~psi4.core.Molecule` |w--w| fragmented molecule in Cartesian, fixed-geom (no variable values), no dummy-atom format. Examples -------- >>> # [1] prepare unfragmented (and non-adjacent-atom) HHFF into (HF)_2 molecule ready for SAPT >>> molecule mol {\nH 0.0 0.0 0.0\nH 2.0 0.0 0.0\nF 0.0 1.0 0.0\nF 2.0 1.0 0.0\n} >>> print mol.nfragments() # 1 >>> fragmol = auto_fragments() >>> print fragmol.nfragments() # 2 """ # Make sure the molecule the user provided is the active one molecule = kwargs.pop('molecule', core.get_active_molecule()) seeds = kwargs.pop('seed_atoms', None) molecule.update_geometry() molname = molecule.name() frag, bmol = molecule.BFS(seed_atoms=seeds, return_molecule=True) bmol.set_name(molname) bmol.print_cluster() core.print_out(""" Exiting auto_fragments\n""") return bmol
def compute_hessian(self, molecule): """Compute dispersion Hessian based on engine, dispersion level, and parameters in `self`. Uses finite difference, as no dispersion engine has analytic second derivatives. Parameters ---------- molecule : psi4.core.Molecule System for which to compute empirical dispersion correction. Returns ------- psi4.core.Matrix (3*nat, 3*nat) dispersion Hessian [Eh/a0/a0]. """ optstash = p4util.OptionsState(['PRINT']) core.set_global_option('PRINT', 0) core.print_out("\n\n Analytical Dispersion Hessians are not supported by dftd3 or gcp.\n") core.print_out(" Computing the Hessian through finite difference of gradients.\n\n") # Setup the molecule molclone = molecule.clone() molclone.reinterpret_coordentry(False) molclone.fix_orientation(True) molclone.fix_com(True) # Record undisplaced symmetry for projection of diplaced point groups core.set_parent_symmetry(molecule.schoenflies_symbol()) findif_meta_dict = driver_findif.hessian_from_gradient_geometries(molclone, -1) for displacement in findif_meta_dict["displacements"].values(): geom_array = np.reshape(displacement["geometry"], (-1, 3)) molclone.set_geometry(core.Matrix.from_array(geom_array)) molclone.update_geometry() displacement["gradient"] = self.compute_gradient(molclone).np.ravel().tolist() H = driver_findif.compute_hessian_from_gradients(findif_meta_dict, -1) optstash.restore() return core.Matrix.from_array(H)
def mcscf_solver(ref_wfn): # Build CIWavefunction core.prepare_options_for_module("DETCI") ciwfn = core.CIWavefunction(ref_wfn) ciwfn.set_module("detci") # Hush a lot of CI output ciwfn.set_print(0) # Begin with a normal two-step step_type = 'Initial CI' total_step = core.Matrix("Total step", ciwfn.get_dimension('OA'), ciwfn.get_dimension('AV')) start_orbs = ciwfn.get_orbitals("ROT").clone() ciwfn.set_orbitals("ROT", start_orbs) # Grab da options mcscf_orb_grad_conv = core.get_option("DETCI", "MCSCF_R_CONVERGENCE") mcscf_e_conv = core.get_option("DETCI", "MCSCF_E_CONVERGENCE") mcscf_max_macroiteration = core.get_option("DETCI", "MCSCF_MAXITER") mcscf_type = core.get_option("DETCI", "MCSCF_TYPE") mcscf_d_file = core.get_option("DETCI", "CI_FILE_START") + 3 mcscf_nroots = core.get_option("DETCI", "NUM_ROOTS") mcscf_wavefunction_type = core.get_option("DETCI", "WFN") mcscf_ndet = ciwfn.ndet() mcscf_nuclear_energy = ciwfn.molecule().nuclear_repulsion_energy() mcscf_steplimit = core.get_option("DETCI", "MCSCF_MAX_ROT") mcscf_rotate = core.get_option("DETCI", "MCSCF_ROTATE") # DIIS info mcscf_diis_start = core.get_option("DETCI", "MCSCF_DIIS_START") mcscf_diis_freq = core.get_option("DETCI", "MCSCF_DIIS_FREQ") mcscf_diis_error_type = core.get_option("DETCI", "MCSCF_DIIS_ERROR_TYPE") mcscf_diis_max_vecs = core.get_option("DETCI", "MCSCF_DIIS_MAX_VECS") # One-step info mcscf_target_conv_type = core.get_option("DETCI", "MCSCF_ALGORITHM") mcscf_so_start_grad = core.get_option("DETCI", "MCSCF_SO_START_GRAD") mcscf_so_start_e = core.get_option("DETCI", "MCSCF_SO_START_E") mcscf_current_step_type = 'Initial CI' # Start with SCF energy and other params scf_energy = ciwfn.variable("HF TOTAL ENERGY") eold = scf_energy norb_iter = 1 converged = False ah_step = False qc_step = False approx_integrals_only = True # Fake info to start with the initial diagonalization ediff = 1.e-4 orb_grad_rms = 1.e-3 # Grab needed objects diis_obj = solvers.DIIS(mcscf_diis_max_vecs) mcscf_obj = ciwfn.mcscf_object() # Execute the rotate command for rot in mcscf_rotate: if len(rot) != 4: raise p4util.PsiException( "Each element of the MCSCF rotate command requires 4 arguements (irrep, orb1, orb2, theta)." ) irrep, orb1, orb2, theta = rot if irrep > ciwfn.Ca().nirrep(): raise p4util.PsiException( "MCSCF_ROTATE: Expression %s irrep number is larger than the number of irreps" % (str(rot))) if max(orb1, orb2) > ciwfn.Ca().coldim()[irrep]: raise p4util.PsiException( "MCSCF_ROTATE: Expression %s orbital number exceeds number of orbitals in irrep" % (str(rot))) theta = np.deg2rad(theta) x = ciwfn.Ca().nph[irrep][:, orb1].copy() y = ciwfn.Ca().nph[irrep][:, orb2].copy() xp = np.cos(theta) * x - np.sin(theta) * y yp = np.sin(theta) * x + np.cos(theta) * y ciwfn.Ca().nph[irrep][:, orb1] = xp ciwfn.Ca().nph[irrep][:, orb2] = yp # Limited RAS functionality if core.get_local_option( "DETCI", "WFN") == "RASSCF" and mcscf_target_conv_type != "TS": core.print_out( "\n Warning! Only the TS algorithm for RASSCF wavefunction is currently supported.\n" ) core.print_out(" Switching to the TS algorithm.\n\n") mcscf_target_conv_type = "TS" # Print out headers if mcscf_type == "CONV": mtype = " @MCSCF" core.print_out("\n ==> Starting MCSCF iterations <==\n\n") core.print_out( " Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n" ) elif mcscf_type == "DF": mtype = " @DF-MCSCF" core.print_out("\n ==> Starting DF-MCSCF iterations <==\n\n") core.print_out( " Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n" ) else: mtype = " @AO-MCSCF" core.print_out("\n ==> Starting AO-MCSCF iterations <==\n\n") core.print_out( " Iter Total Energy Delta E Orb RMS CI RMS NCI NORB\n" ) # Iterate ! for mcscf_iter in range(1, mcscf_max_macroiteration + 1): # Transform integrals, diagonalize H ciwfn.transform_mcscf_integrals(approx_integrals_only) nci_iter = ciwfn.diag_h(abs(ediff) * 1.e-2, orb_grad_rms * 1.e-3) # After the first diag we need to switch to READ ciwfn.set_ci_guess("DFILE") ciwfn.form_opdm() ciwfn.form_tpdm() ci_grad_rms = ciwfn.variable("DETCI AVG DVEC NORM") # Update MCSCF object Cocc = ciwfn.get_orbitals("DOCC") Cact = ciwfn.get_orbitals("ACT") Cvir = ciwfn.get_orbitals("VIR") opdm = ciwfn.get_opdm(-1, -1, "SUM", False) tpdm = ciwfn.get_tpdm("SUM", True) mcscf_obj.update(Cocc, Cact, Cvir, opdm, tpdm) current_energy = ciwfn.variable("MCSCF TOTAL ENERGY") ciwfn.reset_ci_H0block() orb_grad_rms = mcscf_obj.gradient_rms() ediff = current_energy - eold # Print iterations print_iteration(mtype, mcscf_iter, current_energy, ediff, orb_grad_rms, ci_grad_rms, nci_iter, norb_iter, mcscf_current_step_type) eold = current_energy if mcscf_current_step_type == 'Initial CI': mcscf_current_step_type = 'TS' # Check convergence if (orb_grad_rms < mcscf_orb_grad_conv) and (abs(ediff) < abs(mcscf_e_conv)) and\ (mcscf_iter > 3) and not qc_step: core.print_out("\n %s has converged!\n\n" % mtype) converged = True break # Which orbital convergence are we doing? if ah_step: converged, norb_iter, step = ah_iteration(mcscf_obj, print_micro=False) norb_iter += 1 if converged: mcscf_current_step_type = 'AH' else: core.print_out( " !Warning. Augmented Hessian did not converge. Taking an approx step.\n" ) step = mcscf_obj.approx_solve() mcscf_current_step_type = 'TS, AH failure' else: step = mcscf_obj.approx_solve() step_type = 'TS' maxstep = step.absmax() if maxstep > mcscf_steplimit: core.print_out( ' Warning! Maxstep = %4.2f, scaling to %4.2f\n' % (maxstep, mcscf_steplimit)) step.scale(mcscf_steplimit / maxstep) xstep = total_step.clone() total_step.add(step) # Do or add DIIS if (mcscf_iter >= mcscf_diis_start) and ("TS" in mcscf_current_step_type): # Figure out DIIS error vector if mcscf_diis_error_type == "GRAD": error = core.triplet(ciwfn.get_orbitals("OA"), mcscf_obj.gradient(), ciwfn.get_orbitals("AV"), False, False, True) else: error = step diis_obj.add(total_step, error) if not (mcscf_iter % mcscf_diis_freq): total_step = diis_obj.extrapolate() mcscf_current_step_type = 'TS, DIIS' # Build the rotation by continuous updates if mcscf_iter == 1: totalU = mcscf_obj.form_rotation_matrix(total_step) else: xstep.axpy(-1.0, total_step) xstep.scale(-1.0) Ustep = mcscf_obj.form_rotation_matrix(xstep) totalU = core.doublet(totalU, Ustep, False, False) # Build the rotation directly (not recommended) # orbs_mat = mcscf_obj.Ck(start_orbs, total_step) # Finally rotate and set orbitals orbs_mat = core.doublet(start_orbs, totalU, False, False) ciwfn.set_orbitals("ROT", orbs_mat) # Figure out what the next step should be if (orb_grad_rms < mcscf_so_start_grad) and (abs(ediff) < abs(mcscf_so_start_e)) and\ (mcscf_iter >= 2): if mcscf_target_conv_type == 'AH': approx_integrals_only = False ah_step = True elif mcscf_target_conv_type == 'OS': approx_integrals_only = False mcscf_current_step_type = 'OS, Prep' break else: continue #raise p4util.PsiException("") # If we converged do not do onestep if converged or (mcscf_target_conv_type != 'OS'): one_step_iters = [] # If we are not converged load in Dvec and build iters array else: one_step_iters = range(mcscf_iter + 1, mcscf_max_macroiteration + 1) dvec = ciwfn.D_vector() dvec.init_io_files(True) dvec.read(0, 0) dvec.symnormalize(1.0, 0) ci_grad = ciwfn.new_civector(1, mcscf_d_file + 1, True, True) ci_grad.set_nvec(1) ci_grad.init_io_files(True) # Loop for onestep for mcscf_iter in one_step_iters: # Transform integrals and update the MCSCF object ciwfn.transform_mcscf_integrals(ciwfn.H(), False) ciwfn.form_opdm() ciwfn.form_tpdm() # Update MCSCF object Cocc = ciwfn.get_orbitals("DOCC") Cact = ciwfn.get_orbitals("ACT") Cvir = ciwfn.get_orbitals("VIR") opdm = ciwfn.get_opdm(-1, -1, "SUM", False) tpdm = ciwfn.get_tpdm("SUM", True) mcscf_obj.update(Cocc, Cact, Cvir, opdm, tpdm) orb_grad_rms = mcscf_obj.gradient_rms() # Warning! Does not work for SA-MCSCF current_energy = mcscf_obj.current_total_energy() current_energy += mcscf_nuclear_energy ciwfn.set_variable("CI ROOT %d TOTAL ENERGY" % 1, current_energy) ciwfn.set_variable("CURRENT ENERGY", current_energy) ciwfn.set_energy(current_energy) docc_energy = mcscf_obj.current_docc_energy() ci_energy = mcscf_obj.current_ci_energy() # Compute CI gradient ciwfn.sigma(dvec, ci_grad, 0, 0) ci_grad.scale(2.0, 0) ci_grad.axpy(-2.0 * ci_energy, dvec, 0, 0) ci_grad_rms = ci_grad.norm(0) orb_grad_rms = mcscf_obj.gradient().rms() ediff = current_energy - eold print_iteration(mtype, mcscf_iter, current_energy, ediff, orb_grad_rms, ci_grad_rms, nci_iter, norb_iter, mcscf_current_step_type) mcscf_current_step_type = 'OS' eold = current_energy if (orb_grad_rms < mcscf_orb_grad_conv) and (abs(ediff) < abs(mcscf_e_conv)): core.print_out("\n %s has converged!\n\n" % mtype) converged = True break # Take a step converged, norb_iter, nci_iter, step = qc_iteration( dvec, ci_grad, ciwfn, mcscf_obj) # Rotate integrals to new frame total_step.add(step) orbs_mat = mcscf_obj.Ck(ciwfn.get_orbitals("ROT"), step) ciwfn.set_orbitals("ROT", orbs_mat) core.print_out(mtype + " Final Energy: %20.15f\n" % current_energy) # Die if we did not converge if (not converged): if core.get_global_option("DIE_IF_NOT_CONVERGED"): raise p4util.PsiException("MCSCF: Iterations did not converge!") else: core.print_out("\nWarning! MCSCF iterations did not converge!\n\n") # Print out CI vector information if mcscf_target_conv_type == 'OS': dvec.close_io_files() ci_grad.close_io_files() # For orbital invariant methods we transform the orbitals to the natural or # semicanonical basis. Frozen doubly occupied and virtual orbitals are not # modified. if core.get_option("DETCI", "WFN") == "CASSCF": # Do we diagonalize the opdm? if core.get_option("DETCI", "NAT_ORBS"): ciwfn.ci_nat_orbs() else: ciwfn.semicanonical_orbs() # Retransform intragrals and update CI coeffs., OPDM, and TPDM ciwfn.transform_mcscf_integrals(approx_integrals_only) ciwfn.set_print(1) ciwfn.set_ci_guess("H0_BLOCK") nci_iter = ciwfn.diag_h(mcscf_e_conv, mcscf_e_conv**0.5) ciwfn.form_opdm() ciwfn.form_tpdm() proc_util.print_ci_results(ciwfn, "MCSCF", scf_energy, current_energy, print_opdm_no=True) # Set final energy ciwfn.set_variable("CURRENT ENERGY", ciwfn.variable("MCSCF TOTAL ENERGY")) ciwfn.set_energy(ciwfn.variable("MCSCF TOTAL ENERGY")) # What do we need to cleanup? if core.get_option("DETCI", "MCSCF_CI_CLEANUP"): ciwfn.cleanup_ci() if core.get_option("DETCI", "MCSCF_DPD_CLEANUP"): ciwfn.cleanup_dpd() del diis_obj del mcscf_obj return ciwfn
def print_iteration(mtype, niter, energy, de, orb_rms, ci_rms, nci, norb, stype): core.print_out( "%s %2d: % 18.12f % 1.4e %1.2e %1.2e %3d %3d %s\n" % (mtype, niter, energy, de, orb_rms, ci_rms, nci, norb, stype))
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 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') # does the JK algorithm use severe screening approximations for early SCF iterations? early_screening = self.jk().get_early_screening() # has early_screening changed from True to False? early_screening_disabled = False # 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() # Two-electron contribution to Fock matrix from self.jk() core.timer_on("HF: Form G") self.form_G() core.timer_off("HF: Form G") # Check if special J/K construction algorithms were used incfock_performed = hasattr( self.jk(), "do_incfock_iter") and self.jk().do_incfock_iter() linK_performed = hasattr(self.jk(), "do_linK") and self.jk().do_linK() 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") if linK_performed: status.append("LINK") # 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 # this is the first iteration after early screening was turned off if early_screening_disabled: break # Call any postiteration callbacks if not ((self.iteration_ == 0) and self.sad_) and _converged( Ediff, Dnorm, e_conv=e_conv, d_conv=d_conv): if early_screening: # we've reached convergence with early screning enabled; disable it on the JK object early_screening = False self.jk().set_early_screening(early_screening) # make note of the change to early screening; next SCF iteration will be the last early_screening_disabled = True # clear any cached matrices associated with incremental fock construction # the change in the screening spoils the linearity in the density matrix if hasattr(self.jk(), 'clear_D_prev'): self.jk().clear_D_prev() core.print_out( " Energy and wave function converged with early screening.\n" ) core.print_out( " Performing final iteration with tighter screening.\n\n") else: break if self.iteration_ >= core.get_option('SCF', 'MAXITER'): raise SCFConvergenceError("""SCF iterations""", self.iteration_, self, Ediff, Dnorm)
def callback(output): core.print_out(f"{output}\n")
def _pybuild_basis(mol, key=None, target=None, fitrole='ORBITAL', other=None, puream=-1, return_atomlist=False, quiet=False): if key == 'ORBITAL': key = 'BASIS' 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 # Figure out what exactly was meant by 'target'. resolved_target = _resolve_target(key, target) # resolved_target needs to be either a string or function for pyconstuct. # if a string, they search for a gbs file with that name. # if a function, it needs to apply a basis to each atom. bs, basisdict = qcdb.BasisSet.pyconstruct(mol.to_dict(), key, resolved_target, fitrole, other, return_dict=True, return_atomlist=return_atomlist) if return_atomlist: atom_basis_list = [] for atbs in basisdict: atommol = core.Molecule.from_dict(atbs['molecule']) lmbs = core.BasisSet.construct_from_pydict(atommol, atbs, puream) atom_basis_list.append(lmbs) return atom_basis_list if isinstance(resolved_target, str): basisdict['name'] = basisdict['name'].split('/')[-1].replace( '.gbs', '') if callable(resolved_target): basisdict['name'] = resolved_target.__name__.replace( 'basisspec_psi4_yo__', '').upper() if not quiet: core.print_out(basisdict['message']) if 'ECP' in basisdict['message']: core.print_out( ' !!! WARNING: ECP capability is in beta. Please check occupations closely. !!!\n\n' ) if basisdict['key'] is None: basisdict['key'] = 'BASIS' psibasis = core.BasisSet.construct_from_pydict(mol, basisdict, puream) return psibasis
def run_sapt_dft(name, **kwargs): optstash = p4util.OptionsState(['SCF', 'SCF_TYPE'], ['SCF', 'REFERENCE'], ['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 = {} 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") core.set_global_option("SAVE_JK", True) 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") core.set_global_option("SAVE_JK", False) # 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"), 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() 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_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(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_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.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") core.set_global_option("DFT_GRAC_SHIFT", 0.0) # Write out header scf_alg = core.get_option("SCF", "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 extract_sowreap_from_output(sowout, quantity, sownum, linkage, allvital=False, label='electronic energy'): """Function to examine file *sowout* from a sow/reap distributed job for formatted line with electronic energy information about index *sownum* to be used for construction of *quantity* computations as directed by master input file with *linkage* kwarg. When file *sowout* is missing or incomplete files, function will either return zero (*allvital* is ``False``) or terminate (*allvital* is ``True``) since some sow/reap procedures can produce meaningful results (database) from an incomplete set of sown files, while others cannot (gradient, hessian). """ warnings.warn( "Using `psi4.driver.p4util.extract_sowreap_from_output` is deprecated, and in 1.4 it will stop working\n", category=FutureWarning, stacklevel=2) E = 0.0 try: freagent = open('%s.out' % (sowout), 'r') except IOError: if allvital: raise ValidationError( 'Aborting upon output file \'%s.out\' not found.\n' % (sowout)) else: return 0.0 else: while True: line = freagent.readline() if not line: if E == 0.0: raise ValidationError( 'Aborting upon output file \'%s.out\' has no %s RESULT line.\n' % (sowout, quantity)) break s = line.strip().split(None, 10) if (len(s) != 0) and (s[0:3] == [quantity, 'RESULT:', 'computation']): if int(s[3]) != linkage: raise ValidationError( 'Output file \'%s.out\' has linkage %s incompatible with master.in linkage %s.' % (sowout, str(s[3]), str(linkage))) if s[6] != str(sownum + 1): raise ValidationError( 'Output file \'%s.out\' has nominal affiliation %s incompatible with item %s.' % (sowout, s[6], str(sownum + 1))) if label == 'electronic energy' and s[8:10] == [ 'electronic', 'energy' ]: E = float(s[10]) core.print_out('%s RESULT: electronic energy = %20.12f\n' % (quantity, E)) if label == 'electronic gradient' and s[8:10] == [ 'electronic', 'gradient' ]: E = ast.literal_eval(s[-1]) core.print_out('%s RESULT: electronic gradient = %r\n' % (quantity, E)) freagent.close() return E
def ah_iteration(mcscf_obj, tol=1e-3, max_iter=15, lindep=1e-14, print_micro=True): """ Solve the generalized eigenvalue problem: | 0, g.T | | 1/l | = | 1/l | | g, H/l | | X | = e | X | Where g is the gradient, H is the orbital Hessian, X is our orbital update step, and l is the eigenvalue. In some ways this is the subspace reduction of the full MCSCF Hessian where the CC part has been solved exactly. When this occurs the OC and CO elements collapse to the above and the CC Hessian becomes diagonally dominant. We can solve this through Davidson iterations where we condition the edges. It's the Pulay equations all over again, just iterative. Watch out for lambdas that are zero. Looking for the lambda that is ~1. """ # Unpack information orb_grad = mcscf_obj.gradient() precon = mcscf_obj.H_approx_diag() approx_step = mcscf_obj.approx_solve() orb_grad_ssq = orb_grad.sum_of_squares() # Gears min_lambda = 0.3 converged = False warning_neg = False warning_mult = False fullG = np.zeros((max_iter + 2, max_iter + 2)) fullS = np.zeros((max_iter + 2, max_iter + 2)) fullS[np.diag_indices_from(fullS)] = 1 guesses = [] sigma_list = [] guesses.append(approx_step) sigma_list.append(mcscf_obj.compute_Hk(approx_step)) if print_micro: core.print_out( "\n Eigenvalue Rel dE dX \n" ) # Run Davidson look for lambda ~ 1 old_val = 0 for microi in range(1, max_iter + 1): # Gradient fullG[0, microi] = guesses[-1].vector_dot(orb_grad) for i in range(microi): fullG[i + 1, microi] = guesses[-1].vector_dot(sigma_list[i]) fullS[i + 1, microi] = guesses[-1].vector_dot(guesses[i]) fullG[microi] = fullG[:, microi] fullS[microi] = fullS[:, microi] wlast = old_val # Slice out relevant S and G S = fullS[:microi + 1, :microi + 1] G = fullG[:microi + 1, :microi + 1] # Solve Gv = lSv v, L = np.linalg.eigh(S) mask = v > (np.min(np.abs(v)) * 1.e-10) invL = L[:, mask] * (v[mask]**-0.5) # Solve in S basis, rotate back evals, evecs = np.linalg.eigh(np.dot(invL.T, G).dot(invL)) vectors = np.dot(invL, evecs) # Figure out the right root to follow if np.sum(np.abs(vectors[0]) > min_lambda) == 0: raise PsiException("Augmented Hessian: Could not find the correct root!\n"\ "Try starting AH when the MCSCF wavefunction is more converged.") if np.sum(np.abs(vectors[0]) > min_lambda) > 1 and not warning_mult: core.print_out( " Warning! Multiple eigenvectors found to follow. Following closest to \lambda = 1.\n" ) warning_mult = True idx = (np.abs(1 - np.abs(vectors[0]))).argmin() lam = abs(vectors[0, idx]) subspace_vec = vectors[1:, idx] # Negative roots should go away? if idx > 0 and evals[idx] < -5.0e-6 and not warning_neg: core.print_out( ' Warning! AH might follow negative eigenvalues!\n') warning_neg = True diff_val = evals[idx] - old_val old_val = evals[idx] new_guess = guesses[0].clone() new_guess.zero() for num, c in enumerate(subspace_vec / lam): new_guess.axpy(c, guesses[num]) # Build estimated sigma vector new_dx = sigma_list[0].clone() new_dx.zero() for num, c in enumerate(subspace_vec): new_dx.axpy(c, sigma_list[num]) # Consider restraints new_dx.axpy(lam, orb_grad) new_dx.axpy(old_val * lam, new_guess) norm_dx = (new_dx.sum_of_squares() / orb_grad_ssq)**0.5 if print_micro: core.print_out( " AH microiter %2d % 18.12e % 6.4e % 6.4e\n" % (microi, evals[idx], diff_val / evals[idx], norm_dx)) if abs(old_val - wlast) < tol and norm_dx < (tol**0.5): converged = True break # Apply preconditioner tmp = precon.clone() val = tmp.clone() val.set(evals[idx]) tmp.subtract(val) new_dx.apply_denominator(tmp) guesses.append(new_dx) sigma_list.append(mcscf_obj.compute_Hk(new_dx)) if print_micro and converged: core.print_out("\n") # core.print_out(" AH converged! \n\n") #if not converged: # core.print_out(" !Warning. Augmented Hessian did not converge.\n") new_guess.scale(-1.0) return converged, microi, new_guess
def run_qcschema(input_data, clean=True): outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".qcschema_tmpout") core.set_output_file(outfile, False) print_header() start_time = datetime.datetime.now() try: input_model = qcng.util.model_wrapper(input_data, qcel.models.AtomicInput) # Echo the infile on the outfile core.print_out("\n ==> Input QCSchema <==\n") core.print_out( "\n--------------------------------------------------------------------------\n" ) core.print_out(pp.pformat(json.loads(input_model.json()))) core.print_out( "\n--------------------------------------------------------------------------\n" ) keep_wfn = input_model.protocols.wavefunction != 'none' # qcschema should be copied ret_data = run_json_qcschema(input_model.dict(), clean, False, keep_wfn=keep_wfn) ret_data["provenance"] = { "creator": "Psi4", "version": __version__, "routine": "psi4.schema_runner.run_qcschema" } exit_printing(start_time=start_time, success=True) ret = qcel.models.AtomicResult(**ret_data, stdout=_read_output(outfile)) except Exception as exc: if not isinstance(input_data, dict): input_data = input_data.dict() input_data = input_data.copy() input_data["stdout"] = _read_output(outfile) ret = qcel.models.FailedOperation( input_data=input_data, success=False, error={ 'error_type': type(exc).__name__, 'error_message': ''.join(traceback.format_exception(*sys.exc_info())), }) atexit.register(_quiet_remove, outfile) return ret
def run_sf_sapt(name, **kwargs): optstash = p4util.OptionsState(['SCF_TYPE'], ['SCF', 'REFERENCE'], ['SCF', 'DFT_GRAC_SHIFT'], ['SCF', 'SAVE_JK']) core.tstart() # Alter default algorithm if not core.has_global_option_changed('SCF_TYPE'): core.set_global_option('SCF_TYPE', 'DF') core.prepare_options_for_module("SAPT") # Get the molecule of interest ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: sapt_dimer = kwargs.pop('molecule', core.get_active_molecule()) else: core.print_out('Warning! SAPT argument "ref_wfn" is only able to use molecule information.') sapt_dimer = ref_wfn.molecule() sapt_dimer, monomerA, monomerB = proc_util.prepare_sapt_molecule(sapt_dimer, "dimer") # Print out the title and some information core.print_out("\n") core.print_out(" ---------------------------------------------------------\n") core.print_out(" " + "Spin-Flip SAPT Procedure".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith and Konrad Patkowski".center(58) + "\n") core.print_out(" ---------------------------------------------------------\n") core.print_out("\n") core.print_out(" ==> Algorithm <==\n\n") core.print_out(" JK Algorithm %12s\n" % core.get_option("SCF", "SCF_TYPE")) core.print_out("\n") core.print_out(" Required computations:\n") core.print_out(" HF (Monomer A)\n") core.print_out(" HF (Monomer B)\n") core.print_out("\n") if (core.get_option('SCF', 'REFERENCE') != 'ROHF'): raise ValidationError('Spin-Flip SAPT currently only supports restricted open-shell references.') # Run the two monomer computations core.IO.set_default_namespace('dimer') data = {} if (core.get_global_option('SCF_TYPE') == 'DF'): core.set_global_option('DF_INTS_IO', 'SAVE') # Compute dimer wavefunction wfn_A = scf_helper("SCF", molecule=monomerA, banner="SF-SAPT: HF Monomer A", **kwargs) core.set_global_option("SAVE_JK", True) wfn_B = scf_helper("SCF", molecule=monomerB, banner="SF-SAPT: HF Monomer B", **kwargs) sapt_jk = wfn_B.jk() core.set_global_option("SAVE_JK", False) core.print_out("\n") core.print_out(" ---------------------------------------------------------\n") core.print_out(" " + "Spin-Flip SAPT Exchange and Electrostatics".center(58) + "\n") core.print_out("\n") core.print_out(" " + "by Daniel G. A. Smith and Konrad Patkowski".center(58) + "\n") core.print_out(" ---------------------------------------------------------\n") core.print_out("\n") sf_data = sapt_sf_terms.compute_sapt_sf(sapt_dimer, sapt_jk, wfn_A, wfn_B) # Print the results core.print_out(" Spin-Flip SAPT Results\n") core.print_out(" " + "-" * 103 + "\n") for key, value in sf_data.items(): value = sf_data[key] print_vals = (key, value * 1000, value * constants.hartree2kcalmol, value * constants.hartree2kJmol) string = " %-26s % 15.8f [mEh] % 15.8f [kcal/mol] % 15.8f [kJ/mol]\n" % print_vals core.print_out(string) core.print_out(" " + "-" * 103 + "\n\n") dimer_wfn = core.Wavefunction.build(sapt_dimer, wfn_A.basisset()) # Set variables psivar_tanslator = { "Elst10": "SAPT ELST ENERGY", "Exch10(S^2) [diagonal]": "SAPT EXCH10(S^2),DIAGONAL ENERGY", "Exch10(S^2) [off-diagonal]": "SAPT EXCH10(S^2),OFF-DIAGONAL ENERGY", "Exch10(S^2) [highspin]": "SAPT EXCH10(S^2),HIGHSPIN ENERGY", } for k, v in sf_data.items(): psi_k = psivar_tanslator[k] dimer_wfn.set_variable(psi_k, v) core.set_variable(psi_k, v) # Copy over highspin core.set_variable("SAPT EXCH ENERGY", sf_data["Exch10(S^2) [highspin]"]) core.tstop() return dimer_wfn
def scf_print_preiterations(self, small=False): # small version does not print Nalpha,Nbeta,Ndocc,Nsocc, e.g. for SAD guess where they are not # available ct = self.molecule().point_group().char_table() if not small: core.print_out( " -------------------------------------------------------\n") core.print_out( " Irrep Nso Nmo Nalpha Nbeta Ndocc Nsocc\n") core.print_out( " -------------------------------------------------------\n") for h in range(self.nirrep()): core.print_out( f" {ct.gamma(h).symbol():<3s} {self.nsopi()[h]:6d} {self.nmopi()[h]:6d} {self.nalphapi()[h]:6d} {self.nbetapi()[h]:6d} {self.doccpi()[h]:6d} {self.soccpi()[h]:6d}\n" ) core.print_out( " -------------------------------------------------------\n") core.print_out( f" Total {self.nso():6d} {self.nmo():6d} {self.nalpha():6d} {self.nbeta():6d} {self.nbeta():6d} {self.nalpha() - self.nbeta():6d}\n" ) core.print_out( " -------------------------------------------------------\n\n") else: core.print_out(" -------------------------\n") core.print_out(" Irrep Nso Nmo \n") core.print_out(" -------------------------\n") for h in range(self.nirrep()): core.print_out( f" {ct.gamma(h).symbol():<3s} {self.nsopi()[h]:6d} {self.nmopi()[h]:6d} \n" ) core.print_out(" -------------------------\n") core.print_out(f" Total {self.nso():6d} {self.nmo():6d}\n") core.print_out(" -------------------------\n\n")
def sapt_dft_header(sapt_dft_functional="unknown", mon_a_shift=None, mon_b_shift=None, do_delta_hf="N/A", jk_alg="N/A"): # 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)) if mon_a_shift: core.print_out(" Monomer A GRAC Shift %12.6f\n" % mon_a_shift) if mon_b_shift: core.print_out(" Monomer B GRAC Shift %12.6f\n" % mon_b_shift) core.print_out(" Delta HF %12s\n" % do_delta_hf) core.print_out(" JK Algorithm %12s\n" % jk_alg)
def test_ccl_functional(functional, ccl_functional): check = True if (not os.path.exists('data_pt_%s.html' % (ccl_functional))): os.system('wget ftp://ftp.dl.ac.uk/qcg/dft_library/data_pt_%s.html' % ccl_functional) fh = open('data_pt_%s.html' % (ccl_functional)) lines = fh.readlines() fh.close() points = [] point = {} rho_line = re.compile( r'^\s*rhoa=\s*(-?\d+\.\d+E[+-]\d+)\s*rhob=\s*(-?\d+\.\d+E[+-]\d+)\s*sigmaaa=\s*(-?\d+\.\d+E[+-]\d+)\s*sigmaab=\s*(-?\d+\.\d+E[+-]\d+)\s*sigmabb=\s*(-?\d+\.\d+E[+-]\d+)\s*' ) val_line = re.compile(r'^\s*(\w*)\s*=\s*(-?\d+\.\d+E[+-]\d+)') aliases = { 'zk': 'v', 'vrhoa': 'v_rho_a', 'vrhob': 'v_rho_b', 'vsigmaaa': 'v_gamma_aa', 'vsigmaab': 'v_gamma_ab', 'vsigmabb': 'v_gamma_bb', 'v2rhoa2': 'v_rho_a_rho_a', 'v2rhoab': 'v_rho_a_rho_b', 'v2rhob2': 'v_rho_b_rho_b', 'v2rhoasigmaaa': 'v_rho_a_gamma_aa', 'v2rhoasigmaab': 'v_rho_a_gamma_ab', 'v2rhoasigmabb': 'v_rho_a_gamma_bb', 'v2rhobsigmaaa': 'v_rho_b_gamma_aa', 'v2rhobsigmaab': 'v_rho_b_gamma_ab', 'v2rhobsigmabb': 'v_rho_b_gamma_bb', 'v2sigmaaa2': 'v_gamma_aa_gamma_aa', 'v2sigmaaaab': 'v_gamma_aa_gamma_ab', 'v2sigmaaabb': 'v_gamma_aa_gamma_bb', 'v2sigmaab2': 'v_gamma_ab_gamma_ab', 'v2sigmaabbb': 'v_gamma_ab_gamma_bb', 'v2sigmabb2': 'v_gamma_bb_gamma_bb', } for line in lines: mobj = re.match(rho_line, line) if (mobj): if len(point): points.append(point) point = {} point['rho_a'] = float(mobj.group(1)) point['rho_b'] = float(mobj.group(2)) point['gamma_aa'] = float(mobj.group(3)) point['gamma_ab'] = float(mobj.group(4)) point['gamma_bb'] = float(mobj.group(5)) continue mobj = re.match(val_line, line) if (mobj): point[aliases[mobj.group(1)]] = float(mobj.group(2)) points.append(point) N = len(points) rho_a = core.Vector(N) rho_b = core.Vector(N) gamma_aa = core.Vector(N) gamma_ab = core.Vector(N) gamma_bb = core.Vector(N) tau_a = core.Vector(N) tau_b = core.Vector(N) index = 0 for point in points: rho_a[index] = point['rho_a'] rho_b[index] = point['rho_b'] gamma_aa[index] = point['gamma_aa'] gamma_ab[index] = point['gamma_ab'] gamma_bb[index] = point['gamma_bb'] index = index + 1 super = build_superfunctional(functional, N, 1) super.test_functional(rho_a, rho_b, gamma_aa, gamma_ab, gamma_bb, tau_a, tau_b) v = super.value('V') v_rho_a = super.value('V_RHO_A') v_rho_b = super.value('V_RHO_B') v_gamma_aa = super.value('V_GAMMA_AA') v_gamma_ab = super.value('V_GAMMA_AB') v_gamma_bb = super.value('V_GAMMA_BB') if not v_gamma_aa: v_gamma_aa = tau_a v_gamma_ab = tau_a v_gamma_bb = tau_a tasks = [ 'v', 'v_rho_a', 'v_rho_b', 'v_gamma_aa', 'v_gamma_ab', 'v_gamma_bb' ] mapping = { 'v': v, 'v_rho_a': v_rho_a, 'v_rho_b': v_rho_b, 'v_gamma_aa': v_gamma_aa, 'v_gamma_ab': v_gamma_ab, 'v_gamma_bb': v_gamma_bb, } super.print_detail(3) index = 0 for point in points: core.print_out( 'rho_a= %11.3E, rho_b= %11.3E, gamma_aa= %11.3E, gamma_ab= %11.3E, gamma_bb= %11.3E\n' % (rho_a[index], rho_b[index], gamma_aa[index], gamma_ab[index], gamma_bb[index])) for task in tasks: v_ref = point[task] v_obs = mapping[task][index] delta = v_obs - v_ref if (v_ref == 0.0): epsilon = 0.0 else: epsilon = abs(delta / v_ref) if (epsilon < 1.0E-11): passed = 'PASSED' else: passed = 'FAILED' check = False core.print_out('\t%-15s %24.16E %24.16E %24.16E %24.16E %6s\n' % (task, v_ref, v_obs, delta, epsilon, passed)) index = index + 1 core.print_out('\n') return check
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 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_xtpl_helgaker_2(functionname: str, zLO: int, valueLO: Extrapolatable, zHI: int, valueHI: Extrapolatable, verbose: int = 1, alpha: Optional[float] = None) -> Extrapolatable: r"""Extrapolation scheme using exponential form for reference energies with two adjacent zeta-level bases. Used by :py:func:`~psi4.cbs`. Parameters ---------- functionname Name of the CBS component (e.g., 'HF') used in summary printing. zLO Zeta number of the smaller basis set in 2-point extrapolation. valueLO Energy, gradient, or Hessian value at the smaller basis set in 2-point extrapolation. zHI Zeta number of the larger basis set in 2-point extrapolation. Must be `zLO + 1`. valueHI Energy, gradient, or Hessian value at the larger basis set in 2-point extrapolation. verbose Controls volume of printing. alpha Fitted 2-point parameter. Overrides the default :math:`\alpha = 1.63` Returns ------- float or ndarray Eponymous function applied to input zetas and values; type from `valueLO`. Notes ----- The extrapolation is calculated according to [1]_: :math:`E_{total}^X = E_{total}^{\infty} + \beta e^{-\alpha X}, \alpha = 1.63` References ---------- .. [1] Halkier, Helgaker, Jorgensen, Klopper, & Olsen, Chem. Phys. Lett. 302 (1999) 437-446, DOI: 10.1016/S0009-2614(99)00179-7 Examples -------- >>> # [1] Hartree-Fock extrapolation >>> psi4.energy('cbs', scf_wfn='hf', scf_basis='cc-pV[DT]Z', scf_scheme='scf_xtpl_helgaker_2') """ if type(valueLO) != type(valueHI): raise ValidationError( f"scf_xtpl_helgaker_2: Inputs must be of the same datatype! ({type(valueLO)}, {type(valueHI)})" ) if alpha is None: alpha = 1.63 beta_division = 1 / (math.exp(-1 * alpha * zLO) * (math.exp(-1 * alpha) - 1)) beta_mult = math.exp(-1 * alpha * zHI) if isinstance(valueLO, float): beta = (valueHI - valueLO) * beta_division value = valueHI - beta * beta_mult if verbose: # Output string with extrapolation parameters cbsscheme = '' cbsscheme += """\n ==> Helgaker 2-point exponential SCF extrapolation for method: %s <==\n\n""" % ( functionname.upper()) cbsscheme += """ LO-zeta (%s) Energy: % 16.12f\n""" % ( str(zLO), valueLO) cbsscheme += """ HI-zeta (%s) Energy: % 16.12f\n""" % ( str(zHI), valueHI) cbsscheme += """ Alpha (exponent) Value: % 16.12f\n""" % ( alpha) cbsscheme += """ Beta (coefficient) Value: % 16.12f\n\n""" % ( beta) name_str = "%s/(%s,%s)" % (functionname.upper(), _zeta_val2sym[zLO].upper(), _zeta_val2sym[zHI].upper()) cbsscheme += """ @Extrapolated """ cbsscheme += name_str + ':' cbsscheme += " " * (18 - len(name_str)) cbsscheme += """% 16.12f\n\n""" % value core.print_out(cbsscheme) return value elif isinstance(valueLO, (core.Matrix, core.Vector)): valueLO = valueLO.to_array() valueHI = valueHI.to_array() beta = (valueHI - valueLO) * beta_division value = valueHI - beta * beta_mult if verbose > 2: cbsscheme = f"""\n ==> Helgaker 2-point exponential SCF extrapolation for method: {functionname.upper()} <==\n""" cbsscheme += f"""\n LO-zeta ({zLO}) Data\n""" cbsscheme += nppp(valueLO) cbsscheme += f"""\n HI-zeta ({zHI}) Data\n""" cbsscheme += nppp(valueHI) cbsscheme += f"""\n Alpha (exponent) Value: {alpha:16.8f}""" cbsscheme += f"""\n Beta Data\n""" cbsscheme += nppp(beta) cbsscheme += f"""\n Extrapolated Data\n""" cbsscheme += nppp(value) cbsscheme += "\n" core.print_out(cbsscheme) value = core.Matrix.from_array(value) return value else: raise ValidationError( f"scf_xtpl_helgaker_2: datatype is not recognized '{type(valueLO)}'." )
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]) # 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 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 (name.lower() == 'hf'): raise ValidationError("SCF: HF with -NL not implemented") nl_tuple = core.get_option("SCF", "NL_DISPERSION_PARAMETERS") sup[0].set_vv10_b(nl_tuple[0]) if len(nl_tuple) > 1: sup[0].set_vv10_c(nl_tuple[1]) if len(nl_tuple) > 2: raise ValidationError( "too many entries in NL_DISPERSION_PARAMETERS for DFT-NL") elif core.has_option_changed("SCF", "DFT_VV10_B"): if (name.lower() == 'hf'): raise ValidationError("SCF: HF with -NL not implemented") vv10_b = core.get_option("SCF", "DFT_VV10_B") sup[0].set_vv10_b(vv10_b) if core.has_option_changed("SCF", "DFT_VV10_C"): vv10_c = core.get_option("SCF", "DFT_VV10_C") sup[0].set_vv10_c(vv10_c) if (abs(sup[0].vv10_c() - 0.0) <= 1e-8): core.print_out( "SCF: VV10_C not specified. Using default (C=0.0093)!") sup[0].set_vv10_c(0.0093) if (core.has_option_changed("SCF", "NL_DISPERSION_PARAMETERS") and core.has_option_changed("SCF", "DFT_VV10_B")): raise ValidationError( "SCF: Decide between NL_DISPERSION_PARAMETERS and DFT_VV10_B !!") # Check SCF_TYPE if sup[0].is_x_lrc() and (core.get_global_option("SCF_TYPE") not in ["DIRECT", "DF", "OUT_OF_CORE", "PK"]): raise ValidationError( "SCF: SCF_TYPE (%s) not supported for range-separated functionals, plese use SCF_TYPE = 'DF' to automatically select the correct JK build." % core.get_global_option("SCF_TYPE")) if (core.get_global_option('INTEGRAL_PACKAGE') == 'ERD') and (sup[0].is_x_lrc()): raise ValidationError( 'INTEGRAL_PACKAGE ERD does not play nicely with LRC DFT functionals, so stopping.' ) sup[0].set_lock(True) return sup
def scf_xtpl_truhlar_2(functionname: str, zLO: int, valueLO: Extrapolatable, zHI: int, valueHI: Extrapolatable, verbose: int = 1, alpha: Optional[float] = None) -> Extrapolatable: r"""Extrapolation scheme using power form for reference energies with two adjacent zeta-level bases. Used by :py:func:`~psi4.cbs`. Parameters ---------- functionname Name of the CBS component (e.g., 'HF') used in summary printing. zLO Zeta number of the smaller basis set in 2-point extrapolation. valueLO Energy, gradient, or Hessian value at the smaller basis set in 2-point extrapolation. zHI Zeta number of the larger basis set in 2-point extrapolation Must be `zLO + 1`. valueHI Energy, gradient, or Hessian value at the larger basis set in 2-point extrapolation. verbose Controls volume of printing. alpha Overrides the default :math:`\alpha = 3.4` Returns ------- float or ndarray Eponymous function applied to input zetas and values; type from `valueLO`. Notes ----- The extrapolation is calculated according to [2]_: :math:`E_{total}^X = E_{total}^{\infty} + \beta X^{-\alpha}, \alpha = 3.4` References ---------- .. [2] Truhlar, Chem. Phys. Lett. 294 (1998) 45-48, DOI: 10.1016/S0009-2614(98)00866-5 """ if type(valueLO) != type(valueHI): raise ValidationError( f"scf_xtpl_truhlar_2: Inputs must be of the same datatype! ({type(valueLO)}, {type(valueHI)})" ) if alpha is None: alpha = 3.40 beta_division = 1 / (zHI**(-1 * alpha) - zLO**(-1 * alpha)) beta_mult = zHI**(-1 * alpha) if isinstance(valueLO, float): beta = (valueHI - valueLO) * beta_division value = valueHI - beta * beta_mult if verbose: # Output string with extrapolation parameters cbsscheme = '' cbsscheme += """\n ==> Truhlar 2-point power form SCF extrapolation for method: %s <==\n\n""" % ( functionname.upper()) cbsscheme += """ LO-zeta (%s) Energy: % 16.12f\n""" % ( str(zLO), valueLO) cbsscheme += """ HI-zeta (%s) Energy: % 16.12f\n""" % ( str(zHI), valueHI) cbsscheme += """ Alpha (exponent) Value: % 16.12f\n""" % ( alpha) cbsscheme += """ Beta (coefficient) Value: % 16.12f\n\n""" % ( beta) name_str = "%s/(%s,%s)" % (functionname.upper(), _zeta_val2sym[zLO].upper(), _zeta_val2sym[zHI].upper()) cbsscheme += """ @Extrapolated """ cbsscheme += name_str + ':' cbsscheme += " " * (18 - len(name_str)) cbsscheme += """% 16.12f\n\n""" % value core.print_out(cbsscheme) return value elif isinstance(valueLO, (core.Matrix, core.Vector)): valueLO = valueLO.to_array() valueHI = valueHI.to_array() beta = (valueHI - valueLO) * beta_division value = valueHI - beta * beta_mult if verbose > 2: cbsscheme = f"""\n ==> Truhlar 2-point power SCF extrapolation for method: {functionname.upper()} <==\n""" cbsscheme += f"""\n LO-zeta ({zLO}) Data\n""" cbsscheme += nppp(valueLO) cbsscheme += f"""\n HI-zeta ({zHI}) Data\n""" cbsscheme += nppp(valueHI) cbsscheme += f"""\n Alpha (exponent) Value: {alpha:16.8f}""" cbsscheme += f"""\n Beta Data\n""" cbsscheme += nppp(beta) cbsscheme += f"""\n Extrapolated Data\n""" cbsscheme += nppp(value) cbsscheme += "\n" core.print_out(cbsscheme) value = core.Matrix.from_array(value) return value else: raise ValidationError( f"scf_xtpl_truhlar_2: datatype is not recognized '{type(valueLO)}'." )
def compute_sapt_sf(dimer, jk, wfn_A, wfn_B, do_print=True): """ Computes Elst and Spin-Flip SAPT0 for ROHF wavefunctions """ if do_print: core.print_out("\n ==> Preparing SF-SAPT Data Cache <== \n\n") jk.print_header() ### Build intermediates # Pull out Wavefunction A quantities ndocc_A = wfn_A.doccpi().sum() nsocc_A = wfn_A.soccpi().sum() Cocc_A = np.asarray(wfn_A.Ca_subset("AO", "OCC")) Ci = Cocc_A[:, :ndocc_A] Ca = Cocc_A[:, ndocc_A:] Pi = np.dot(Ci, Ci.T) Pa = np.dot(Ca, Ca.T) mints = core.MintsHelper(wfn_A.basisset()) V_A = mints.ao_potential() # Pull out Wavefunction B quantities ndocc_B = wfn_B.doccpi().sum() nsocc_B = wfn_B.soccpi().sum() Cocc_B = np.asarray(wfn_B.Ca_subset("AO", "OCC")) Cj = Cocc_B[:, :ndocc_B] Cb = Cocc_B[:, ndocc_B:] Pj = np.dot(Cj, Cj.T) Pb = np.dot(Cb, Cb.T) mints = core.MintsHelper(wfn_B.basisset()) V_B = mints.ao_potential() # Pull out generic quantities S = np.asarray(wfn_A.S()) intermonomer_nuclear_repulsion = dimer.nuclear_repulsion_energy() intermonomer_nuclear_repulsion -= wfn_A.molecule( ).nuclear_repulsion_energy() intermonomer_nuclear_repulsion -= wfn_B.molecule( ).nuclear_repulsion_energy() num_el_A = (2 * ndocc_A + nsocc_A) num_el_B = (2 * ndocc_B + nsocc_B) ### Build JK Terms if do_print: core.print_out("\n ==> Computing required JK matrices <== \n\n") # Writen so that we can reorganize order to save on DF-JK cost. pairs = [("ii", Ci, None, Ci), ("ij", Ci, _chain_dot(Ci.T, S, Cj), Cj), ("jj", Cj, None, Cj), ("aa", Ca, None, Ca), ("aj", Ca, _chain_dot(Ca.T, S, Cj), Cj), ("ib", Ci, _chain_dot(Ci.T, S, Cb), Cb), ("bb", Cb, None, Cb), ("ab", Ca, _chain_dot(Ca.T, S, Cb), Cb)] # Reorganize names = [x[0] for x in pairs] Cleft = [x[1] for x in pairs] rotations = [x[2] for x in pairs] Cright = [x[3] for x in pairs] tmp_J, tmp_K = _sf_compute_JK(jk, Cleft, Cright, rotations) J = {key: val for key, val in zip(names, tmp_J)} K = {key: val for key, val in zip(names, tmp_K)} ### Compute Terms if do_print: core.print_out( "\n ==> Computing Spin-Flip Exchange and Electrostatics <== \n\n") w_A = V_A + 2 * J["ii"] + J["aa"] w_B = V_B + 2 * J["jj"] + J["bb"] h_Aa = V_A + 2 * J["ii"] + J["aa"] - K["ii"] - K["aa"] h_Ab = V_A + 2 * J["ii"] + J["aa"] - K["ii"] h_Ba = V_B + 2 * J["jj"] + J["bb"] - K["jj"] h_Bb = V_B + 2 * J["jj"] + J["bb"] - K["jj"] - K["bb"] ### Build electrostatics # socc/socc term two_el_repulsion = np.vdot(Pa, J["bb"]) attractive_a = np.vdot(V_A, Pb) * nsocc_A / num_el_A attractive_b = np.vdot(V_B, Pa) * nsocc_B / num_el_B nuclear_repulsion = intermonomer_nuclear_repulsion * nsocc_A * nsocc_B / ( num_el_A * num_el_B) elst_abab = two_el_repulsion + attractive_a + attractive_b + nuclear_repulsion # docc/socc term two_el_repulsion = np.vdot(Pi, J["bb"]) attractive_a = np.vdot(V_A, Pb) * ndocc_A / num_el_A attractive_b = np.vdot(V_B, Pi) * nsocc_B / num_el_B nuclear_repulsion = intermonomer_nuclear_repulsion * ndocc_A * nsocc_B / ( num_el_A * num_el_B) elst_ibib = 2 * (two_el_repulsion + attractive_a + attractive_b + nuclear_repulsion) # socc/docc term two_el_repulsion = np.vdot(Pa, J["jj"]) attractive_a = np.vdot(V_A, Pj) * nsocc_A / num_el_A attractive_b = np.vdot(V_B, Pa) * ndocc_B / num_el_B nuclear_repulsion = intermonomer_nuclear_repulsion * nsocc_A * ndocc_B / ( num_el_A * num_el_B) elst_jaja = 2 * (two_el_repulsion + attractive_a + attractive_b + nuclear_repulsion) # docc/docc term two_el_repulsion = np.vdot(Pi, J["jj"]) attractive_a = np.vdot(V_A, Pj) * ndocc_A / num_el_A attractive_b = np.vdot(V_B, Pi) * ndocc_B / num_el_B nuclear_repulsion = intermonomer_nuclear_repulsion * ndocc_A * ndocc_B / ( num_el_A * num_el_B) elst_ijij = 4 * (two_el_repulsion + attractive_a + attractive_b + nuclear_repulsion) elst = elst_abab + elst_ibib + elst_jaja + elst_ijij # print(print_sapt_var("Elst,10", elst)) ### Start diagonal exchange exch_diag = 0.0 exch_diag -= np.vdot(Pj, 2 * K["ii"] + K["aa"]) exch_diag -= np.vdot(Pb, K["ii"]) exch_diag -= np.vdot(_chain_dot(Pi, S, Pj), (h_Aa + h_Ab + h_Ba + h_Bb)) exch_diag -= np.vdot(_chain_dot(Pa, S, Pj), (h_Aa + h_Ba)) exch_diag -= np.vdot(_chain_dot(Pi, S, Pb), (h_Ab + h_Bb)) exch_diag += 2.0 * np.vdot(_chain_dot(Pj, S, Pi, S, Pb), w_A) exch_diag += 2.0 * np.vdot(_chain_dot(Pj, S, Pi, S, Pj), w_A) exch_diag += np.vdot(_chain_dot(Pb, S, Pi, S, Pb), w_A) exch_diag += np.vdot(_chain_dot(Pj, S, Pa, S, Pj), w_A) exch_diag += 2.0 * np.vdot(_chain_dot(Pi, S, Pj, S, Pi), w_B) exch_diag += 2.0 * np.vdot(_chain_dot(Pi, S, Pj, S, Pa), w_B) exch_diag += np.vdot(_chain_dot(Pi, S, Pb, S, Pi), w_B) exch_diag += np.vdot(_chain_dot(Pa, S, Pj, S, Pa), w_B) exch_diag -= 2.0 * np.vdot(_chain_dot(Pi, S, Pj), K["ij"]) exch_diag -= 2.0 * np.vdot(_chain_dot(Pa, S, Pj), K["ij"]) exch_diag -= 2.0 * np.vdot(_chain_dot(Pi, S, Pb), K["ij"]) exch_diag -= np.vdot(_chain_dot(Pa, S, Pj), K["aj"]) exch_diag -= np.vdot(_chain_dot(Pi, S, Pb), K["ib"]) # print(print_sapt_var("Exch10,offdiagonal", exch_diag)) ### Start off-diagonal exchange exch_offdiag = 0.0 exch_offdiag -= np.vdot(Pb, K["aa"]) exch_offdiag -= np.vdot(_chain_dot(Pa, S, Pb), (h_Aa + h_Bb)) exch_offdiag += np.vdot(_chain_dot(Pa, S, Pj), K["bb"]) exch_offdiag += np.vdot(_chain_dot(Pi, S, Pb), K["aa"]) exch_offdiag += 2.0 * np.vdot(_chain_dot(Pj, S, Pa, S, Pb), w_A) exch_offdiag += np.vdot(_chain_dot(Pb, S, Pa, S, Pb), w_A) exch_offdiag += 2.0 * np.vdot(_chain_dot(Pi, S, Pb, S, Pa), w_B) exch_offdiag += np.vdot(_chain_dot(Pa, S, Pb, S, Pa), w_B) exch_offdiag -= 2.0 * np.vdot(_chain_dot(Pa, S, Pb), K["ij"]) exch_offdiag -= 2.0 * np.vdot(_chain_dot(Pa, S, Pb), K["ib"]) exch_offdiag -= 2.0 * np.vdot(_chain_dot(Pa, S, Pj), K["ab"]) exch_offdiag -= 2.0 * np.vdot(_chain_dot(Pa, S, Pj), K["ib"]) exch_offdiag -= np.vdot(_chain_dot(Pa, S, Pb), K["ab"]) # print(print_sapt_var("Exch10,off-diagonal", exch_offdiag)) # print(print_sapt_var("Exch10(S^2)", exch_offdiag + exch_diag)) ret_values = OrderedDict({ "Elst10": elst, "Exch10(S^2) [diagonal]": exch_diag, "Exch10(S^2) [off-diagonal]": exch_offdiag, "Exch10(S^2) [highspin]": exch_offdiag + exch_diag, }) return ret_values
def df_fdds_dispersion(primary, auxiliary, cache, is_hybrid, x_alpha, leg_points=10, leg_lambda=0.3, do_print=True): rho_thresh = core.get_option("SAPT", "SAPT_FDDS_V2_RHO_CUTOFF") if do_print: core.print_out("\n ==> E20 Dispersion (CHF FDDS) <== \n\n") core.print_out(" Legendre Points: % 10d\n" % leg_points) core.print_out(" Lambda Shift: % 10.3f\n" % leg_lambda) core.print_out(" Fxc Kernal: % 10s\n" % "ALDA") core.print_out(" (P|Fxc|Q) Thresh: % 8.3e\n" % rho_thresh) # Build object df_matrix_keys = ["Cocc_A", "Cvir_A", "Cocc_B", "Cvir_B"] fdds_matrix_cache = {key: cache[key] for key in df_matrix_keys} df_vector_keys = ["eps_occ_A", "eps_vir_A", "eps_occ_B", "eps_vir_B"] fdds_vector_cache = {key: cache[key] for key in df_vector_keys} fdds_obj = core.FDDS_Dispersion(primary, auxiliary, fdds_matrix_cache, fdds_vector_cache, is_hybrid) # Aux Densities D = fdds_obj.project_densities([cache["D_A"], cache["D_B"]]) # Temps half_Saux = fdds_obj.aux_overlap().clone() half_Saux.power(-0.5, 1.e-12) halfp_Saux = fdds_obj.aux_overlap().clone() halfp_Saux.power(0.5, 1.e-12) # Builds potentials W_A = fdds_obj.metric().clone() W_A.axpy(1.0, _compute_fxc(D[0], half_Saux, halfp_Saux, x_alpha, rho_thresh=rho_thresh)) W_A = W_A.to_array() W_B = fdds_obj.metric().clone() W_B.axpy(1.0, _compute_fxc(D[1], half_Saux, halfp_Saux, x_alpha, rho_thresh=rho_thresh)) W_B = W_B.to_array() # Nuke the densities del D metric = fdds_obj.metric().clone().to_array() metric_inv = fdds_obj.metric_inv().clone().to_array() # Integrate core.print_out("\n => Time Integration <= \n\n") val_pack = ("Omega", "Weight", "Disp20,u", "Disp20", "time [s]") core.print_out("% 12s % 12s % 14s % 14s % 10s\n" % val_pack) start_time = time.time() total_uc = 0 total_c = 0 # Read R if is_hybrid: R_A = fdds_obj.R_A().to_array() R_B = fdds_obj.R_B().to_array() Rtinv_A = np.linalg.pinv(R_A, rcond=1.e-13).transpose() Rtinv_B = np.linalg.pinv(R_B, rcond=1.e-13).transpose() for point, weight in zip(*np.polynomial.legendre.leggauss(leg_points)): omega = leg_lambda * (1.0 - point) / (1.0 + point) lambda_scale = ((2.0 * leg_lambda) / (point + 1.0)**2) # Monomer A if is_hybrid: aux_dict = fdds_obj.form_aux_matrices("A", omega) aux_dict = {k: v.to_array() for k, v in aux_dict.items()} X_A_uc = aux_dict["amp"].copy() X_A = X_A_uc - x_alpha * aux_dict["K2L"] # K matrices K_A = -x_alpha * aux_dict["K1LD"] - x_alpha * aux_dict["K2LD"] + x_alpha * x_alpha * aux_dict["K21L"] KRS_A = K_A.dot(Rtinv_A).dot(metric) else: X_A = fdds_obj.form_unc_amplitude("A", omega) X_A.scale(-1.0) X_A = X_A.to_array() X_A_uc = X_A.copy() # Coupled A XSW_A = X_A.dot(metric_inv).dot(W_A) if is_hybrid: XSW_A += 0.25 * KRS_A amplitude = np.linalg.pinv(metric - XSW_A, rcond=1.e-13) X_A_coupled = X_A + XSW_A.dot(amplitude).dot(X_A) del X_A, XSW_A, amplitude if is_hybrid: del K_A, KRS_A, aux_dict # Monomer B if is_hybrid: aux_dict = fdds_obj.form_aux_matrices("B", omega) aux_dict = {k: v.to_array() for k, v in aux_dict.items()} X_B_uc = aux_dict["amp"].copy() X_B = X_B_uc - x_alpha * aux_dict["K2L"] # K matrices K_B = -x_alpha * aux_dict["K1LD"] - x_alpha * aux_dict["K2LD"] + x_alpha * x_alpha * aux_dict["K21L"] KRS_B = K_B.dot(Rtinv_B).dot(metric) else: X_B = fdds_obj.form_unc_amplitude("B", omega) X_B.scale(-1.0) X_B = X_B.to_array() X_B_uc = X_B.copy() # Coupled B XSW_B = X_B.dot(metric_inv).dot(W_B) if is_hybrid: XSW_B += 0.25 * KRS_B amplitude = np.linalg.pinv(metric - XSW_B, rcond=1.e-13) X_B_coupled = X_B + XSW_B.dot(amplitude).dot(X_B) del X_B, XSW_B, amplitude if is_hybrid: del K_B, KRS_B, aux_dict # Make sure the results are symmetrized X_A_uc = _symmetrize(X_A_uc) X_B_uc = _symmetrize(X_B_uc) X_A_coupled = _symmetrize(X_A_coupled) X_B_coupled = _symmetrize(X_B_coupled) # Combine tmp_uc = metric_inv.dot(X_A_uc).dot(metric_inv) value_uc = np.dot(tmp_uc.flatten(), X_B_uc.flatten()) del tmp_uc tmp_c = metric_inv.dot(X_A_coupled).dot(metric_inv) value_c = np.dot(tmp_c.flatten(), X_B_coupled.flatten()) # Tally total_uc += value_uc * weight * lambda_scale total_c += value_c * weight * lambda_scale if do_print: tmp_disp_unc = value_uc * weight * lambda_scale tmp_disp = value_c * weight * lambda_scale fdds_time = time.time() - start_time val_pack = (omega, weight, tmp_disp_unc, tmp_disp, fdds_time) core.print_out("% 12.3e % 12.3e % 14.3e % 14.3e %10d\n" % val_pack) Disp20_uc = -1.0 / (2.0 * np.pi) * total_uc Disp20_c = -1.0 / (2.0 * np.pi) * total_c core.print_out("\n") core.print_out(print_sapt_var("Disp20,u", Disp20_uc, short=True) + "\n") core.print_out(print_sapt_var("Disp20", Disp20_c, short=True) + "\n") return {"Disp20,FDDS (unc)": Disp20_uc, "Disp20": Disp20_c}
def scf_xtpl_karton_2(functionname: str, zLO: int, valueLO: Extrapolatable, zHI: int, valueHI: Extrapolatable, verbose: int = 1, alpha: Optional[float] = None) -> Extrapolatable: r"""Extrapolation scheme using root-power form for reference energies with two adjacent zeta-level bases. Used by :py:func:`~psi4.cbs`. Parameters ---------- functionname Name of the CBS component (e.g., 'HF') used in summary printing. zLO Zeta number of the smaller basis set in 2-point extrapolation. valueLO Energy, gradient, or Hessian value at the smaller basis set in 2-point extrapolation. zHI Zeta number of the larger basis set in 2-point extrapolation Must be `zLO + 1`. valueHI Energy, gradient, or Hessian value at the larger basis set in 2-point extrapolation. verbose Controls volume of printing. alpha Overrides the default :math:`\alpha = 6.3` Returns ------- float or ndarray Eponymous function applied to input zetas and values; type from `valueLO`. Notes ----- The extrapolation is calculated according to [3]_: :math:`E_{total}^X = E_{total}^{\infty} + \beta e^{-\alpha\sqrt{X}}, \alpha = 6.3` References ---------- .. [3] Karton, Martin, Theor. Chem. Acc. 115 (2006) 330-333, DOI: 10.1007/s00214-005-0028-6 """ if type(valueLO) != type(valueHI): raise ValidationError( f"scf_xtpl_karton_2: Inputs must be of the same datatype! ({type(valueLO)}, {type(valueHI)})" ) if alpha is None: alpha = 6.30 # prior to April 2022, this wrong expression was used # beta_division = 1 / (math.exp(-1 * alpha) * (math.exp(math.sqrt(zHI)) - math.exp(math.sqrt(zLO)))) beta_division = 1 / (math.exp(-1 * alpha * math.sqrt(zHI)) - math.exp(-1 * alpha * math.sqrt(zLO))) beta_mult = math.exp(-1 * alpha * math.sqrt(zHI)) if isinstance(valueLO, float): beta = (valueHI - valueLO) * beta_division value = valueHI - beta * beta_mult if verbose: # Output string with extrapolation parameters cbsscheme = '' cbsscheme += """\n ==> Karton 2-point power form SCF extrapolation for method: %s <==\n\n""" % ( functionname.upper()) cbsscheme += """ LO-zeta (%s) Energy: % 16.12f\n""" % ( str(zLO), valueLO) cbsscheme += """ HI-zeta (%s) Energy: % 16.12f\n""" % ( str(zHI), valueHI) cbsscheme += """ Alpha (exponent) Value: % 16.12f\n""" % ( alpha) cbsscheme += """ Beta (coefficient) Value: % 16.12f\n\n""" % ( beta) name_str = "%s/(%s,%s)" % (functionname.upper(), _zeta_val2sym[zLO].upper(), _zeta_val2sym[zHI].upper()) cbsscheme += """ @Extrapolated """ cbsscheme += name_str + ':' cbsscheme += " " * (18 - len(name_str)) cbsscheme += """% 16.12f\n\n""" % value core.print_out(cbsscheme) return value elif isinstance(valueLO, (core.Matrix, core.Vector)): valueLO = valueLO.to_array() valueHI = valueHI.to_array() beta = (valueHI - valueLO) * beta_division value = valueHI - beta * beta_mult if verbose > 2: cbsscheme = f"""\n ==> Karton 2-point power SCF extrapolation for method: {functionname.upper()} <==\n""" cbsscheme += f"""\n LO-zeta ({zLO}) Data\n""" cbsscheme += nppp(valueLO) cbsscheme += f"""\n HI-zeta ({zHI}) Data\n""" cbsscheme += nppp(valueHI) cbsscheme += f"""\n Alpha (exponent) Value: {alpha:16.8f}""" cbsscheme += f"""\n Beta Data\n""" cbsscheme += nppp(beta) cbsscheme += f"""\n Extrapolated Data\n""" cbsscheme += nppp(value) cbsscheme += "\n" core.print_out(cbsscheme) value = core.Matrix.from_array(value) return value else: raise ValidationError( f"scf_xtpl_Karton_2: datatype is not recognized '{type(valueLO)}'." )
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_xtpl_helgaker_3(functionname: str, zLO: int, valueLO: Extrapolatable, zMD: int, valueMD: Extrapolatable, zHI: int, valueHI: Extrapolatable, verbose: int = 1, alpha: Optional[float] = None) -> Extrapolatable: r"""Extrapolation scheme for reference energies with three adjacent zeta-level bases. Used by :py:func:`~psi4.cbs`. Parameters ---------- functionname Name of the CBS component (e.g., 'HF') used in summary printing. zLO Zeta number of the smaller basis set in 3-point extrapolation. valueLO Energy, gradient, or Hessian value at the smaller basis set in 3-point extrapolation. zMD Zeta number of the medium basis set in 3-point extrapolation. Must be `zLO + 1`. valueMD Energy, gradient, or Hessian value at the medium basis set in 3-point extrapolation. zHI Zeta number of the larger basis set in 3-point extrapolation. Must be `zLO + 2`. valueHI Energy, gradient, or Hessian value at the larger basis set in 3-point extrapolation. verbose Controls volume of printing. alpha Not used. Returns ------- float or ndarray Eponymous function applied to input zetas and values; type from `valueLO`. Notes ----- The extrapolation is calculated according to [4]_: :math:`E_{total}^X = E_{total}^{\infty} + \beta e^{-\alpha X}, \alpha = 3.0` References ---------- .. [4] Halkier, Helgaker, Jorgensen, Klopper, & Olsen, Chem. Phys. Lett. 302 (1999) 437-446, DOI: 10.1016/S0009-2614(99)00179-7 Examples -------- >>> # [1] Hartree-Fock extrapolation >>> psi4.energy('cbs', scf_wfn='hf', scf_basis='cc-pV[DTQ]Z', scf_scheme='scf_xtpl_helgaker_3') """ if (type(valueLO) != type(valueMD)) or (type(valueMD) != type(valueHI)): raise ValidationError( f"scf_xtpl_helgaker_3: Inputs must be of the same datatype! ({type(valueLO)}, {type(valueMD)}, {type(valueHI)})" ) if isinstance(valueLO, float): ratio = (valueHI - valueMD) / (valueMD - valueLO) alpha = -1 * math.log(ratio) beta = (valueHI - valueMD) / (math.exp(-1 * alpha * zMD) * (ratio - 1)) value = valueHI - beta * math.exp(-1 * alpha * zHI) if verbose: # Output string with extrapolation parameters cbsscheme = '' cbsscheme += """\n ==> Helgaker 3-point SCF extrapolation for method: %s <==\n\n""" % ( functionname.upper()) cbsscheme += """ LO-zeta (%s) Energy: % 16.12f\n""" % ( str(zLO), valueLO) cbsscheme += """ MD-zeta (%s) Energy: % 16.12f\n""" % ( str(zMD), valueMD) cbsscheme += """ HI-zeta (%s) Energy: % 16.12f\n""" % ( str(zHI), valueHI) cbsscheme += """ Alpha (exponent) Value: % 16.12f\n""" % ( alpha) cbsscheme += """ Beta (coefficient) Value: % 16.12f\n\n""" % ( beta) name_str = "%s/(%s,%s,%s)" % ( functionname.upper(), _zeta_val2sym[zLO].upper(), _zeta_val2sym[zMD].upper(), _zeta_val2sym[zHI].upper()) cbsscheme += """ @Extrapolated """ cbsscheme += name_str + ':' cbsscheme += " " * (18 - len(name_str)) cbsscheme += """% 16.12f\n\n""" % value core.print_out(cbsscheme) return value elif isinstance(valueLO, (core.Matrix, core.Vector)): valueLO = np.array(valueLO) valueMD = np.array(valueMD) valueHI = np.array(valueHI) nonzero_mask = np.abs(valueHI) > 1.e-14 top = (valueHI - valueMD)[nonzero_mask] bot = (valueMD - valueLO)[nonzero_mask] ratio = top / bot alpha = -1 * np.log(np.abs(ratio)) beta = top / (np.exp(-1 * alpha * zMD) * (ratio - 1)) np_value = valueHI.copy() np_value[nonzero_mask] -= beta * np.exp(-1 * alpha * zHI) np_value[~nonzero_mask] = 0.0 if verbose > 2: cbsscheme = f"""\n ==> Helgaker 3-point power SCF extrapolation for method: {functionname.upper()} <==\n""" cbsscheme += f"""\n LO-zeta ({zLO}) Data\n""" cbsscheme += nppp(valueLO) cbsscheme += f"""\n MD-zeta ({zMD}) Data\n""" cbsscheme += nppp(valueMD) cbsscheme += f"""\n HI-zeta ({zHI}) Data\n""" cbsscheme += nppp(valueHI) cbsscheme += f"""\n Alpha Data\n""" cbsscheme += nppp(alpha) cbsscheme += f"""\n Beta Data\n""" cbsscheme += nppp(beta) cbsscheme += f"""\n Extrapolated Data\n""" cbsscheme += nppp(np_value) cbsscheme += "\n" core.print_out(cbsscheme) ## Build and set from numpy routines #value = core.Matrix(*valueHI.shape) #value_view = np.asarray(value) #value_view[:] = np_value #return value np_value = core.Matrix.from_array(np_value) return np_value else: raise ValidationError( f"scf_xtpl_helgaker_3: datatype is not recognized '{type(valueLO)}'." )
def corl_xtpl_helgaker_2(functionname: str, zLO: int, valueLO: Extrapolatable, zHI: int, valueHI: Extrapolatable, verbose: int = 1, alpha: Optional[float] = None) -> Extrapolatable: r"""Extrapolation scheme for correlation energies with two adjacent zeta-level bases. Used by :py:func:`~psi4.cbs`. Parameters ---------- functionname Name of the CBS component (e.g., 'MP2') used in summary printing. zLO Zeta number of the smaller basis set in 2-point extrapolation. valueLO Energy, gradient, or Hessian value at the smaller basis set in 2-point extrapolation. zHI Zeta number of the larger basis set in 2-point extrapolation. Must be `zLO + 1`. valueHI Energy, gradient, or Hessian value at the larger basis set in 2-point extrapolation. verbose Controls volume of printing. alpha Overrides the default :math:`\alpha = 3.0` Returns ------- float or numpy.ndarray Eponymous function applied to input zetas and values; type from `valueLO`. Notes ----- The extrapolation is calculated according to [5]_: :math:`E_{corl}^X = E_{corl}^{\infty} + \beta X^{-alpha}` References ---------- .. [5] Halkier, Helgaker, Jorgensen, Klopper, Koch, Olsen, & Wilson, Chem. Phys. Lett. 286 (1998) 243-252, DOI: 10.1016/S0009-2614(99)00179-7 Examples -------- >>> # [1] CISD extrapolation >>> energy('cbs', corl_wfn='cisd', corl_basis='cc-pV[DT]Z', corl_scheme='corl_xtpl_helgaker_2') """ if type(valueLO) != type(valueHI): raise ValidationError( f"corl_xtpl_helgaker_2: Inputs must be of the same datatype! ({type(valueLO)}, {type(valueHI)})" ) if alpha is None: alpha = 3.0 if isinstance(valueLO, float): value = (valueHI * zHI**alpha - valueLO * zLO**alpha) / (zHI**alpha - zLO**alpha) beta = (valueHI - valueLO) / (zHI**(-alpha) - zLO**(-alpha)) final = value if verbose: # Output string with extrapolation parameters cbsscheme = f"""\n\n ==> Helgaker 2-point correlated extrapolation for method: {functionname.upper()} <==\n\n""" cbsscheme += """ LO-zeta (%s) Energy: % 16.12f\n""" % ( str(zLO), valueLO) cbsscheme += """ HI-zeta (%s) Energy: % 16.12f\n""" % ( str(zHI), valueHI) cbsscheme += """ Alpha (exponent) Value: % 16.12f\n""" % alpha cbsscheme += f""" Beta (coefficient) Value: {beta: 16.12f}\n\n""" cbsscheme += """ Extrapolated Energy: % 16.12f\n\n""" % value # Note that in energy-only days, this used to print SCF and Correlation, not Total, Energy name_str = "%s/(%s,%s)" % (functionname.upper(), _zeta_val2sym[zLO].upper(), _zeta_val2sym[zHI].upper()) cbsscheme += """ @Extrapolated """ cbsscheme += name_str + ':' cbsscheme += " " * (19 - len(name_str)) cbsscheme += """% 16.12f\n\n""" % final core.print_out(cbsscheme) return final elif isinstance(valueLO, (core.Matrix, core.Vector)): valueLO = np.array(valueLO) valueHI = np.array(valueHI) value = (valueHI * zHI**alpha - valueLO * zLO**alpha) / (zHI**alpha - zLO**alpha) beta = (valueHI - valueLO) / (zHI**(-alpha) - zLO**(-alpha)) if verbose > 2: cbsscheme = f"""\n ==> Helgaker 2-point correlated extrapolation for method: {functionname.upper()} <==\n""" cbsscheme += f"""\n LO-zeta ({zLO}) Data\n""" cbsscheme += nppp(valueLO) cbsscheme += f"""\n HI-zeta ({zHI}) Data\n""" cbsscheme += nppp(valueHI) cbsscheme += f"""\n Alpha (exponent) Value: {alpha:16.8f}""" cbsscheme += f"""\n Beta Data\n""" cbsscheme += nppp(beta) cbsscheme += f"""\n Extrapolated Data\n""" cbsscheme += nppp(value) cbsscheme += "\n" core.print_out(cbsscheme) value = core.Matrix.from_array(value) return value else: raise ValidationError( f"corl_xtpl_helgaker_2: datatype is not recognized '{type(valueLO)}'." )
def print_ci_results(ciwfn, rname, scf_e, ci_e, print_opdm_no=False): """ Printing for all CI Wavefunctions """ # Print out energetics core.print_out("\n ==> Energetics <==\n\n") core.print_out(" SCF energy = %20.15f\n" % scf_e) if "CI" in rname: core.print_out(" Total CI energy = %20.15f\n" % ci_e) elif "MP" in rname: core.print_out(" Total MP energy = %20.15f\n" % ci_e) elif "ZAPT" in rname: core.print_out(" Total ZAPT energy = %20.15f\n" % ci_e) else: core.print_out(" Total MCSCF energy = %20.15f\n" % ci_e) # Nothing to be done for ZAPT or MP if ("MP" in rname) or ("ZAPT" in rname): core.print_out("\n") return # Initial info ci_nroots = core.get_option("DETCI", "NUM_ROOTS") irrep_labels = ciwfn.molecule().irrep_labels() # Grab the D-vector dvec = ciwfn.D_vector() dvec.init_io_files(True) for root in range(ci_nroots): core.print_out("\n ==> %s root %d information <==\n\n" % (rname, root)) # Print total energy root_e = ciwfn.variable("CI ROOT %d TOTAL ENERGY" % (root)) core.print_out(" %s Root %d energy = %20.15f\n" % (rname, root, root_e)) # Print natural occupations if print_opdm_no: core.print_out("\n Active Space Natural occupation numbers:\n\n") occs_list = [] r_opdm = ciwfn.get_opdm(root, root, "SUM", False) for h in range(len(r_opdm.nph)): if 0 in r_opdm.nph[h].shape: continue nocc, rot = np.linalg.eigh(r_opdm.nph[h]) for e in nocc: occs_list.append((e, irrep_labels[h])) occs_list.sort(key=lambda x: -x[0]) cnt = 0 for value, label in occs_list: value, label = occs_list[cnt] core.print_out(" %4s % 8.6f" % (label, value)) cnt += 1 if (cnt % 3) == 0: core.print_out("\n") if (cnt % 3): core.print_out("\n") # Print CIVector information ciwfn.print_vector(dvec, root) # True to keep the file dvec.close_io_files(True)
def anharmonicity(rvals: List, energies: List, plot_fit: str = '', mol=None) -> Dict: """Generates spectroscopic constants for a diatomic molecules. Fits a diatomic potential energy curve using a weighted least squares approach (c.f. https://doi.org/10.1063/1.4862157, particularly eqn. 7), locates the minimum energy point, and then applies second order vibrational perturbation theory to obtain spectroscopic constants. Any number of points greater than 4 may be provided, and they should bracket the minimum. The data need not be evenly spaced, and can be provided in any order. The data are weighted such that those closest to the minimum have highest impact. A dictionary with the following keys, which correspond to spectroscopic constants, is returned: :param rvals: The bond lengths (in Angstrom) for which energies are provided, of length at least 5 and equal to the length of the energies array :param energies: The energies (Eh) computed at the bond lengths in the rvals list :param plot_fit: A string describing where to save a plot of the harmonic and anharmonic fits, the inputted data points, re, r0 and the first few energy levels, if matplotlib is available. Set to 'screen' to generate an interactive plot on the screen instead. If a filename is provided, the image type is determined by the extension; see matplotlib for supported file types. :returns: (*dict*) Keys: "re", "r0", "we", "wexe", "nu", "ZPVE(harmonic)", "ZPVE(anharmonic)", "Be", "B0", "ae", "De" corresponding to the spectroscopic constants in cm-1 """ angstrom_to_bohr = 1.0 / constants.bohr2angstroms angstrom_to_meter = 10e-10 # Make sure the input is valid if len(rvals) != len(energies): raise ValidationError( "The number of energies must match the number of distances") npoints = len(rvals) if npoints < 5: raise ValidationError( "At least 5 data points must be provided to compute anharmonicity") core.print_out("\n\nPerforming a fit to %d data points\n" % npoints) # Sort radii and values first from lowest to highest radius indices = np.argsort(rvals) rvals = np.array(rvals)[indices] energies = np.array(energies)[indices] # Make sure the molecule the user provided is the active one molecule = mol or core.get_active_molecule() molecule.update_geometry() natoms = molecule.natom() if natoms != 2: raise Exception( "The current molecule must be a diatomic for this code to work!") m1 = molecule.mass(0) m2 = molecule.mass(1) # Find rval of the minimum of energies, check number of points left and right min_index = np.argmin(energies) if min_index < 3: core.print_out( "\nWarning: fewer than 3 points provided with a r < r(min(E))!\n") if min_index >= len(energies) - 3: core.print_out( "\nWarning: fewer than 3 points provided with a r > r(min(E))!\n") # Optimize the geometry, refitting the surface around each new geometry core.print_out("\nOptimizing geometry based on current surface:\n\n") re = rvals[min_index] maxit = 30 thres = 1.0e-9 for i in range(maxit): derivs = least_squares_fit_polynomial(rvals, energies, localization_point=re) e, g, H = derivs[0:3] core.print_out(" E = %20.14f, x = %14.7f, grad = %20.14f\n" % (e, re, g)) if abs(g) < thres: break re -= g / H if i == maxit - 1: raise ConvergenceError("diatomic geometry optimization", maxit) core.print_out(" Final E = %20.14f, x = %14.7f, grad = %20.14f\n" % (e, re, g)) if re < min(rvals): raise Exception( "Minimum energy point is outside range of points provided. Use a lower range of r values." ) if re > max(rvals): raise Exception( "Minimum energy point is outside range of points provided. Use a higher range of r values." ) # Convert to convenient units, and compute spectroscopic constants d0, d1, d2, d3, d4 = derivs * constants.hartree2aJ core.print_out("\nEquilibrium Energy %20.14f Hartrees\n" % e) core.print_out("Gradient %20.14f\n" % g) core.print_out("Quadratic Force Constant %14.7f MDYNE/A\n" % d2) core.print_out("Cubic Force Constant %14.7f MDYNE/A**2\n" % d3) core.print_out("Quartic Force Constant %14.7f MDYNE/A**3\n" % d4) hbar = constants.h / (2.0 * np.pi) mu = ((m1 * m2) / (m1 + m2)) * constants.amu2kg we = 5.3088375e-11 * np.sqrt(d2 / mu) wexe = (1.2415491e-6) * (we / d2)**2 * ((5.0 * d3 * d3) / (3.0 * d2) - d4) # Rotational constant: Be I = ((m1 * m2) / (m1 + m2)) * constants.amu2kg * (re * angstrom_to_meter)**2 B = constants.h / (8.0 * np.pi**2 * constants.c * I) # alpha_e and quartic centrifugal distortion constant ae = -(6.0 * B**2 / we) * ((1.05052209e-3 * we * d3) / (np.sqrt(B * d2**3)) + 1.0) de = 4.0 * B**3 / we**2 # B0 and r0 (plus re check using Be) B0 = B - ae / 2.0 r0 = np.sqrt(constants.h / (8.0 * np.pi**2 * mu * constants.c * B0)) recheck = np.sqrt(constants.h / (8.0 * np.pi**2 * mu * constants.c * B)) r0 /= angstrom_to_meter recheck /= angstrom_to_meter # Fundamental frequency nu nu = we - 2.0 * wexe zpve_nu = 0.5 * we - 0.25 * wexe zpve_we = 0.5 * we # Generate pretty pictures, if requested if (plot_fit): try: import matplotlib.pyplot as plt except ImportError: msg = "\n\tPlot not generated; matplotlib is not installed on this machine.\n\n" print(msg) core.print_out(msg) # Correct the derivatives for the missing factorial prefactors dvals = np.zeros(5) dvals[0:5] = derivs[0:5] dvals[2] /= 2 dvals[3] /= 6 dvals[4] /= 24 # Default plot range, before considering energy levels minE = np.min(energies) maxE = np.max(energies) minR = np.min(rvals) maxR = np.max(rvals) # Plot vibrational energy levels we_au = we / constants.hartree2wavenumbers wexe_au = wexe / constants.hartree2wavenumbers coefs2 = [dvals[2], dvals[1], dvals[0]] coefs4 = [dvals[4], dvals[3], dvals[2], dvals[1], dvals[0]] for n in range(3): Eharm = we_au * (n + 0.5) Evpt2 = Eharm - wexe_au * (n + 0.5)**2 coefs2[-1] = -Eharm coefs4[-1] = -Evpt2 roots2 = np.roots(coefs2) roots4 = np.roots(coefs4) xvals2 = roots2 + re xvals4 = np.choose(np.where(np.isreal(roots4)), roots4)[0].real + re Eharm += dvals[0] Evpt2 += dvals[0] plt.plot(xvals2, [Eharm, Eharm], 'b', linewidth=1) plt.plot(xvals4, [Evpt2, Evpt2], 'g', linewidth=1) maxE = Eharm maxR = np.max([xvals2, xvals4]) minR = np.min([xvals2, xvals4]) # Find ranges for the plot dE = maxE - minE minE -= 0.2 * dE maxE += 0.4 * dE dR = maxR - minR minR -= 0.2 * dR maxR += 0.2 * dR # Generate the fitted PES xpts = np.linspace(minR, maxR, 1000) xrel = xpts - re xpows = xrel[:, None]**range(5) fit2 = np.einsum('xd,d', xpows[:, 0:3], dvals[0:3]) fit4 = np.einsum('xd,d', xpows, dvals) # Make / display the plot plt.plot(xpts, fit2, 'b', linewidth=2.5, label='Harmonic (quadratic) fit') plt.plot(xpts, fit4, 'g', linewidth=2.5, label='Anharmonic (quartic) fit') plt.plot([re, re], [minE, maxE], 'b--', linewidth=0.5) plt.plot([r0, r0], [minE, maxE], 'g--', linewidth=0.5) plt.scatter(rvals, energies, c='Black', linewidth=3, label='Input Data') plt.legend() plt.xlabel('Bond length (Angstroms)') plt.ylabel('Energy (Eh)') plt.xlim(minR, maxR) plt.ylim(minE, maxE) if plot_fit == 'screen': plt.show() else: plt.savefig(plot_fit) core.print_out("\n\tPES fit saved to %s.\n\n" % plot_fit) core.print_out("\nre = %10.6f A check: %10.6f\n" % (re, recheck)) core.print_out("r0 = %10.6f A\n" % r0) core.print_out("E at re = %17.10f Eh\n" % e) core.print_out("we = %10.4f cm-1\n" % we) core.print_out("wexe = %10.4f cm-1\n" % wexe) core.print_out("nu = %10.4f cm-1\n" % nu) core.print_out("ZPVE(we) = %10.4f cm-1\n" % zpve_we) core.print_out("ZPVE(nu) = %10.4f cm-1\n" % zpve_nu) core.print_out("Be = %10.4f cm-1\n" % B) core.print_out("B0 = %10.4f cm-1\n" % B0) core.print_out("ae = %10.4f cm-1\n" % ae) core.print_out("De = %10.7f cm-1\n" % de) results = { "re": re, "r0": r0, "we": we, "wexe": wexe, "nu": nu, "E(re)": e, "ZPVE(harmonic)": zpve_we, "ZPVE(anharmonic)": zpve_nu, "Be": B, "B0": B0, "ae": ae, "De": de } return results
def scf_print_energies(self): enuc = self.get_energies('Nuclear') e1 = self.get_energies('One-Electron') e2 = self.get_energies('Two-Electron') exc = self.get_energies('XC') ed = self.get_energies('-D') self.del_variable('-D Energy') evv10 = self.get_energies('VV10') eefp = self.get_energies('EFP') epcm = self.get_energies('PCM Polarization') epe = self.get_energies('PE Energy') hf_energy = enuc + e1 + e2 dft_energy = hf_energy + exc + ed + evv10 total_energy = dft_energy + eefp + epcm + epe core.print_out(" => Energetics <=\n\n") core.print_out( " Nuclear Repulsion Energy = {:24.16f}\n".format(enuc)) core.print_out( " One-Electron Energy = {:24.16f}\n".format(e1)) core.print_out( " Two-Electron Energy = {:24.16f}\n".format(e2)) if self.functional().needs_xc(): core.print_out( " DFT Exchange-Correlation Energy = {:24.16f}\n".format(exc)) core.print_out( " Empirical Dispersion Energy = {:24.16f}\n".format(ed)) core.print_out( " VV10 Nonlocal Energy = {:24.16f}\n".format(evv10)) if core.get_option('SCF', 'PCM'): core.print_out( " PCM Polarization Energy = {:24.16f}\n".format(epcm)) if core.get_option('SCF', 'PE'): core.print_out( " PE Energy = {:24.16f}\n".format(epe)) if hasattr(self.molecule(), 'EFP'): core.print_out( " EFP Energy = {:24.16f}\n".format(eefp)) core.print_out(" Total Energy = {:24.16f}\n".format( total_energy)) if core.get_option('SCF', 'PE'): core.print_out(self.pe_state.cppe_state.summary_string) self.set_variable("NUCLEAR REPULSION ENERGY", enuc) # P::e SCF self.set_variable("ONE-ELECTRON ENERGY", e1) # P::e SCF self.set_variable("TWO-ELECTRON ENERGY", e2) # P::e SCF if self.functional().needs_xc(): self.set_variable("DFT XC ENERGY", exc) # P::e SCF self.set_variable("DFT VV10 ENERGY", evv10) # P::e SCF self.set_variable("DFT FUNCTIONAL TOTAL ENERGY", hf_energy + exc + evv10) # P::e SCF #self.set_variable(self.functional().name() + ' FUNCTIONAL TOTAL ENERGY', hf_energy + exc + evv10) self.set_variable("DFT TOTAL ENERGY", dft_energy) # overwritten later for DH # P::e SCF else: self.set_variable("HF TOTAL ENERGY", hf_energy) # P::e SCF if hasattr(self, "_disp_functor"): self.set_variable("DISPERSION CORRECTION ENERGY", ed) # P::e SCF #if abs(ed) > 1.0e-14: # for pv, pvv in self.variables().items(): # if abs(pvv - ed) < 1.0e-14: # if pv.endswith('DISPERSION CORRECTION ENERGY') and pv.startswith(self.functional().name()): # fctl_plus_disp_name = pv.split()[0] # self.set_variable(fctl_plus_disp_name + ' TOTAL ENERGY', dft_energy) # overwritten later for DH #else: # self.set_variable(self.functional().name() + ' TOTAL ENERGY', dft_energy) # overwritten later for DH self.set_variable("SCF ITERATIONS", self.iteration_) # P::e SCF
def prepare_sapt_molecule(sapt_dimer, sapt_basis): """ Prepares a dimer molecule for a SAPT computations. Returns the dimer, monomerA, and monomerB. """ # Shifting to C1 so we need to copy the active molecule sapt_dimer = sapt_dimer.clone() if sapt_dimer.schoenflies_symbol() != 'c1': core.print_out( ' SAPT does not make use of molecular symmetry, further calculations in C1 point group.\n' ) sapt_dimer.reset_point_group('c1') sapt_dimer.fix_orientation(True) sapt_dimer.fix_com(True) sapt_dimer.update_geometry() else: sapt_dimer.update_geometry( ) # make sure since mol from wfn, kwarg, or P::e sapt_dimer.fix_orientation(True) sapt_dimer.fix_com(True) nfrag = sapt_dimer.nfragments() if nfrag == 3: # Midbond case if sapt_basis == 'monomer': raise ValidationError( "SAPT basis cannot both be monomer centered and have midbond functions." ) midbond = sapt_dimer.extract_subsets(3) ztotal = 0 for n in range(midbond.natom()): ztotal += midbond.Z(n) if ztotal > 0: raise ValidationError( "SAPT third monomer must be a midbond function (all ghosts).") ghosts = ([2, 3], [1, 3]) elif nfrag == 2: # Classical dimer case ghosts = (2, 1) else: raise ValidationError( 'SAPT requires active molecule to have 2 fragments, not %s.' % (nfrag)) if sapt_basis == 'dimer': monomerA = sapt_dimer.extract_subsets(1, ghosts[0]) monomerA.set_name('monomerA') monomerB = sapt_dimer.extract_subsets(2, ghosts[1]) monomerB.set_name('monomerB') elif sapt_basis == 'monomer': monomerA = sapt_dimer.extract_subsets(1) monomerA.set_name('monomerA') monomerB = sapt_dimer.extract_subsets(2) monomerB.set_name('monomerB') else: raise ValidationError("SAPT basis %s not recognized" % sapt_basis) return (sapt_dimer, monomerA, monomerB)