def test_aci1(): import math import psi4 import forte from forte import forte_options ref_aci = -75.010199198896 rel_tol = 1e-9 abs_tol = 1e-8 h2o = psi4.geometry(""" O H 1 0.96 H 1 0.96 2 104.5 """) psi4.set_options({'basis': "sto-3g"}) E_scf, wfn = psi4.energy('scf', return_wfn=True) state = forte.StateInfo(na=5, nb=5, multiplicity=1, twice_ms=0, irrep=0) dim = psi4.core.Dimension([4, 0, 1, 2]) options = psi4.core.get_options() options.set_current_module('FORTE') forte_options.update_psi_options(options) forte.startup() forte.banner() mo_space_info = forte.make_mo_space_info(wfn, forte_options) ints = forte.make_forte_integrals(wfn, options, mo_space_info) scf_info = forte.SCFInfo(wfn) solver = forte.make_active_space_solver('ACI', state, scf_info, mo_space_info, ints, forte_options) energy = solver.compute_energy() assert math.isclose(energy, ref_aci, abs_tol=abs_tol, rel_tol=rel_tol) print("\n\nACI Energy = {}".format(energy)) forte.cleanup()
def test_aci1(): import math import psi4 import forte from forte import forte_options ref_aci = -75.010199198896 rel_tol = 1e-9 abs_tol = 1e-8 h2o = psi4.geometry(""" O H 1 0.96 H 1 0.96 2 104.5 """) psi4.set_options({'basis': "sto-3g"}) E_scf, wfn = psi4.energy('scf', return_wfn=True) state = forte.StateInfo(na=5, nb=5, multiplicity=1, twice_ms=0, irrep=0) dim = psi4.core.Dimension([4, 0, 1, 2]) options = psi4.core.get_options() options.set_current_module('FORTE') forte_options.update_psi_options(options) forte.startup() forte.banner() mo_space_info = forte.make_mo_space_info(wfn, forte_options) ints = forte.make_forte_integrals(wfn, options, mo_space_info) scf_info = forte.SCFInfo(wfn) solver = forte.make_active_space_solver('ACI',state,scf_info,mo_space_info, ints, forte_options) energy = solver.compute_energy() assert math.isclose(energy,ref_aci,abs_tol=abs_tol, rel_tol=rel_tol) print("\n\nACI Energy = {}".format(energy)) forte.cleanup()
def prepare_forte_objects(wfn): """ Take a psi4 wavefunction object and prepare the ForteIntegrals, SCFInfo, and MOSpaceInfo objects Parameters ---------- wfn : psi4Wavefunction A psi4 Wavefunction object Returns ------- tuple(ForteIntegrals, SCFInfo, MOSpaceInfo) a tuple containing the ForteIntegrals, SCFInfo, and MOSpaceInfo objects """ # fill in the options object psi4_options = psi4.core.get_options() psi4_options.set_current_module('FORTE') options = forte.forte_options options.get_options_from_psi4(psi4_options) if ('DF' in options.get_str('INT_TYPE')): aux_basis = psi4.core.BasisSet.build( wfn.molecule(), 'DF_BASIS_MP2', psi4.core.get_global_option('DF_BASIS_MP2'), 'RIFIT', psi4.core.get_global_option('BASIS')) wfn.set_basisset('DF_BASIS_MP2', aux_basis) if (options.get_str('MINAO_BASIS')): minao_basis = psi4.core.BasisSet.build( wfn.molecule(), 'MINAO_BASIS', psi4_options.get_str('MINAO_BASIS')) wfn.set_basisset('MINAO_BASIS', minao_basis) # Prepare base objects scf_info = forte.SCFInfo(wfn) mo_space_info = forte.make_mo_space_info(wfn, options) ints = forte.make_forte_integrals(wfn, options, mo_space_info) return (ints, scf_info, mo_space_info)
def run_forte(name, **kwargs): r"""Function encoding sequence of PSI module and plugin calls so that forte can be called via :py:func:`~driver.energy`. For post-scf plugins. >>> energy('forte') """ lowername = name.lower() kwargs = p4util.kwargs_lower(kwargs) # Compute a SCF reference, a wavefunction is return which holds the molecule used, orbitals # Fock matrices, and more ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: ref_wfn = psi4.driver.scf_helper(name, **kwargs) # Get the option object options = psi4.core.get_options() options.set_current_module('FORTE') forte.forte_options.update_psi_options(options) if ('DF' in options.get_str('INT_TYPE')): aux_basis = psi4.core.BasisSet.build( ref_wfn.molecule(), 'DF_BASIS_MP2', psi4.core.get_global_option('DF_BASIS_MP2'), 'RIFIT', psi4.core.get_global_option('BASIS')) ref_wfn.set_basisset('DF_BASIS_MP2', aux_basis) if (options.get_str('MINAO_BASIS')): minao_basis = psi4.core.BasisSet.build(ref_wfn.molecule(), 'MINAO_BASIS', options.get_str('MINAO_BASIS')) ref_wfn.set_basisset('MINAO_BASIS', minao_basis) # Start Forte, initialize ambit my_proc_n_nodes = forte.startup() my_proc, n_nodes = my_proc_n_nodes # Print the banner forte.banner() # Create the MOSpaceInfo object mo_space_info = forte.make_mo_space_info(ref_wfn, forte.forte_options) # Create the AO subspace projector ps = forte.make_aosubspace_projector(ref_wfn, options) state = forte.make_state_info_from_psi_wfn(ref_wfn) scf_info = forte.SCFInfo(ref_wfn) state_weights_map = forte.make_state_weights_map(forte.forte_options, ref_wfn) # Run a method job_type = options.get_str('JOB_TYPE') energy = 0.0 if job_type != 'NONE': start = timeit.timeit() # Make an integral object ints = forte.make_forte_integrals(ref_wfn, options, mo_space_info) # Rotate orbitals before computation orb_type = options.get_str("ORBITAL_TYPE") if orb_type != 'CANONICAL': orb_t = forte.make_orbital_transformation(orb_type, scf_info, forte.forte_options, ints, mo_space_info) orb_t.compute_transformation() Ua = orb_t.get_Ua() Ub = orb_t.get_Ub() ints.rotate_orbitals(Ua, Ub) # Run a method if (job_type == 'NEWDRIVER'): energy = forte_driver(state_weights_map, scf_info, forte.forte_options, ints, mo_space_info) else: energy = forte.forte_old_methods(ref_wfn, options, ints, mo_space_info) end = timeit.timeit() #print('\n\n Your calculation took ', (end - start), ' seconds'); # Close ambit, etc. forte.cleanup() psi4.core.set_scalar_variable('CURRENT ENERGY', energy) return ref_wfn
def test_sparse_ci2(): import math import psi4 import forte import itertools import numpy as np import pytest from forte import forte_options ref_fci = -5.623851783330647 psi4.core.clean() # need to clean the options otherwise this job will interfere forte.clean_options() h2o = psi4.geometry(""" He He 1 1.0 """) psi4.set_options({'basis': 'cc-pVDZ'}) _, wfn = psi4.energy('scf', return_wfn=True) na = wfn.nalpha() nb = wfn.nbeta() nirrep = wfn.nirrep() wfn_symmetry = 0 forte.startup() forte.banner() psi4_options = psi4.core.get_options() psi4_options.set_current_module('FORTE') forte_options.get_options_from_psi4(psi4_options) # Setup forte and prepare the active space integral class nmopi = wfn.nmopi() point_group = wfn.molecule().point_group().symbol() mo_space_info = forte.make_mo_space_info(nmopi, point_group, forte_options) ints = forte.make_ints_from_psi4(wfn, forte_options, mo_space_info) as_ints = forte.make_active_space_ints(mo_space_info, ints, 'ACTIVE', ['RESTRICTED_DOCC']) print('\n\n => Sparse FCI Test <=') print(' Number of irreps: {}'.format(nirrep)) nmo = wfn.nmo() nmopi = [wfn.nmopi()[h] for h in range(nirrep)] nmopi_str = [str(wfn.nmopi()[h]) for h in range(nirrep)] mo_sym = [] for h in range(nirrep): for i in range(nmopi[h]): mo_sym.append(h) print(' Number of orbitals per irreps: [{}]'.format(','.join(nmopi_str))) print(' Symmetry of the MOs: ', mo_sym) hf_reference = forte.Determinant() hf_reference.create_alfa_bit(0) hf_reference.create_beta_bit(0) print(' Hartree-Fock determinant: {}'.format(hf_reference.str(10))) # Compute the HF energy hf_energy = as_ints.nuclear_repulsion_energy() + as_ints.slater_rules(hf_reference, hf_reference) print(' Nuclear repulsion energy: {}'.format(as_ints.nuclear_repulsion_energy())) print(' Reference energy: {}'.format(hf_energy)) # Build a list of determinants orblist = [i for i in range(nmo)] dets = [] for astr in itertools.combinations(orblist, na): for bstr in itertools.combinations(orblist, nb): sym = 0 d = forte.Determinant() for a in astr: d.create_alfa_bit(a) sym = sym ^ mo_sym[a] for b in bstr: d.create_beta_bit(b) sym = sym ^ mo_sym[b] if (sym == wfn_symmetry): dets.append(d) print(' Determinant {} has symmetry {}'.format(d.str(nmo), sym)) print(f'\n Size of the derminant basis: {len(dets)}') energy, evals, evecs, spin = forte.diag(dets, as_ints, 1, 1, "FULL") print(energy) efci = energy[0] + as_ints.nuclear_repulsion_energy() print('\n FCI Energy: {}\n'.format(efci)) assert efci == pytest.approx(ref_fci, abs=1e-9) # Clean up forte (necessary) forte.cleanup()
def prepare_forte_objects(wfn, mo_spaces=None, active_space='ACTIVE', core_spaces=['RESTRICTED_DOCC'], localize=False, localize_spaces=[]): """Take a psi4 wavefunction object and prepare the ForteIntegrals, SCFInfo, and MOSpaceInfo objects Parameters ---------- wfn : psi4 Wavefunction A psi4 Wavefunction object mo_spaces : dict A dictionary with the size of each space (e.g., {'ACTIVE' : [3]}) active_space : str The MO space treated as active (default: 'ACTIVE') core_spaces : list(str) The MO spaces treated as active (default: ['RESTRICTED_DOCC']) localize : bool Do localize the orbitals? (defaul: False) localize_spaces : list(str) A list of spaces to localize (default: []) Returns ------- tuple(ForteIntegrals, ActiveSpaceIntegrals, SCFInfo, MOSpaceInfo, map(StateInfo : list) a tuple containing the ForteIntegrals, SCFInfo, and MOSpaceInfo objects and a map of states and weights """ # fill in the options object psi4_options = psi4.core.get_options() psi4_options.set_current_module('FORTE') options = forte.forte_options options.get_options_from_psi4(psi4_options) if ('DF' in options.get_str('INT_TYPE')): aux_basis = psi4.core.BasisSet.build( wfn.molecule(), 'DF_BASIS_MP2', psi4.core.get_global_option('DF_BASIS_MP2'), 'RIFIT', psi4.core.get_global_option('BASIS')) wfn.set_basisset('DF_BASIS_MP2', aux_basis) if (options.get_str('MINAO_BASIS')): minao_basis = psi4.core.BasisSet.build( wfn.molecule(), 'MINAO_BASIS', psi4_options.get_str('MINAO_BASIS')) wfn.set_basisset('MINAO_BASIS', minao_basis) # Prepare base objects scf_info = forte.SCFInfo(wfn) nmopi = wfn.nmopi() point_group = wfn.molecule().point_group().symbol() if mo_spaces == None: mo_space_info = forte.make_mo_space_info(nmopi, point_group, options) else: mo_space_info = forte.make_mo_space_info_from_map( nmopi, point_group, mo_spaces, []) state_weights_map = forte.make_state_weights_map(options, mo_space_info) ints = forte.make_ints_from_psi4(wfn, options, mo_space_info) if localize: localizer = forte.Localize(forte.forte_options, ints, mo_space_info) localizer.set_orbital_space(localize_spaces) localizer.compute_transformation() Ua = localizer.get_Ua() ints.rotate_orbitals(Ua, Ua) # the space that defines the active orbitals. We select only the 'ACTIVE' part # the space(s) with non-active doubly occupied orbitals as_ints = forte.make_active_space_ints(mo_space_info, ints, active_space, core_spaces) return (ints, as_ints, scf_info, mo_space_info, state_weights_map)
def gradient_forte(name, **kwargs): r"""Function encoding sequence of PSI module and plugin calls so that forte can be called via :py:func:`~driver.energy`. For post-scf plugins. >>> gradient('forte') available for : CASSCF """ lowername = name.lower() kwargs = p4util.kwargs_lower(kwargs) # Compute a SCF reference, a wavefunction is return which holds the molecule used, orbitals # Fock matrices, and more ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: ref_wfn = psi4.driver.scf_helper(name, **kwargs) # Get the psi4 option object optstash = p4util.OptionsState(['GLOBALS', 'DERTYPE']) psi4_options = psi4.core.get_options() psi4_options.set_current_module('FORTE') # Get the forte option object options = forte.forte_options options.get_options_from_psi4(psi4_options) if ('DF' in options.get_str('INT_TYPE')): raise Exception('analytic gradient is not implemented for density fitting') if (options.get_str('MINAO_BASIS')): minao_basis = psi4.core.BasisSet.build(ref_wfn.molecule(), 'MINAO_BASIS', options.get_str('MINAO_BASIS')) ref_wfn.set_basisset('MINAO_BASIS', minao_basis) # Start Forte, initialize ambit my_proc_n_nodes = forte.startup() my_proc, n_nodes = my_proc_n_nodes # Print the banner forte.banner() # Create the MOSpaceInfo object mo_space_info = forte.make_mo_space_info(ref_wfn, options) # Call methods that project the orbitals (AVAS, embedding) mo_space_info = orbital_projection(ref_wfn, options, mo_space_info) state = forte.make_state_info_from_psi_wfn(ref_wfn) scf_info = forte.SCFInfo(ref_wfn) state_weights_map = forte.make_state_weights_map(options,ref_wfn) # Run a method job_type = options.get_str('JOB_TYPE') energy = 0.0 if not job_type == 'CASSCF': raise Exception('analytic gradient is only implemented for CASSCF') start = time.time() # Make an integral object ints = forte.make_forte_integrals(ref_wfn, options, mo_space_info) # Rotate orbitals before computation orb_type = options.get_str("ORBITAL_TYPE") if orb_type != 'CANONICAL': orb_t = forte.make_orbital_transformation(orb_type, scf_info, options, ints, mo_space_info) orb_t.compute_transformation() Ua = orb_t.get_Ua() Ub = orb_t.get_Ub() ints.rotate_orbitals(Ua,Ub) # Run gradient computation energy = forte.forte_old_methods(ref_wfn, options, ints, mo_space_info) derivobj = psi4.core.Deriv(ref_wfn) derivobj.set_deriv_density_backtransformed(True) derivobj.set_ignore_reference(True) grad = derivobj.compute() #psi4.core.DerivCalcType.Correlated ref_wfn.set_gradient(grad) optstash.restore() end = time.time() #print('\n\n Your calculation took ', (end - start), ' seconds'); # Close ambit, etc. forte.cleanup() return ref_wfn
def run_forte(name, **kwargs): r"""Function encoding sequence of PSI module and plugin calls so that forte can be called via :py:func:`~driver.energy`. For post-scf plugins. >>> energy('forte') """ lowername = name.lower() kwargs = p4util.kwargs_lower(kwargs) # Compute a SCF reference, a wavefunction is return which holds the molecule used, orbitals # Fock matrices, and more ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: ref_wfn = psi4.driver.scf_helper(name, **kwargs) # Get the option object psi4_options = psi4.core.get_options() psi4_options.set_current_module('FORTE') # Get the forte option object options = forte.forte_options options.get_options_from_psi4(psi4_options) if ('DF' in options.get_str('INT_TYPE')): aux_basis = psi4.core.BasisSet.build(ref_wfn.molecule(), 'DF_BASIS_MP2', options.get_str('DF_BASIS_MP2'), 'RIFIT', options.get_str('BASIS')) ref_wfn.set_basisset('DF_BASIS_MP2', aux_basis) if (options.get_str('MINAO_BASIS')): minao_basis = psi4.core.BasisSet.build(ref_wfn.molecule(), 'MINAO_BASIS', options.get_str('MINAO_BASIS')) ref_wfn.set_basisset('MINAO_BASIS', minao_basis) # Start Forte, initialize ambit my_proc_n_nodes = forte.startup() my_proc, n_nodes = my_proc_n_nodes # Print the banner forte.banner() # Create the MOSpaceInfo object mo_space_info = forte.make_mo_space_info(ref_wfn, options) # Call methods that project the orbitals (AVAS, embedding) mo_space_info = orbital_projection(ref_wfn, options, mo_space_info) # Averaging spin multiplets if doing spin-adapted computation if options.get_str('CORRELATION_SOLVER') == 'SA-MRDSRG': options_dict = options.dict() options_dict['SPIN_AVG_DENSITY']['value'] = True options.set_dict(options_dict) state = forte.make_state_info_from_psi_wfn(ref_wfn) scf_info = forte.SCFInfo(ref_wfn) state_weights_map = forte.make_state_weights_map(options,ref_wfn) # Run a method job_type = options.get_str('JOB_TYPE') energy = 0.0 if job_type == 'NONE': forte.cleanup() return ref_wfn start_pre_ints = time.time() # Make an integral object ints = forte.make_forte_integrals(ref_wfn, options, mo_space_info) start = time.time() # Rotate orbitals before computation (e.g. localization, MP2 natural orbitals, etc.) orb_type = options.get_str("ORBITAL_TYPE") if orb_type != 'CANONICAL': orb_t = forte.make_orbital_transformation(orb_type, scf_info, options, ints, mo_space_info) orb_t.compute_transformation() Ua = orb_t.get_Ua() Ub = orb_t.get_Ub() ints.rotate_orbitals(Ua,Ub) # Run a method if (job_type == 'NEWDRIVER'): energy = forte_driver(state_weights_map, scf_info, options, ints, mo_space_info) else: energy = forte.forte_old_methods(ref_wfn, options, ints, mo_space_info) end = time.time() # Close ambit, etc. forte.cleanup() psi4.core.set_scalar_variable('CURRENT ENERGY', energy) psi4.core.print_out(f'\n\n Time to prepare integrals: {start - start_pre_ints:12.3f} seconds') psi4.core.print_out(f'\n Time to run job : {end - start:12.3f} seconds') psi4.core.print_out(f'\n Total : {end - start:12.3f} seconds') return ref_wfn
def test_sparse_ci(): import math import psi4 import forte import itertools import numpy as np import pytest from forte import forte_options ref_fci = -1.101150330132956 psi4.core.clean() h2o = psi4.geometry(""" H H 1 1.0 """) psi4.set_options({'basis': 'sto-3g'}) E_scf, wfn = psi4.energy('scf', return_wfn=True) na = wfn.nalpha() nb = wfn.nbeta() nirrep = wfn.nirrep() wfn_symmetry = 0 forte.startup() forte.banner() psi4_options = psi4.core.get_options() psi4_options.set_current_module('FORTE') forte_options.get_options_from_psi4(psi4_options) # Setup forte and prepare the active space integral class mo_space_info = forte.make_mo_space_info(wfn, forte_options) ints = forte.make_forte_integrals(wfn, forte_options, mo_space_info) as_ints = forte.make_active_space_ints(mo_space_info, ints, 'ACTIVE', ['RESTRICTED_DOCC']) as_ints.print() print('\n\n => Sparse FCI Test <=') print(' Number of irreps: {}'.format(nirrep)) nmo = wfn.nmo() nmopi = [wfn.nmopi()[h] for h in range(nirrep)] nmopi_str = [str(wfn.nmopi()[h]) for h in range(nirrep)] mo_sym = [] for h in range(nirrep): for i in range(nmopi[h]): mo_sym.append(h) print(' Number of orbitals per irreps: [{}]'.format(','.join(nmopi_str))) print(' Symmetry of the MOs: ', mo_sym) hf_reference = forte.Determinant() hf_reference.create_alfa_bit(0) hf_reference.create_beta_bit(0) print(' Hartree-Fock determinant: {}'.format(hf_reference.str(2))) # Compute the HF energy hf_energy = as_ints.nuclear_repulsion_energy() + as_ints.slater_rules( hf_reference, hf_reference) print(' Nuclear repulsion energy: {}'.format( as_ints.nuclear_repulsion_energy())) print(' Reference energy: {}'.format(hf_energy)) # Build a list of determinants orblist = [i for i in range(nmo)] dets = [] for astr in itertools.combinations(orblist, na): for bstr in itertools.combinations(orblist, nb): sym = 0 d = forte.Determinant() for a in astr: d.create_alfa_bit(a) sym = sym ^ mo_sym[a] for b in bstr: d.create_beta_bit(b) sym = sym ^ mo_sym[b] if (sym == wfn_symmetry): dets.append(d) print(' Determinant {} has symmetry {}'.format( d.str(nmo), sym)) # Build the Hamiltonian matrix using 'slater_rules' nfci = len(dets) H = np.ndarray((nfci, nfci)) for I in range(nfci): # off-diagonal terms for J in range(I + 1, nfci): HIJ = as_ints.slater_rules(dets[I], dets[J]) H[I][J] = H[J][I] = HIJ # diagonal term H[I][I] = as_ints.nuclear_repulsion_energy() + as_ints.slater_rules( dets[I], dets[I]) # Find the lowest eigenvalue efci = np.linalg.eigh(H)[0][0] print('\n FCI Energy: {}\n'.format(efci)) assert efci == pytest.approx(ref_fci, 1.0e-9) # Clean up forte (necessary) forte.cleanup()
def prepare_forte_objects_from_fcidump(options, path='.'): fcidump_file = options.get_str('FCIDUMP_FILE') filename = pathlib.Path(path) / fcidump_file psi4.core.print_out( f'\n Reading integral information from FCIDUMP file {filename}') fcidump = forte.proc.fcidump_from_file(filename, convert_to_psi4=True) irrep_size = { 'c1': 1, 'ci': 2, 'c2': 2, 'cs': 2, 'd2': 4, 'c2v': 4, 'c2h': 4, 'd2h': 8 } nmo = len(fcidump['orbsym']) if 'pntgrp' in fcidump: nirrep = irrep_size[fcidump['pntgrp'].lower()] nmopi_list = [fcidump['orbsym'].count(h) for h in range(nirrep)] else: fcidump['pntgrp'] = 'C1' # set the point group to C1 fcidump['isym'] = 0 # shift by -1 nirrep = 1 nmopi_list = [nmo] nmopi_offset = [sum(nmopi_list[0:h]) for h in range(nirrep)] nmopi = psi4.core.Dimension(nmopi_list) # Create the MOSpaceInfo object mo_space_info = forte.make_mo_space_info(nmopi, fcidump['pntgrp'], options) # Call methods that project the orbitals (AVAS, embedding) # skipped due to lack of functionality # manufacture a SCFInfo object from the FCIDUMP file (this assumes C1 symmetry) nel = fcidump['nelec'] ms2 = fcidump['ms2'] na = (nel + ms2) // 2 nb = nel - na if fcidump['pntgrp'] == 'C1': doccpi = psi4.core.Dimension([nb]) soccpi = psi4.core.Dimension([ms2]) else: doccpi = options.get_int_list('FCIDUMP_DOCC') soccpi = options.get_int_list('FCIDUMP_SOCC') if len(doccpi) + len(soccpi) == 0: print( 'Reading a FCIDUMP file that uses symmetry but no DOCC and SOCC is specified.' ) print( 'Use the FCIDUMP_DOCC and FCIDUMP_SOCC options to specify the number of occupied orbitals per irrep.' ) doccpi = psi4.core.Dimension([0] * nirrep) soccpi = psi4.core.Dimension([0] * nirrep) if 'epsilon' in fcidump: epsilon_a = psi4.core.Vector.from_array(fcidump['epsilon']) epsilon_b = psi4.core.Vector.from_array(fcidump['epsilon']) else: # manufacture Fock matrices epsilon_a = psi4.core.Vector(nmo) epsilon_b = psi4.core.Vector(nmo) hcore = fcidump['hcore'] eri = fcidump['eri'] nmo = fcidump['norb'] for i in range(nmo): val = hcore[i, i] for h in range(nirrep): for j in range(nmopi_offset[h], nmopi_offset[h] + doccpi[h] + soccpi[h]): val += eri[i, i, j, j] - eri[i, j, i, j] for j in range(nmopi_offset[h], nmopi_offset[h] + doccpi[h]): val += eri[i, i, j, j] epsilon_a.set(i, val) val = hcore[i, i] for h in range(nirrep): for j in range(nmopi_offset[h], nmopi_offset[h] + doccpi[h] + soccpi[h]): val += eri[i, i, j, j] for j in range(nmopi_offset[h], nmopi_offset[h] + doccpi[h]): val += eri[i, i, j, j] - eri[i, j, i, j] epsilon_b.set(i, val) scf_info = forte.SCFInfo(nmopi, doccpi, soccpi, 0.0, epsilon_a, epsilon_b) state_info = make_state_info_from_fcidump(fcidump, options) state_weights_map = {state_info: [1.0]} return (state_weights_map, mo_space_info, scf_info, fcidump)
def prepare_psi4_ref_wfn(options, **kwargs): """ Prepare a Psi4 Wavefunction as reference for Forte. :param options: a ForteOptions object for options :param kwargs: named arguments associated with Psi4 :return: (the processed Psi4 Wavefunction, a Forte MOSpaceInfo object) Notes: We will create a new Psi4 Wavefunction (wfn_new) if necessary. 1. For an empty ref_wfn, wfn_new will come from Psi4 SCF or MCSCF. 2. For a valid ref_wfn, we will test the orbital orthonormality against molecule. If the orbitals from ref_wfn are consistent with the active geometry, wfn_new will simply be a link to ref_wfn. If not, we will rerun a Psi4 SCF and orthogonalize orbitals, where wfn_new comes from this new Psi4 SCF computation. """ p4print = psi4.core.print_out # grab reference Wavefunction and Molecule from kwargs kwargs = p4util.kwargs_lower(kwargs) ref_wfn = kwargs.get('ref_wfn', None) molecule = kwargs.pop('molecule', psi4.core.get_active_molecule()) point_group = molecule.point_group().symbol() # try to read orbitals from file Ca = read_orbitals() if options.get_bool('READ_ORBITALS') else None need_orbital_check = True fresh_ref_wfn = True if ref_wfn is None else False if ref_wfn is None: ref_type = options.get_str('REF_TYPE') p4print('\n No reference wave function provided for Forte.' f' Computing {ref_type} orbitals using Psi4 ...\n') # no warning printing for MCSCF job_type = options.get_str('JOB_TYPE') do_mcscf = (job_type in ["CASSCF", "MCSCF_TWO_STEP"] or options.get_bool("CASSCF_REFERENCE")) # run Psi4 SCF or MCSCF ref_wfn = run_psi4_ref(ref_type, molecule, not do_mcscf, **kwargs) need_orbital_check = False if Ca is None else True else: # Ca from file has higher priority than that of ref_wfn Ca = ref_wfn.Ca().clone() if Ca is None else Ca # build Forte MOSpaceInfo nmopi = ref_wfn.nmopi() mo_space_info = forte.make_mo_space_info(nmopi, point_group, options) # do we need to check MO overlap? if not need_orbital_check: wfn_new = ref_wfn else: # test if input Ca has the correct dimension if Ca.rowdim() != nmopi or Ca.coldim() != nmopi: raise ValueError( "Invalid orbitals: different basis set / molecule") new_S = psi4.core.Wavefunction.build(molecule, options.get_str("BASIS")).S() if check_MO_orthonormality(new_S, Ca): wfn_new = ref_wfn wfn_new.Ca().copy(Ca) else: if fresh_ref_wfn: wfn_new = ref_wfn wfn_new.Ca().copy(ortho_orbs_forte(wfn_new, mo_space_info, Ca)) else: p4print("\n Perform new SCF at current geometry ...\n") kwargs_copy = { k: v for k, v in kwargs.items() if k != 'ref_wfn' } wfn_new = run_psi4_ref('scf', molecule, False, **kwargs_copy) # orthonormalize orbitals wfn_new.Ca().copy(ortho_orbs_forte(wfn_new, mo_space_info, Ca)) # copy wfn_new to ref_wfn ref_wfn.shallow_copy(wfn_new) # set DF and MINAO basis if 'DF' in options.get_str('INT_TYPE'): aux_basis = psi4.core.BasisSet.build(molecule, 'DF_BASIS_MP2', options.get_str('DF_BASIS_MP2'), 'RIFIT', options.get_str('BASIS')) wfn_new.set_basisset('DF_BASIS_MP2', aux_basis) if options.get_str('MINAO_BASIS'): minao_basis = psi4.core.BasisSet.build(molecule, 'MINAO_BASIS', options.get_str('MINAO_BASIS')) wfn_new.set_basisset('MINAO_BASIS', minao_basis) return wfn_new, mo_space_info
def run_forte(name, **kwargs): r"""Function encoding sequence of PSI module and plugin calls so that forte can be called via :py:func:`~driver.energy`. For post-scf plugins. >>> energy('forte') """ lowername = name.lower() kwargs = p4util.kwargs_lower(kwargs) # Compute a SCF reference, a wavefunction is return which holds the molecule used, orbitals # Fock matrices, and more ref_wfn = kwargs.get('ref_wfn', None) if ref_wfn is None: ref_wfn = psi4.driver.scf_helper(name, **kwargs) # Get the option object options = psi4.core.get_options() options.set_current_module('FORTE') forte.forte_options.update_psi_options(options) if ('DF' in options.get_str('INT_TYPE')): aux_basis = psi4.core.BasisSet.build(ref_wfn.molecule(), 'DF_BASIS_MP2', psi4.core.get_global_option('DF_BASIS_MP2'), 'RIFIT', psi4.core.get_global_option('BASIS')) ref_wfn.set_basisset('DF_BASIS_MP2', aux_basis) if (options.get_str('MINAO_BASIS')): minao_basis = psi4.core.BasisSet.build(ref_wfn.molecule(), 'MINAO_BASIS', options.get_str('MINAO_BASIS')) ref_wfn.set_basisset('MINAO_BASIS', minao_basis) # Start Forte, initialize ambit my_proc_n_nodes = forte.startup() my_proc, n_nodes = my_proc_n_nodes # Print the banner forte.banner() # Create the MOSpaceInfo object mo_space_info = forte.make_mo_space_info(ref_wfn, forte.forte_options) # Call methods that project the orbitals (AVAS, embedding) orbital_projection(ref_wfn, options) state = forte.make_state_info_from_psi_wfn(ref_wfn) scf_info = forte.SCFInfo(ref_wfn) state_weights_map = forte.make_state_weights_map(forte.forte_options,ref_wfn) # Run a method job_type = options.get_str('JOB_TYPE') energy = 0.0 if job_type == 'NONE': forte.cleanup() return ref_wfn start = timeit.timeit() # Make an integral object ints = forte.make_forte_integrals(ref_wfn, options, mo_space_info) # Rotate orbitals before computation orb_type = options.get_str("ORBITAL_TYPE") if orb_type != 'CANONICAL': orb_t = forte.make_orbital_transformation(orb_type, scf_info, forte.forte_options, ints, mo_space_info) orb_t.compute_transformation() Ua = orb_t.get_Ua() Ub = orb_t.get_Ub() ints.rotate_orbitals(Ua,Ub) # Run a method if (job_type == 'NEWDRIVER'): energy = forte_driver(state_weights_map, scf_info, forte.forte_options, ints, mo_space_info) else: energy = forte.forte_old_methods(ref_wfn, options, ints, mo_space_info) end = timeit.timeit() #print('\n\n Your calculation took ', (end - start), ' seconds'); # Close ambit, etc. forte.cleanup() psi4.core.set_scalar_variable('CURRENT ENERGY', energy) return ref_wfn