예제 #1
1
파일: test_dfjk.py 프로젝트: psi4/psi4
def build_system(request):
    mol = psi4.geometry("""
    O
    H 1 1.00
    H 1 1.00 2 103.1
    """)

    memory = 50000

    puream = request.param == "spherical"
    primary = psi4.core.BasisSet.build(mol, "ORBITAL", "cc-pVDZ", puream=puream)
    aux = psi4.core.BasisSet.build(mol, "ORBITAL", "cc-pVDZ-jkfit", puream=puream)

    nbf = primary.nbf()
    naux = aux.nbf()

    # construct spaces
    names = ['C1', 'C2', 'C3', 'C4', 'C5']
    sizes = [16, 16, 20, 20, 30]
    spaces = {names[ind]: psi4.core.Matrix.from_array(np.random.rand(nbf, size)) for ind, size in enumerate(sizes)}
    space_pairs = [[0, 0], [0, 1], [1, 1], [2, 2], [3, 2], [3, 3], [4, 4]]

    # space vectors
    C_vectors = [[spaces[names[left]], spaces[names[right]]] for left, right in space_pairs]

    # DiskJK
    psi4.set_options({"SCF_TYPE": "DISK_DF"})
    DiskJK = psi4.core.JK.build_JK(primary, aux)
    DiskJK.initialize()
    DiskJK.print_header()

    # symm_JK
    psi4.set_options({"SCF_TYPE": "MEM_DF"})
    MemJK = psi4.core.JK.build_JK(primary, aux)
    MemJK.initialize()
    MemJK.print_header()

    # add C matrices
    for Cleft, Cright in C_vectors:
        DiskJK.C_left_add(Cleft)
        MemJK.C_left_add(Cleft)
        DiskJK.C_right_add(Cright)
        MemJK.C_right_add(Cright)

    # compute
    DiskJK.compute()
    MemJK.compute()

    # get integrals
    DiskJK_ints = [DiskJK.J(), DiskJK.K()]
    MemJK_ints = [MemJK.J(), MemJK.K()]

    return (DiskJK_ints, MemJK_ints)
예제 #2
0
def dft_bench_systems():
    ang = np.array([
      [ -1.551007,  -0.114520,   0.000000],
      [ -1.934259,   0.762503,   0.000000],
      [ -0.599677,   0.040712,   0.000000]])
    oldang = ang * 0.52917721067 / 0.52917720859
    oldmass = [15.99491461956, 1.00782503207, 1.00782503207]

    h2o = psi4.core.Molecule.from_arrays(geom=oldang, elez=[8, 1, 1], units='Angstrom', mass=oldmass)
    h2o_plus = psi4.core.Molecule.from_arrays(geom=oldang, elez=[8, 1, 1], units='Angstrom', mass=oldmass,
                                              molecular_charge=1, molecular_multiplicity=2)

    h2o_dimer = psi4.geometry("""
        0 1
        O  -1.551007  -0.114520   0.000000
        H  -1.934259   0.762503   0.000000
        H  -0.599677   0.040712   0.000000
        --
        0 1
        O   1.350625   0.111469   0.000000
        H   1.680398  -0.373741  -0.758561
        H   1.680398  -0.373741   0.758561
        no_reorient
        """)

    psi4.set_options({
       'dft_radial_points': 200,
       'dft_spherical_points': 590,
       'guess': 'sad',
       'e_convergence': 9,
       'd_convergence': 9,
    })

    return {'h2o': h2o, 'h2o_plus': h2o_plus, 'h2o_dimer': h2o_dimer}
예제 #3
0
def restricted_orbitals(basis, labels, coords, charge=0, spin=0, niter=100,
                        e_thresh=1e-12, d_thresh=1e-9, guess='gwh'):
    """restricted Hartree-Fock orbitals

    :param basis: basis set name
    :type basis: str
    :param labels: atomic symbols labeling the nuclei
    :type labels: tuple
    :param coords: nuclear coordinates in Bohr
    :type coords: numpy.ndarray
    :param charge: total molecular charge
    :type charge: int
    :param spin: number of unpaired electrons
    :type spin: int
    :param niter: maximum number of iterations
    :type niter: int
    :param e_thresh: energy convergence threshold
    :type e_thresh: float
    :param d_thresh: density convergence threshold
    :type d_thresh: float
    :param guess: hartree-fock starting guess
    :type guess: str

    :return: orbital coefficients and energies, along with the occupation count
    :rtype: (numpy.ndarray, numpy.ndarray, int)
    """
    psi4.set_options({'e_convergence': e_thresh, 'd_convergence': d_thresh,
                      'maxiter': niter, 'guess': guess, 'reference': 'RHF'})
    mol = psi4_molecule(labels=labels, coords=coords, charge=charge, spin=spin)
    wfn = psi4.core.Wavefunction.build(mol, basis)
    sf, _ = psi4.driver.dft_funcs.build_superfunctional("HF", False)
    hf = psi4.core.RHF(wfn, sf)
    hf.compute_energy()
    return numpy.array(hf.Ca()), numpy.array(hf.epsilon_a()), int(hf.nalpha())
예제 #4
0
def test_gpudfcc2():
    """gpu_dfcc/tests/gpu_dfcc2"""
    #! aug-cc-pvdz (H2O) Test DF-CCSD(T) vs GPU-DF-CCSD(T)

    import psi4

    H20 = psi4.geometry("""
               O          0.000000000000     0.000000000000    -0.068516219310   
               H          0.000000000000    -0.790689573744     0.543701060724   
               H          0.000000000000     0.790689573744     0.543701060724   
    """)

    psi4.set_memory(32000000000)
    psi4.set_options({
      'cc_type': 'df',
      'basis':        'aug-cc-pvdz',
      'freeze_core': 'true',
      'e_convergence': 1e-8,
      'd_convergence': 1e-8,
      'r_convergence': 1e-8,
      'scf_type': 'df',
      'maxiter': 30})
    
    psi4.set_num_threads(2)
    
    en_dfcc     = psi4.energy('ccsd(t)')
    en_gpu_dfcc = psi4.energy('gpu-df-ccsd(t)')
    
    assert psi4.compare_values(en_gpu_dfcc, en_dfcc, 8, "CCSD total energy")
예제 #5
0
def psi4_esp(method, basis, molecule):
    """ Computes QM electrostatic potential

    Parameters
    ----------
    method : str 
        QM method
    basis : str
        basis set
    molecule : psi4.Molecule instance

    Returns
    -------
    np.array
        QM electrostatic potential.

    Note
    -----
    Psi4 read grid information from grid.dat file
    """
    import psi4
    mol = psi4.geometry(molecule.create_psi4_string_from_molecule())
    psi4.set_options({'basis': basis})
    e, wfn = psi4.prop(method, properties=['GRID_ESP'], return_wfn=True)
    psi4.core.clean()
    return np.loadtxt('grid_esp.dat')   
예제 #6
0
def test_uhf():
    """
    test for uhf using (H2O)^+
    """
    print("!!! %s" % os.path.dirname(__file__))
    ao_ints, test_scf_param, e_ZZ_repulsion = scf.init(\
        os.path.dirname(__file__) + "/test_uhf.yml")
    eps, C, D, F = scf.scf(ao_ints, test_scf_param, e_ZZ_repulsion)
    energy = scf.get_SCF_energy(ao_ints['H'], F, D, True) + e_ZZ_repulsion
    print("energy: %f" % energy)

    # psi4 setup
    import psi4
    mol = psi4.geometry("""
    1 2
    O
    H 1 1.1
    H 1 1.1 2 104
    """)
    mol.update_geometry()

    bas = psi4.core.BasisSet.build(mol, target=test_scf_param['basis'])
    mints = psi4.core.MintsHelper(bas)

    # DENSITY FITTED
    psi4.set_options({"scf_type": "pk", "reference": "uhf"})
    psi4_energy = psi4.energy("SCF/cc-pVDZ", molecule = mol)
    print("psi4 energy: %f" % psi4_energy)
    assert(np.allclose(energy, psi4_energy) == True)
예제 #7
0
def test_mp2():
    """
    test for energies
    """
    ao_ints, test_scf_param, e_ZZ_repulsion = scf.init(\
        os.path.dirname(__file__) + "/test_mp2.yml")
    eps, C, D, F = scf.scf(ao_ints, test_scf_param, e_ZZ_repulsion)
    energy = scf.get_SCF_energy(ao_ints['H'], F, D, False) + e_ZZ_repulsion

    # psi4 setup
    import psi4
    mol = psi4.geometry("""
    O
    H 1 1.1
    H 1 1.1 2 104
    """)
    mol.update_geometry()

    bas = psi4.core.BasisSet.build(mol, target="cc-pVDZ")
    mints = psi4.core.MintsHelper(bas)

    # DF-MP2
    psi4.set_options({"scf_type": "df"})
    psi4.set_options({"MP2_type": "CONV"})
    psi4_energy = psi4.energy("MP2/cc-pVDZ", molecule = mol)
    psi4_energy_MP2 = psi4.get_variable('SCS-MP2 TOTAL ENERGY')

    test_scf_param.update({"method": "MP2"})
    test_scf_param.update({"is_fitted": "True"})
    eps, C, D, F = scf.scf(ao_ints, test_scf_param, e_ZZ_repulsion)
    H = ao_ints['T'] + ao_ints['V']
    energy = np.sum((F+H)*D) + e_ZZ_repulsion
    energy_corr = mp2.get_mp2_energy(\
        eps, C, ao_ints['g4'], test_scf_param['nel_alpha'])
    assert(np.allclose(energy + energy_corr, psi4_energy_MP2) == True)
예제 #8
0
def test_cfour():
    """cfour/sp-rhf-ccsd_t_"""
    #! single-point CCSD(T)/qz2p on water

    print('        <<< Translation of ZMAT to Psi4 format to Cfour >>>')

    psi4.geometry("""
    O
    H 1 R
    H 1 R 2 A

    R=0.958
    A=104.5
    """)

    psi4.set_options({
    'cfour_CALC_level': 'CCSD(T)',
    'cfour_BASIS': 'qz2p',
    'cfour_SCF_CONV': 12,
    'cfour_CC_CONV': 12,
    })

    psi4.energy('cfour')

    assert psi4.compare_values(-76.062748460117, psi4.variable('scf total energy'), 6, 'SCF')
    assert psi4.compare_values(-76.332940127333, psi4.variable('mp2 total energy'), 6, 'MP2')
    assert psi4.compare_values(-76.338453951890, psi4.variable('ccsd total energy'), 6, 'CCSD')
    assert psi4.compare_values(-0.275705491773, psi4.variable('ccsd correlation energy'), 6, 'CCSD corl')
    assert psi4.compare_values(-76.345717549886, psi4.variable('ccsd(t) total energy'), 6, 'CCSD(T)')
    assert psi4.compare_values(-0.282969089769, psi4.variable('ccsd(t) correlation energy'), 6, 'CCSD(T) corl')
예제 #9
0
def test_rhf():
    """
    test for rhf
    """
    ao_ints, test_scf_param, e_ZZ_repulsion = scf.init(\
        os.path.dirname(__file__) + "/test_rhf.yml")
    eps, C, D, F = scf.scf(ao_ints, test_scf_param, e_ZZ_repulsion)
    energy = scf.get_SCF_energy(ao_ints['H'], F, D, False) + e_ZZ_repulsion

    # psi4 setup
    import psi4
    mol = psi4.geometry("""
    O
    H 1 1.1
    H 1 1.1 2 104
    """)
    mol.update_geometry()

    bas = psi4.core.BasisSet.build(mol, target="cc-pVDZ")
    mints = psi4.core.MintsHelper(bas)

    # DENSITY FITTED
    psi4.set_options({"scf_type": "df"})
    psi4_energy = psi4.energy("SCF/cc-pVDZ", molecule = mol)
    assert(np.allclose(energy, psi4_energy) == True)
예제 #10
0
def test_gpu_dfcc():
    """gpu_dfcc/tests/gpu_dfcc1"""
    #! cc-pvdz (H2O)2 Test DF-CCSD vs GPU-DF-CCSD

    import gpu_dfcc

    H20 = psi4.geometry("""
               O          0.000000000000     0.000000000000    -0.068516219310
               H          0.000000000000    -0.790689573744     0.543701060724
               H          0.000000000000     0.790689573744     0.543701060724
    """)

    psi4.set_memory(32000000000)
    psi4.set_options({
      'cc_timings': False,
      'num_gpus': 1,
      'cc_type': 'df',
      'df_basis_cc':  'aug-cc-pvdz-ri',
      'df_basis_scf': 'aug-cc-pvdz-jkfit',
      'basis':        'aug-cc-pvdz',
      'freeze_core': 'true',
      'e_convergence': 1e-8,
      'd_convergence': 1e-8,
      'r_convergence': 1e-8,
      'scf_type': 'df',
      'maxiter': 30})
    psi4.set_num_threads(2)
    en_dfcc     = psi4.energy('ccsd', molecule=H20)
    en_gpu_dfcc = psi4.energy('gpu-df-ccsd', molecule=H20)

    assert psi4.compare_values(en_gpu_dfcc, en_dfcc, 8, "CCSD total energy")
예제 #11
0
파일: test_dftd3.py 프로젝트: psi4/psi4
def test_dftd3_dft_grad_lr3():
    """modified VV10-less B97 functional gradient wB97X-V -> wB97X-D3BJ"""

    # stored data from finite differences
    FD_wb97x_d3 = psi4.core.Matrix.from_list([
       [  0.03637802044642,    0.06718963272193,    0.00000000000000],
       [  0.04955519892514,   -0.06340333481039,    0.00000000000000],
       [ -0.07009043821383,   -0.00834477190196,    0.00000000000000],
       [  0.02732425404378,   -0.05883094637658,    0.00000000000000],
       [ -0.02158351760075,    0.03169471018350,    0.05342791683461],
       [ -0.02158351760075,    0.03169471018350,   -0.05342791683461]])

    psi4.geometry("""
    0 1
    O         -1.65542       -0.12330        0.00000
    O          1.24621        0.10269        0.00000
    H         -0.70409        0.03193        0.00000
    H         -2.03867        0.75372        0.00000
    H          1.57599       -0.38252       -0.75856
    H          1.57599       -0.38252        0.75856
    """)

    psi4.set_options({
        'scf_type': 'pk',
        'basis': 'minix',
        'dft_radial_points': 99,
        'dft_spherical_points': 302,
        'e_convergence': 8,
    })

    analytic = psi4.gradient('wB97X-D3BJ', dertype=1)
    assert compare_matrices(analytic, FD_wb97x_d3, 5, "wB97X-D3BJ Analytic vs Store")
예제 #12
0
def test_psi4_cas():
    """casscf-sp"""
    #! CASSCF/6-31G** energy point

    geom = psi4.geometry("""
    O
    H 1 1.00
    H 1 1.00 2 103.1
    """)

    psi4.set_options({
        "basis"           : '6-31G**',
        "reference"       : 'rhf',
        "scf_type"        : 'pk',
        "mcscf_algorithm" : 'ah',
        "qc_module"       : 'detci',
        "nat_orbs"        : True})

    cisd_energy, cisd_wfn = psi4.energy("CISD", return_wfn=True)

    assert psi4.compare_values(-76.2198474477531, cisd_energy, 6, 'CISD Energy')

    psi4.set_options({
        "restricted_docc": [1, 0, 0, 0],
        "active":          [3, 0, 1, 2]})

    casscf_energy = psi4.energy('casscf', ref_wfn=cisd_wfn)

    assert psi4.compare_values(-76.073865006902, casscf_energy, 6, 'CASSCF Energy')
예제 #13
0
def test_restricted_RPA_triplet_c1():
    "Build out the full CIS/TDA hamiltonian (A) col by col with the product engine"
    h2o = psi4.geometry("""
    O
    H 1 0.96
    H 1 0.96 2 104.5
    symmetry c1
    """)
    psi4.set_options({"scf_type": "pk", 'save_jk': True})
    e, wfn = psi4.energy("hf/cc-pvdz", molecule=h2o, return_wfn=True)
    A_ref, B_ref = build_RHF_AB_C1_triplet(wfn)
    ni, na, _, _ = A_ref.shape
    nia = ni * na
    A_ref = A_ref.reshape((nia, nia))
    B_ref = B_ref.reshape((nia, nia))
    P_ref = A_ref + B_ref
    M_ref = A_ref - B_ref
    # Build engine
    eng = TDRSCFEngine(wfn, ptype='rpa', triplet=True)
    # our "guess"" vectors
    ID = [psi4.core.Matrix.from_array(v.reshape((ni, na))) for v in tuple(np.eye(nia).T)]
    Px, Mx = eng.compute_products(ID)[:-1]
    P_test = np.column_stack([x.to_array().flatten() for x in Px])
    assert compare_arrays(P_ref, P_test, 8, "RHF (A+B)x C1 products")
    M_test = np.column_stack([x.to_array().flatten() for x in Mx])
    assert compare_arrays(M_ref, M_test, 8, "RHF (A-B)x C1 products")
예제 #14
0
def test_unrestricted_RPA_C1():
    ch2 = psi4.geometry("""
    0 3
    c
    h 1 1.0
    h 1 1.0 2 125.0
    symmetry c1
    """)
    psi4.set_options({"scf_type": "pk", 'reference': 'UHF', 'save_jk': True})
    e, wfn = psi4.energy("hf/cc-pvdz", molecule=ch2, return_wfn=True)
    A_ref, B_ref = build_UHF_AB_C1(wfn)
    nI, nA, _, _ = A_ref['IAJB'].shape
    nIA = nI * nA
    ni, na, _, _ = A_ref['iajb'].shape
    nia = ni * na

    P_ref = {k: A_ref[k] + B_ref[k] for k in A_ref.keys()}
    M_ref = {k: A_ref[k] - B_ref[k] for k in A_ref.keys()}

    eng = TDUSCFEngine(wfn, ptype='rpa')
    X_jb = [psi4.core.Matrix.from_array(v.reshape((ni, na))) for v in tuple(np.eye(nia).T)]
    zero_jb = [psi4.core.Matrix(ni, na) for x in range(nIA)]
    X_JB = [psi4.core.Matrix.from_array(v.reshape((nI, nA))) for v in tuple(np.eye(nIA).T)]
    zero_JB = [psi4.core.Matrix(nI, nA) for x in range(nia)]
    # Guess Identity:
    #     X_I0          X_0I          =      X_I0      X_0I
    # [ I{nOV x nOV} | 0{nOV x nov}]  = [ X{KC,JB} | 0{KC, jb}]
    # [ 0{nov x nOV} | I{nov x nov}]    [ 0{kc,JB} | X{kc, jb}]

    # Products:
    # [ A+/-B{IA, KC}  A+/-B{IA, kc}] [ I{KC, JB} |  0{KC,jb}] = [A+/-B x X_I0] = [ (A+/-B)_IAJB, (A+/-B)_iaJB]
    # [ A+/-B{ia, KC}  A+/-B{ia, kc}] [ O{kc, JB} |  X{kc,jb}]   [A+/-B x X_0I] = [ (A+/-B)_IAjb, (A+/-B)_iajb]
    X_I0 = [[x, zero] for x, zero in zip(X_JB, zero_jb)]
    X_0I = [[zero, x] for zero, x in zip(zero_JB, X_jb)]
    Px_I0, Mx_I0 = eng.compute_products(X_I0)[:-1]
    Px_0I, Mx_0I = eng.compute_products(X_0I)[:-1]

    P_IAJB_test = np.column_stack([x[0].to_array().flatten() for x in Px_I0])
    assert compare_arrays(P_ref['IAJB'].reshape(nIA, nIA), P_IAJB_test, 8, "A_IAJB")

    M_IAJB_test = np.column_stack([x[0].to_array().flatten() for x in Mx_I0])
    assert compare_arrays(M_ref['IAJB'].reshape(nIA, nIA), M_IAJB_test, 8, "A_IAJB")

    P_iaJB_test = np.column_stack([x[1].to_array().flatten() for x in Px_I0])
    assert compare_arrays(P_ref['iaJB'].reshape(nia, nIA), P_iaJB_test, 8, "P_iaJB")

    M_iaJB_test = np.column_stack([x[1].to_array().flatten() for x in Mx_I0])
    assert compare_arrays(M_ref['iaJB'].reshape(nia, nIA), M_iaJB_test, 8, "M_iaJB")

    P_IAjb_test = np.column_stack([x[0].to_array().flatten() for x in Px_0I])
    assert compare_arrays(P_ref['IAjb'].reshape(nIA, nia), P_IAjb_test, 8, "P_IAjb")

    M_IAjb_test = np.column_stack([x[0].to_array().flatten() for x in Mx_0I])
    assert compare_arrays(M_ref['IAjb'].reshape(nIA, nia), M_IAjb_test, 8, "M_IAjb")

    P_iajb_test = np.column_stack([x[1].to_array().flatten() for x in Px_0I])
    assert compare_arrays(P_ref['iajb'].reshape(nia, nia), P_iajb_test, 8, "P_iajb")

    M_iajb_test = np.column_stack([x[1].to_array().flatten() for x in Mx_0I])
    assert compare_arrays(M_ref['iajb'].reshape(nia, nia), M_iajb_test, 8, "M_iajb")
예제 #15
0
def disabled_test_forte():
    """aci-10: Perform aci on benzyne"""

    import forte

    refscf    = -229.20378006852584
    refaci    = -229.359450812283
    refacipt2 = -229.360444943286

    mbenzyne = psi4.geometry("""
      0 1
       C   0.0000000000  -2.5451795941   0.0000000000
       C   0.0000000000   2.5451795941   0.0000000000
       C  -2.2828001669  -1.3508352528   0.0000000000
       C   2.2828001669  -1.3508352528   0.0000000000
       C   2.2828001669   1.3508352528   0.0000000000
       C  -2.2828001669   1.3508352528   0.0000000000
       H  -4.0782187459  -2.3208602146   0.0000000000
       H   4.0782187459  -2.3208602146   0.0000000000
       H   4.0782187459   2.3208602146   0.0000000000
       H  -4.0782187459   2.3208602146   0.0000000000

      units bohr
    """)

    psi4.set_options({
       'basis': 'DZ',
       'df_basis_mp2': 'cc-pvdz-ri',
       'reference': 'uhf',
       'scf_type': 'pk',
       'd_convergence': 10,
       'e_convergence': 12,
       'guess': 'gwh',
    })

    psi4.set_module_options("FORTE", {
      'root_sym': 0,
      'frozen_docc':     [2,1,0,0,0,0,2,1],
      'restricted_docc': [3,2,0,0,0,0,2,3],
      'active':          [1,0,1,2,1,2,1,0],
      'multiplicity': 1,
      'aci_nroot': 1,
      'job_type': 'aci',
      'sigma': 0.001,
      'aci_select_type': 'aimed_energy',
      'aci_spin_projection': 1,
      'aci_enforce_spin_complete': True,
      'aci_add_aimed_degenerate': False,
      'aci_project_out_spin_contaminants': False,
      'diag_algorithm': 'full',
      'aci_quiet_mode': True,
    })

    scf = psi4.energy('scf')
    assert psi4.compare_values(refscf, scf,10,"SCF Energy")

    psi4.energy('forte')
    assert psi4.compare_values(refaci, psi4.variable("ACI ENERGY"),10,"ACI energy")
    assert psi4.compare_values(refacipt2, psi4.variable("ACI+PT2 ENERGY"),8,"ACI+PT2 energy")
예제 #16
0
def test_dft_bench_interaction(func, expected, basis, dft_bench_systems, request):
    """functionals interaction energies vs. Q-Chem & Orca"""
    if func.lower() in psi4.driver.procedures['energy']:
        mols = dft_bench_systems
        psi4.set_options({'basis': basis})
        psi4_ie = psi4.energy(func, molecule=mols['h2o_dimer'], bsse_type='nocp')
        assert compare_values(expected, psi4_ie, 4, request.node.name)
    else:
        pytest.skip("{0:s} not in Psi4.".format(func))
예제 #17
0
def test_libefp():
    """libefp/qchem-qmefp-sp"""
    #! EFP on mixed QM (water) and EFP (water + 2 * ammonia) system.
    #! An EFP-only calc performed first to test vales against q-chem.

    qmefp = psi4.geometry("""
    # QM fragment
    0 1
    units bohr
    O1     0.000000000000     0.000000000000     0.224348285559
    H2    -1.423528800232     0.000000000000    -0.897393142237
    H3     1.423528800232     0.000000000000    -0.897393142237
    # EFP as EFP fragments
    --
    efp h2o -4.014110144291     2.316749370493    -1.801514729931 -2.902133 1.734999 -1.953647
    --
    efp NH3,1.972094713645,,3.599497221584 ,    5.447701074734 -1.105309 2.033306 -1.488582
    --
    efp NH3 -7.876296399270    -1.854372164887    -2.414804197762  2.526442 1.658262 -2.742084
    """)

    #  <<<  EFP calc  >>>
    psi4.set_options({
        'basis': '6-31g*',
        'scf_type': 'pk',
        'guess': 'core',
        'df_scf_guess': False})

    psi4.energy('efp')
    assert psi4.compare_values( 9.1793879214, qmefp.nuclear_repulsion_energy(), 6, 'QM NRE')
    assert psi4.compare_values(-0.0004901368, psi4.variable('efp elst energy'), 6, 'EFP-EFP Elst')  # from q-chem
    assert psi4.compare_values(-0.0003168768, psi4.variable('efp ind energy'), 6, 'EFP-EFP Indc')
    assert psi4.compare_values(-0.0021985285, psi4.variable('efp disp energy'), 6, 'EFP-EFP Disp')  # from q-chem
    assert psi4.compare_values( 0.0056859871, psi4.variable('efp exch energy'), 6, 'EFP-EFP Exch')  # from q-chem
    assert psi4.compare_values( 0.0026804450, psi4.variable('efp total energy'), 6, 'EFP-EFP Totl')
    assert psi4.compare_values( 0.0026804450, psi4.variable('current energy'), 6, 'Current')
    psi4.core.print_variables()

    psi4.core.clean()
    psi4.core.clean_variables()

    #  <<<  QM + EFP calc  >>>
    psi4.set_options({
        'e_convergence': 12,
        'd_convergence': 12})
    psi4.energy('scf')

    assert psi4.compare_values( 9.1793879214, qmefp.nuclear_repulsion_energy(), 6, 'QM NRE')
    assert psi4.compare_values( 0.2622598847, psi4.variable('efp total energy') - psi4.variable('efp ind energy'), 6, 'EFP corr to SCF')  # from q-chem
    assert psi4.compare_values(-0.0117694790, psi4.variable('efp ind energy'), 6, 'QM-EFP Indc')  # from q-chem
    assert psi4.compare_values(-0.0021985285, psi4.variable('efp disp energy'), 6, 'EFP-EFP Disp')  # from q-chem
    assert psi4.compare_values( 0.0056859871, psi4.variable('efp exch energy'), 6, 'EFP-EFP Exch')  # from q-chem
    assert psi4.compare_values( 0.2504904057, psi4.variable('efp total energy'), 6, 'EFP-EFP Totl')  # from q-chem
    assert psi4.compare_values(-76.0139362744, psi4.variable('scf total energy'), 6, 'SCF')  # from q-chem
    psi4.core.print_variables()
예제 #18
0
def test_dft_bench_ionization(func, expected, basis, dft_bench_systems, request):
    """functionals ionization energies vs. Q-Chem"""
    if func.lower() in psi4.driver.procedures['energy']:
        mols = dft_bench_systems
        psi4.set_options({'basis': basis, 'reference': 'uks'})
        cation  = psi4.energy(func, molecule=mols['h2o_plus'])
        psi4.set_options({'reference': 'rks'})
        neutral = psi4.energy(func, molecule=mols['h2o'])
        assert compare_values(expected, cation - neutral, 4, request.node.name)
    else:
        pytest.skip("{0:s} not in Psi4.".format(func))
예제 #19
0
파일: rhf.py 프로젝트: CCQC/summer-program
	def psiSCF(self):

		psi4.core.set_output_file("output.dat",False)

		psi4.set_options({'basis': self.options['DEFAULT']['basis'],
						  'scf_type': 'pk',
						  'reference': 'rhf',
						  'puream': 0,
						  'print': 0 })

		return psi4.energy('scf')
예제 #20
0
def test_psi4_sapt():
    """sapt1"""
    #! SAPT0 cc-pVDZ computation of the ethene-ethyne interaction energy, using the cc-pVDZ-JKFIT RI basis for SCF
    #! and cc-pVDZ-RI for SAPT.  Monomer geometries are specified using Cartesian coordinates.

    Eref = [ 85.189064196429101,  -0.00359915058,  0.00362911158,
             -0.00083137117,      -0.00150542374, -0.00230683391 ]

    ethene_ethyne = psi4.geometry("""
         0 1
         C     0.000000    -0.667578    -2.124659
         C     0.000000     0.667578    -2.124659
         H     0.923621    -1.232253    -2.126185
         H    -0.923621    -1.232253    -2.126185
         H    -0.923621     1.232253    -2.126185
         H     0.923621     1.232253    -2.126185
         --
         0 1
         C     0.000000     0.000000     2.900503
         C     0.000000     0.000000     1.693240
         H     0.000000     0.000000     0.627352
         H     0.000000     0.000000     3.963929
         units angstrom
    """)

    # this molecule will crash test if molecule passing broken
    barrier = psi4.geometry("""
     0 1
     He
    """)

    psi4.set_options({
        "basis": "cc-pvdz",
        "guess": "sad",
        "scf_type": "df",
        "sad_print": 2,
        "d_convergence": 11,
        "puream": True,
        "print": 1})

    psi4.energy('sapt0', molecule=ethene_ethyne)

    Eelst = psi4.get_variable("SAPT ELST ENERGY")
    Eexch = psi4.get_variable("SAPT EXCH ENERGY")
    Eind  = psi4.get_variable("SAPT IND ENERGY")
    Edisp = psi4.get_variable("SAPT DISP ENERGY")
    ET    = psi4.get_variable("SAPT0 TOTAL ENERGY")

    assert psi4.compare_values(Eref[0], ethene_ethyne.nuclear_repulsion_energy(), 9, "Nuclear Repulsion Energy")
    assert psi4.compare_values(Eref[1], Eelst, 6, "SAPT0 Eelst")
    assert psi4.compare_values(Eref[2], Eexch, 6, "SAPT0 Eexch")
    assert psi4.compare_values(Eref[3], Eind, 6, "SAPT0 Eind")
    assert psi4.compare_values(Eref[4], Edisp, 6, "SAPT0 Edisp")
    assert psi4.compare_values(Eref[5], ET, 6, "SAPT0 Etotal")
예제 #21
0
 def _build_wfn(ref, func, basis, nosym):
     if ref.startswith('RHF'):
         mol = tddft_systems['RHF']
     else:
         mol = tddft_systems['UHF']
         psi4.set_options({'reference': 'UHF'})
     if nosym:
         mol.reset_point_group('c1')
     psi4.set_options({'scf_type': 'pk', 'e_convergence': 8, 'd_convergence': 8, 'save_jk': True})
     e, wfn = psi4.energy("{}/{}".format(func, basis), return_wfn=True, molecule=mol)
     return wfn
예제 #22
0
def test_gdma():
    """gdma1"""
    #! Water RHF/cc-pVTZ distributed multipole analysis

    ref_energy = -76.0571685433842219
    ref_dma_mat = psi4.core.Matrix(3, 9)
    ref_dma_mat.name = 'Reference DMA values'
    ref_dma_arr = [
      [ -0.43406697290168, -0.18762673939633,  0.00000000000000,  0.00000000000000,  0.03206686487531,
         0.00000000000000, -0.00000000000000, -0.53123477172696,  0.00000000000000 ],
      [  0.21703348903257, -0.06422316619952,  0.00000000000000, -0.11648289410022,  0.01844320206227,
         0.00000000000000,  0.07409226544133, -0.07115302332866,  0.00000000000000 ],
      [  0.21703348903257, -0.06422316619952,  0.00000000000000,  0.11648289410022,  0.01844320206227,
         0.00000000000000, -0.07409226544133, -0.07115302332866,  0.00000000000000 ]
    ]
    for i in range(3):
        for j in range(9):
            ref_dma_mat.set(i, j, ref_dma_arr[i][j])
    ref_tot_mat = psi4.core.Matrix(1, 9)
    ref_tot_mat.name = "Reference total values"
    ref_tot_arr = [
         0.00000000516346, -0.79665315928128,  0.00000000000000,  0.00000000000000,  0.10813259329390,
         0.00000000000000,  0.00000000000000, -2.01989585894142,  0.00000000000000
    ]
    for i in range(9):
        ref_tot_mat.set(0, i, ref_tot_arr[i])

    # noreorient/nocom are not needed, but are used here to guarantee that the
    #   GDMA origin placement defined below is at the O atom.
    water = psi4.geometry("""
        O  0.000000  0.000000  0.117176
        H -0.000000 -0.756950 -0.468706
        H -0.000000  0.756950 -0.468706
     noreorient
     nocom
    """)

    psi4.set_options({"scf_type": "pk",
                       "basis": "cc-pvtz",
                       "d_convergence": 10,
                       "gdma_switch": 0,
                       "gdma_radius": [ "H", 0.65 ],
                       "gdma_limit": 2,
                       "gdma_origin": [ 0.000000,  0.000000,  0.117176 ]})

    energy, wfn = psi4.energy('scf', return_wfn=True)

    psi4.gdma(wfn)
    dmavals = psi4.core.variable("DMA DISTRIBUTED MULTIPOLES")
    totvals = psi4.core.variable("DMA TOTAL MULTIPOLES")
    assert psi4.compare_values(ref_energy, energy, 8, "SCF Energy")
    assert psi4.compare_matrices(dmavals, ref_dma_mat, 6, "DMA Distributed Multipoles")
    assert psi4.compare_matrices(totvals, ref_tot_mat, 6, "DMA Total Multipoles")
예제 #23
0
파일: test_addons.py 프로젝트: bennybp/psi4
def test_v2rdm_casscf():
    """v2rdm_casscf/tests/v2rdm1"""
    #! cc-pvdz N2 (6,6) active space Test DQG

    print('        N2 / cc-pVDZ / DQG(6,6), scf_type = CD / 1e-12, rNN = 0.5 A')

    import v2rdm_casscf

    n2 = psi4.geometry("""
    0 1
    n
    n 1 r
    """)

    interloper = psi4.geometry("""
    0 1
    O
    H 1 1.0
    H 1 1.0 2 90.0
    """)

    psi4.set_options({
      'basis': 'cc-pvdz',
      'scf_type': 'cd',
      'cholesky_tolerance': 1e-12,
      'd_convergence': 1e-10,
      'maxiter': 500,
      'restricted_docc': [ 2, 0, 0, 0, 0, 2, 0, 0 ],
      'active': [ 1, 0, 1, 1, 0, 1, 1, 1 ],
    })
    ##psi4.set_module_options('v2rdm_casscf', {
    psi4.set_options({
    #  'positivity': 'dqg',
      'r_convergence': 1e-5,
      'e_convergence': 1e-6,
      'maxiter': 20000,
    #  #'orbopt_frequency': 1000,
    #  #'mu_update_frequency': 1000,
    })

    psi4.activate(n2)

    n2.r     = 0.5
    refscf   = -103.04337420425350
    refv2rdm = -103.086205379481

    psi4.energy('v2rdm-casscf', molecule=n2)

    assert psi4.compare_values(refscf, psi4.get_variable("SCF TOTAL ENERGY"), 8, "SCF total energy")
    assert psi4.compare_values(refv2rdm, psi4.get_variable("CURRENT ENERGY"), 5, "v2RDM-CASSCF total energy")
예제 #24
0
def test_psi4_basic():
    """tu1-h2o-energy"""
    #! Sample HF/cc-pVDZ H2O computation

    h2o = psi4.geometry("""
      O
      H 1 0.96
      H 1 0.96 2 104.5
    """)

    psi4.set_options({'basis': "cc-pVDZ"})
    psi4.energy('scf')

    assert psi4.compare_values(-76.0266327341067125, psi4.get_variable('SCF TOTAL ENERGY'), 6, 'SCF energy')
예제 #25
0
def test_mp2_module(inp, clsd_open_pmols, request):
    tnm = request.node.name
    subject = clsd_open_pmols[inp['subject']]

    ref_block = _ref_module[inp['options']['scf_type']][inp['options']['reference']]
    ref_ref = ref_block['HF TOTAL ENERGY']
    ref_block = ref_block[inp['options']['freeze_core']][inp['options']['mp2_type']]
    ref_corl = ref_block['MP2 CORRELATION ENERGY']
    ref_tot = ref_block['MP2 TOTAL ENERGY']

    psi4.set_options({
        'basis': 'cc-pvdz',
        'guess': 'sad',
        'e_convergence': 8,
        'd_convergence': 7,
    })
    psi4.set_options(inp['options'])

    if inp['driver'] == 'energy':
        ene, wfn = psi4.energy('mp2', molecule=subject, return_wfn=True)

    elif inp['driver'] == 'gradient':
        grad, wfn = psi4.gradient('mp2', molecule=subject, return_wfn=True)
        ref_tot_grad = ref_block['MP2 TOTAL GRADIENT']

    for obj in [psi4.core, wfn]:
        for pv in ['HF TOTAL ENERGY', 'SCF TOTAL ENERGY', 'CURRENT REFERENCE ENERGY']:
            assert compare_values(ref_ref, obj.variable(pv), 6, tnm + ' ' + pv)

        for pv in [
                'MP2 CORRELATION ENERGY',
                'CURRENT CORRELATION ENERGY',
        ]:
            assert compare_values(ref_corl, obj.variable(pv), 6, tnm + ' ' + pv)

        for pv in [
                'MP2 TOTAL ENERGY',
                'CURRENT ENERGY',
        ]:
            assert compare_values(ref_tot, obj.variable(pv), 6, tnm + ' ' + pv)

    assert compare_values(ref_tot, wfn.energy(), 6, tnm + ' wfn')

    if inp['driver'] == 'energy':
        assert compare_values(ref_tot, ene, 6, tnm + ' return')

    elif inp['driver'] == 'gradient':
        assert compare_matrices(ref_tot_grad, wfn.gradient(), 6, tnm + ' grad wfn')
        assert compare_matrices(ref_tot_grad, grad, 6, tnm + ' grad return')
예제 #26
0
def test_opt():
    """
    We pick the physicist's water molecule in a relatively large
    basis set (aug-cc-pVDZ), whose uhf and rhf solutions are the
    same. And we test that energies of the following four cases
    are identical:
        RHF + DIIS
        RHF + ODA
        UHF + DIIS
        UHF + ODA
    Note for DIIS, we in addition require the convergence is achieved
    in 30 iterations.
    """
    # get integrals from psi4
    ao_ints, scf_params, e_ZZ_repul = \
        scf.init(os.path.dirname(__file__) + '/test_opt.yml')
    # RHF, DIIS
    scf_params['max_iter'] = 30
    eps, C, D, F = scf.scf(ao_ints, scf_params, e_ZZ_repul)
    E_rhf_diis = scf.get_SCF_energy(ao_ints['H'], F, D, False) + e_ZZ_repul
    # RHF, ODA
    scf_params['max_iter'] = 300
    scf_params['opt'] = "oda"
    eps, C, D, F = scf.scf(ao_ints, scf_params, e_ZZ_repul)
    E_rhf_oda = scf.get_SCF_energy(ao_ints['H'], F, D, False) + e_ZZ_repul
    # UHF, DIIS
    scf_params['max_iter'] = 30
    scf_params['opt'] = "diis"
    scf_params['unrestricted'] = True
    eps, C, D, F = scf.scf(ao_ints, scf_params, e_ZZ_repul)
    E_uhf_diis = scf.get_SCF_energy(ao_ints['H'], F, D, True) + e_ZZ_repul
    # UHF, ODA
    scf_params['max_iter'] = 300
    scf_params['opt'] = "oda"
    eps, C, D, F = scf.scf(ao_ints, scf_params, e_ZZ_repul)
    E_uhf_oda = scf.get_SCF_energy(ao_ints['H'], F, D, True) + e_ZZ_repul
    # RHF, psi4
    import psi4
    mol = psi4.geometry(scf_params['geometry'])
    mol.update_geometry()
    ctrl_string = "SCF/" + scf_params['basis']
    psi4.set_options({"scf_type": "pk"})
    psi4_E_rhf = psi4.energy(ctrl_string, molecule = mol)
    # check
    assert(np.allclose(E_rhf_diis, E_rhf_oda) == True)
    assert(np.allclose(E_rhf_diis, E_uhf_diis) == True)
    assert(np.allclose(E_rhf_diis, E_uhf_oda) == True)
    assert(np.allclose(E_rhf_diis, psi4_E_rhf) == True)
예제 #27
0
파일: mp2.py 프로젝트: CCQC/summer-program
	def psiMP2(self,options):

		psi4.core.set_output_file("output.dat",False)

		psi4.set_options({'basis': options['DEFAULT']['basis'],
						  'scf_type': 'pk',
						  'reference': 'uhf',
						  'e_convergence': 12,
						  'df_basis_mp2' : self.dfBasisName,
						  'puream': 0,
						  'print': 0 })

		if not self.df:
			psi4.set_options( {'mp2_type': 'conv'} )

		return psi4.energy('mp2')
예제 #28
0
def test_RU_TDA_C1():
    h2o = psi4.geometry("""0 1
    O          0.000000    0.000000    0.135446
    H         -0.000000    0.866812   -0.541782
    H         -0.000000   -0.866812   -0.541782
    symmetry c1
    no_reorient
    no_com
    """)
    psi4.set_options({"scf_type": "pk", 'save_jk': True})
    e, wfn = psi4.energy("hf/sto-3g", molecule=h2o, return_wfn=True)
    A_ref, _ = build_UHF_AB_C1(wfn)
    ni, na, _, _ = A_ref['IAJB'].shape
    nia = ni * na
    A_sing_ref = A_ref['IAJB'] + A_ref['IAjb']
    A_sing_ref = A_sing_ref.reshape(nia, nia)
    A_trip_ref = A_ref['IAJB'] - A_ref['IAjb']
    A_trip_ref = A_trip_ref.reshape(nia, nia)
    sing_vals, _ = np.linalg.eigh(A_sing_ref)
    trip_vals, _ = np.linalg.eigh(A_trip_ref)

    trip_eng = TDRSCFEngine(wfn, ptype='tda', triplet=True)
    sing_eng = TDRSCFEngine(wfn, ptype='tda', triplet=False)
    ID = [psi4.core.Matrix.from_array(v.reshape((ni, na))) for v in tuple(np.eye(nia).T)]
    psi4.core.print_out("\nA sing:\n" + str(A_sing_ref) + "\n\n")
    psi4.core.print_out("\nA trip:\n" + str(A_trip_ref) + "\n\n")
    A_trip_test = np.column_stack([x.to_array().flatten() for x in trip_eng.compute_products(ID)[0]])
    assert compare_arrays(A_trip_ref, A_trip_test, 8, "Triplet Ax C1 products")
    A_sing_test = np.column_stack([x.to_array().flatten() for x in sing_eng.compute_products(ID)[0]])
    assert compare_arrays(A_sing_ref, A_sing_test, 8, "Singlet Ax C1 products")

    sing_vals_2, _ = np.linalg.eigh(A_sing_test)
    trip_vals_2, _ = np.linalg.eigh(A_trip_test)

    psi4.core.print_out("\n\n SINGLET EIGENVALUES\n")
    for x, y in zip(sing_vals, sing_vals_2):
        psi4.core.print_out("{:10.6f}  {:10.6f}\n".format(x, y))
        # assert compare_values(x, y, 4, "Singlet ROOT")
    psi4.core.print_out("\n\n Triplet EIGENVALUES\n")
    for x, y in zip(trip_vals, trip_vals_2):
        psi4.core.print_out("{:10.6f}  {:10.6f}\n".format(x, y))
        # assert compare_values(x, y, 4, "Triplet Root")

    for x, y in zip(sing_vals, sing_vals_2):
        assert compare_values(x, y, 4, "Singlet ROOT")
    for x, y in zip(trip_vals, trip_vals_2):
        assert compare_values(x, y, 4, "Triplet Root")
예제 #29
0
def test_chemps2():
    """chemps2/scf-n2"""
    #! dmrg-scf on N2

    N2 = psi4.geometry("""
      N       0.0000   0.0000   0.0000
      N       0.0000   0.0000   2.1180
    units au
    """)

    psi4.set_options({
    'basis': 'cc-pVDZ',
    'reference': 'rhf',
    'e_convergence': 1e-12,
    'd_convergence': 1e-12,

    'dmrg_irrep': 0,
    'dmrg_multiplicity': 1,
    'restricted_docc': [ 1 , 0 , 0 , 0 , 0 , 1 , 0 , 0 ],
    'active': [ 2 , 0 , 1 , 1 , 0 , 2 , 1 , 1 ],

    'dmrg_sweep_states': [   500,  1000,  1000 ],
    'dmrg_sweep_energy_conv': [ 1e-10, 1e-10, 1e-10 ],
    'dmrg_sweep_dvdson_rtol': [  1e-4,  1e-6,  1e-8 ],
    'dmrg_sweep_max_sweeps': [     5,     5,    10 ],
    'dmrg_sweep_noise_prefac': [  0.05,  0.05,   0.0 ],
    'dmrg_print_corr': True,
    'dmrg_mps_write': False,

    'dmrg_unitary_write': True,
    'dmrg_diis': True,
    'dmrg_scf_diis_thr': 1e-2,
    'dmrg_diis_write': True,

    'dmrg_excitation': 0,   # Ground state
    'dmrg_scf_state_avg': False,
    'dmrg_scf_active_space': 'NO',  # INPUT; NO; LOC
    'dmrg_local_init': False,
    })

    psi4.energy("dmrg-scf")

    ref_energy = -109.1035023353
    assert psi4.compare_values(ref_energy, psi4.variable("CURRENT ENERGY"), 6, "DMRG Energy")
예제 #30
0
def test_dkh():
    """dkh/molpro-2order"""

    Ne = psi4.geometry("""
    0 1
    Ne
    """)

    psi4.set_options({
        'reference': 'rhf',
        'basis': 'cc-pvtz-dk',
        'relativistic': 'dkh',
        'dkh_order': 2,
        'print': 2,
        'scf_type': 'pk'})

    e = psi4.energy('scf')

    assert psi4.compare_values(-128.66891610, e, 6, '2nd order vs Molpro')
예제 #31
0
파일: CCSD_T.py 프로젝트: jturney/psi4numpy
np.set_printoptions(precision=5, linewidth=200, suppress=True)
import psi4

psi4.core.set_memory(int(2e9), False)
psi4.core.set_output_file('output.dat', False)

numpy_memory = 2

mol = psi4.geometry("""
O
H 1 1.1
H 1 1.1 2 104
symmetry c1
""")

psi4.set_options({'basis': 'cc-pVDZ'})

# For numpy
compare_psi4 = True

# Compute CCSD
ccsd = helper_CCSD(mol, memory=2)
ccsd.compute_energy()

CCSDcorr_E = ccsd.ccsd_corr_e
CCSD_E = ccsd.ccsd_e

print('\nFinal CCSD correlation energy:          % 16.10f' % CCSDcorr_E)
print('Total CCSD energy:                      % 16.10f' % CCSD_E)

# Triples correction required o^3v^3 storage due the noddy algorithm
예제 #32
0
파일: test_addons.py 프로젝트: votavap/psi4
def test_dftd3():
    """dftd3/energy"""
    #! Exercises the various DFT-D corrections, both through python directly and through c++

    ref_d2         = [-0.00390110, -0.00165271, -0.00058118]
    ref_d3zero     = [-0.00285088, -0.00084340, -0.00031923]
    ref_d3bj       = [-0.00784595, -0.00394347, -0.00226683]

    ref_pbe_d2     = [-0.00278650, -0.00118051, -0.00041513]
    ref_pbe_d3zero = [-0.00175474, -0.00045421, -0.00016839]
    ref_pbe_d3bj   = [-0.00475937, -0.00235265, -0.00131239]

    eneyne = psi4.geometry("""
    C   0.000000  -0.667578  -2.124659
    C   0.000000   0.667578  -2.124659
    H   0.923621  -1.232253  -2.126185
    H  -0.923621  -1.232253  -2.126185
    H  -0.923621   1.232253  -2.126185
    H   0.923621   1.232253  -2.126185
    --
    C   0.000000   0.000000   2.900503
    C   0.000000   0.000000   1.693240
    H   0.000000   0.000000   0.627352
    H   0.000000   0.000000   3.963929
    """)

    psi4.print_stdout('  -D correction from Py-side')
    eneyne.update_geometry()
    E, G = eneyne.run_dftd3('b3lyp', 'd2gr')
    assert psi4.compare_values(ref_d2[0], E, 7, 'Ethene-Ethyne -D2')
    mA = eneyne.extract_subsets(1)
    E, G = mA.run_dftd3('b3lyp', 'd2gr')
    assert psi4.compare_values(ref_d2[1], E, 7, 'Ethene -D2')
    mB = eneyne.extract_subsets(2)
    E, G = mB.run_dftd3('b3lyp', 'd2gr')
    assert psi4.compare_values(ref_d2[2], E, 7, 'Ethyne -D2')
    #mBcp = eneyne.extract_subsets(2,1)
    #E, G = mBcp.run_dftd3('b3lyp', 'd2gr')
    #compare_values(ref_d2[2], E, 7, 'Ethyne(CP) -D2')

    E, G = eneyne.run_dftd3('b3lyp', 'd3zero')
    assert psi4.compare_values(ref_d3zero[0], E, 7, 'Ethene-Ethyne -D3 (zero)')
    mA = eneyne.extract_subsets(1)
    E, G = mA.run_dftd3('b3lyp', 'd3zero')
    assert psi4.compare_values(ref_d3zero[1], E, 7, 'Ethene -D3 (zero)')
    mB = eneyne.extract_subsets(2)
    E, G = mB.run_dftd3('b3lyp', 'd3zero')
    assert psi4.compare_values(ref_d3zero[2], E, 7, 'Ethyne -D3 (zero)')

    E, G = eneyne.run_dftd3('b3lyp', 'd3bj')
    assert psi4.compare_values(ref_d3bj[0], E, 7, 'Ethene-Ethyne -D3 (bj)')
    mA = eneyne.extract_subsets(1)
    E, G = mA.run_dftd3('b3lyp', 'd3bj')
    assert psi4.compare_values(ref_d3bj[1], E, 7, 'Ethene -D3 (bj)')
    mB = eneyne.extract_subsets(2)
    E, G = mB.run_dftd3('b3lyp', 'd3bj')
    assert psi4.compare_values(ref_d3bj[2], E, 7, 'Ethyne -D3 (bj)')

    E, G = eneyne.run_dftd3('b3lyp', 'd3')
    assert psi4.compare_values(ref_d3zero[0], E, 7, 'Ethene-Ethyne -D3 (alias)')
    E, G = eneyne.run_dftd3('b3lyp', 'd')
    assert psi4.compare_values(ref_d2[0], E, 7, 'Ethene-Ethyne -D (alias)')
    E, G = eneyne.run_dftd3('b3lyp', 'd2')
    assert psi4.compare_values(ref_d2[0], E, 7, 'Ethene-Ethyne -D2 (alias)')

    psi4.set_options({'basis': 'sto-3g',
                      'scf_type': 'df',
                      'dft_radial_points': 50,  # use really bad grid for speed since all we want is the -D value
                      'dft_spherical_points': 110,
                      #'scf print': 3,  # will print dftd3 program output to psi4 output file
                    })

    psi4.print_stdout('  -D correction from C-side')
    psi4.activate(mA)
    #psi4.energy('b3lyp-d2p4')
    #assert psi4.compare_values(ref_d2[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D2 (calling psi4 Disp class)')
    #psi4.energy('b3lyp-d2gr')
    #assert psi4.compare_values(ref_d2[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D2 (calling dftd3 -old)')
    #psi4.energy('b3lyp-d3zero')
    #assert psi4.compare_values(ref_d3zero[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (calling dftd3 -zero)')
    psi4.energy('b3lyp-d3bj')
    assert psi4.compare_values(ref_d3bj[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (calling dftd3 -bj)')

    psi4.energy('b3lyp-d2')
    assert psi4.compare_values(ref_d2[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D2 (alias)')
    #psi4.energy('b3lyp-d3')
    #assert psi4.compare_values(ref_d3zero[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (alias)')
    #psi4.energy('b3lyp-d')
    #assert psi4.compare_values(ref_d2[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D (alias)')
    psi4.energy('wb97x-d')
    assert psi4.compare_values(-0.000834247063, psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene wb97x-d (chg)')

    psi4.print_stdout('  non-default -D correction from C-side')
    psi4.activate(mB)
    #psi4.set_options({'dft_dispersion_parameters': [0.75]})
    #psi4.energy('b3lyp-d2p4')
    #assert psi4.compare_values(ref_pbe_d2[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D2 (calling psi4 Disp class)')
    #psi4.set_options({'dft_dispersion_parameters': [0.75, 20.0]})
    #psi4.energy('b3lyp-d2gr')
    #assert psi4.compare_values(ref_pbe_d2[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D2 (calling dftd3 -old)')
    #psi4.set_options({'dft_dispersion_parameters': [1.0,  0.722, 1.217, 14.0]})
    #psi4.energy('b3lyp-d3zero')
    #assert psi4.compare_values(ref_pbe_d3zero[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (calling dftd3 -zero)')
    psi4.set_options({'dft_dispersion_parameters': [1.000, 0.7875, 0.4289, 4.4407]})
    psi4.energy('b3lyp-d3bj')
    assert psi4.compare_values(ref_pbe_d3bj[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (calling dftd3 -bj)')

    psi4.set_options({'dft_dispersion_parameters': [0.75]})
    psi4.energy('b3lyp-d2')
    assert psi4.compare_values(ref_pbe_d2[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D2 (alias)')
    psi4.set_options({'dft_dispersion_parameters': [1.0,  0.722, 1.217, 14.0]})
    psi4.energy('b3lyp-d3')
    assert psi4.compare_values(ref_pbe_d3zero[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (alias)')
    psi4.set_options({'dft_dispersion_parameters': [0.75]})
    psi4.energy('b3lyp-d')
    assert psi4.compare_values(ref_pbe_d2[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D (alias)')
    psi4.activate(mA)
    psi4.set_options({'dft_dispersion_parameters': [1.0]})
    psi4.energy('wb97x-d')
    assert psi4.compare_values(-0.000834247063, psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene wb97x-d (chg)')

    psi4.print_stdout('  non-default -D correction from Py-side')
    eneyne.update_geometry()
    eneyne.run_dftd3('b3lyp', 'd2gr', {'s6': 0.75})
    assert psi4.compare_values(ref_pbe_d2[0], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene-Ethyne -D2')
    mA = eneyne.extract_subsets(1)
    mA.run_dftd3('b3lyp', 'd2gr', {'s6': 0.75})
    assert psi4.compare_values(ref_pbe_d2[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D2')
    mB = eneyne.extract_subsets(2)
    mB.run_dftd3('b3lyp', 'd2gr', {'s6': 0.75})
    assert psi4.compare_values(ref_pbe_d2[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethyne -D2')

    eneyne.run_dftd3('b3lyp', 'd3zero', {'s6': 1.0,  's8': 0.722, 'sr6': 1.217, 'alpha6': 14.0})
    assert psi4.compare_values(ref_pbe_d3zero[0], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene-Ethyne -D3 (zero)')
    mA = eneyne.extract_subsets(1)
    mA.run_dftd3('b3lyp', 'd3zero', {'s6': 1.0,  's8': 0.722, 'sr6': 1.217, 'alpha6': 14.0})
    assert psi4.compare_values(ref_pbe_d3zero[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (zero)')
    mB = eneyne.extract_subsets(2)
    mB.run_dftd3('b3lyp', 'd3zero', {'s6': 1.0,  's8': 0.722, 'sr6': 1.217, 'alpha6': 14.0})
    assert psi4.compare_values(ref_pbe_d3zero[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethyne -D3 (zero)')

    eneyne.run_dftd3('b3lyp', 'd3bj', {'s6': 1.000, 's8':  0.7875, 'a1':  0.4289, 'a2': 4.4407})
    assert psi4.compare_values(ref_pbe_d3bj[0], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene-Ethyne -D3 (bj)')
    mA = eneyne.extract_subsets(1)
    mA.run_dftd3('b3lyp', 'd3bj', {'s6': 1.000, 's8':  0.7875, 'a1':  0.4289, 'a2': 4.4407})
    assert psi4.compare_values(ref_pbe_d3bj[1], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene -D3 (bj)')
    mB = eneyne.extract_subsets(2)
    mB.run_dftd3('b3lyp', 'd3bj', {'s6': 1.000, 's8':  0.7875, 'a1':  0.4289, 'a2': 4.4407})
    assert psi4.compare_values(ref_pbe_d3bj[2], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethyne -D3 (bj)')
    eneyne.run_dftd3('b3lyp', 'd3', {'s6': 1.0,  's8': 0.722, 'sr6': 1.217, 'alpha6': 14.0})

    assert psi4.compare_values(ref_pbe_d3zero[0], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene-Ethyne -D3 (alias)')
    eneyne.run_dftd3('b3lyp', 'd', {'s6': 0.75})
    assert psi4.compare_values(ref_pbe_d2[0], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene-Ethyne -D (alias)')
    eneyne.run_dftd3('b3lyp', 'd2', {'s6': 0.75})
    assert psi4.compare_values(ref_pbe_d2[0], psi4.get_variable('DISPERSION CORRECTION ENERGY'), 7, 'Ethene-Ethyne -D2 (alias)')
예제 #33
0
def test_psi4_scfproperty():
    """scf-property"""
    #! UFH and B3LYP cc-pVQZ properties for the CH2 molecule.

    with open('grid.dat', 'w') as handle:
        handle.write("""\
0.0  0.0  0.0
1.1  1.3  1.4
""")

    ch2 = psi4.geometry("""
        0 3
        c
        h 1 b1
        h 1 b1 2 a1

        b1 = 1.0
        a1 = 125.0
    """)

    # Get a reasonable guess, to save some iterations
    psi4.set_options({
        "scf_type": "pk",
        "basis": "6-31G**",
        "e_convergence": 8,
        "docc": [2, 0, 0, 1],
        "socc": [1, 0, 1, 0],
        "reference": "uhf"
    })

    ch2.update_geometry()
    assert psi4.compare_values(6.648418918908746,
                               ch2.nuclear_repulsion_energy(), 9,
                               "Nuclear repulsion energy")

    props = [
        'DIPOLE', 'QUADRUPOLE', 'MULLIKEN_CHARGES', 'LOWDIN_CHARGES',
        'WIBERG_LOWDIN_INDICES', 'MAYER_INDICES', 'MAYER_INDICES',
        'MO_EXTENTS', 'GRID_FIELD', 'GRID_ESP', 'ESP_AT_NUCLEI',
        'MULTIPOLE(5)', 'NO_OCCUPATIONS'
    ]

    psi4.property('scf', properties=props)

    assert psi4.compare_values(psi4.get_variable("CURRENT ENERGY"),
                               -38.91591819679808, 6, "SCF energy")
    assert psi4.compare_values(psi4.get_variable('SCF DIPOLE X'),
                               0.000000000000, 4, "SCF DIPOLE X")
    assert psi4.compare_values(psi4.get_variable('SCF DIPOLE Y'),
                               0.000000000000, 4, "SCF DIPOLE Y")
    assert psi4.compare_values(psi4.get_variable('SCF DIPOLE Z'),
                               0.572697798348, 4, "SCF DIPOLE Z")
    assert psi4.compare_values(psi4.get_variable('SCF QUADRUPOLE XX'),
                               -7.664066833060, 4, "SCF QUADRUPOLE XX")
    assert psi4.compare_values(psi4.get_variable('SCF QUADRUPOLE YY'),
                               -6.097755074075, 4, "SCF QUADRUPOLE YY")
    assert psi4.compare_values(psi4.get_variable('SCF QUADRUPOLE ZZ'),
                               -7.074596012050, 4, "SCF QUADRUPOLE ZZ")
    assert psi4.compare_values(psi4.get_variable('SCF QUADRUPOLE XY'),
                               0.000000000000, 4, "SCF QUADRUPOLE XY")
    assert psi4.compare_values(psi4.get_variable('SCF QUADRUPOLE XZ'),
                               0.000000000000, 4, "SCF QUADRUPOLE XZ")
    assert psi4.compare_values(psi4.get_variable('SCF QUADRUPOLE YZ'),
                               0.000000000000, 4, "SCF QUADRUPOLE YZ")

    psi4.property('B3LYP', properties=props)

    assert psi4.compare_values(psi4.get_variable('CURRENT ENERGY'),
                               -39.14134740550916, 6, "B3LYP energy")
    assert psi4.compare_values(psi4.get_variable('B3LYP DIPOLE X'),
                               0.000000000000, 4, "B3LYP DIPOLE X")
    assert psi4.compare_values(psi4.get_variable('B3LYP DIPOLE Y'),
                               -0.000000000000, 4, "B3LYP DIPOLE Y")
    assert psi4.compare_values(psi4.get_variable('B3LYP DIPOLE Z'),
                               0.641741521158, 4, "B3LYP DIPOLE Z")
    assert psi4.compare_values(psi4.get_variable('B3LYP QUADRUPOLE XX'),
                               -7.616483183211, 4, "B3LYP QUADRUPOLE XX")
    assert psi4.compare_values(psi4.get_variable('B3LYP QUADRUPOLE YY'),
                               -6.005896804551, 4, "B3LYP QUADRUPOLE YY")
    assert psi4.compare_values(psi4.get_variable('B3LYP QUADRUPOLE ZZ'),
                               -7.021817489904, 4, "B3LYP QUADRUPOLE ZZ")
    assert psi4.compare_values(psi4.get_variable('B3LYP QUADRUPOLE XY'),
                               0.000000000000, 4, "B3LYP QUADRUPOLE XY")
    assert psi4.compare_values(psi4.get_variable('B3LYP QUADRUPOLE XZ'),
                               0.000000000000, 4, "B3LYP QUADRUPOLE XZ")
    assert psi4.compare_values(psi4.get_variable('B3LYP QUADRUPOLE YZ'),
                               -0.000000000000, 4, "B3LYP QUADRUPOLE YZ")
예제 #34
0
파일: RHF.py 프로젝트: jturney/psi4numpy
# Memory for Psi4 in GB
psi4.core.set_memory(int(5e8), False)
psi4.core.set_output_file("output.dat", False)

# Memory for numpy in GB
numpy_memory = 2

mol = psi4.geometry("""
O
H 1 1.1
H 1 1.1 2 104
symmetry c1
""")

psi4.set_options({'basis': 'cc-pvdz', 'scf_type': 'pk', 'e_convergence': 1e-8})

# Set defaults
maxiter = 40
E_conv = 1.0E-6
D_conv = 1.0E-3

# Integral generation from Psi4's MintsHelper
wfn = psi4.core.Wavefunction.build(mol, psi4.core.get_global_option('BASIS'))
t = time.time()
mints = psi4.core.MintsHelper(wfn.basisset())
S = np.asarray(mints.ao_overlap())

# Get nbf and ndocc for closed shell molecules
nbf = S.shape[0]
ndocc = wfn.nalpha()
예제 #35
0
import psi4

psi4.set_output_file("output.dat", False)

geom = psi4.geometry("""
C
""")

psi4.set_options({"SCF_TYPE": "DF", "BASIS": "cc-pVDZ"})

scf_e, scf_wfn = psi4.energy('SCF', return_wfn=True)
psi4.compare_values(-37.5959861862713893, scf_e, 6, 'SCF DF Energy')

psi4.core.set_local_option("SCF", "SCF_TYPE", "PK")
psi4.compare_values(-37.5959861862713893, scf_e, 6, 'SCF PK Energy')
예제 #36
0
파일: test.py 프로젝트: globulion/eopdev
#!/usr/bin/python3
"""
 Test for reproducing results from Steven & Fink, CPL 139, pp.: 15-22 (1987)
 
 Usage: [basis] [xyz.psi]
"""

import psi4, gefp, sys

psi4.set_options({
    "scf_type": "direct",
    "guess": "auto",
    "df_scf_guess": True,
    "e_convergence": 1e-10,
    "d_convergence": 1e-10,
    "basis": sys.argv[1],
    "puream": False,
    "print": 1,
})
psi4.set_output_file("test.log", False)

mol = gefp.core.utilities.psi_molecule_from_file(sys.argv[2])
gefp.math.matrix.move_atom_rotate_molecule(mol, [-30., -83., 43.1])

e_hf, wfn = psi4.energy('scf', molecule=mol, return_wfn=True)

sol = gefp.density.rvs.RVS(wfn)
sol.run_dimer(conver=1e-8)
psi4.core.print_out(str(sol))
예제 #37
0
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()
    # need to clean the options otherwise this job will interfere
    forte.clean_options()

    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
    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'])
    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()
예제 #38
0
# Memory for numpy in GB
numpy_memory = 2

# Triplet O2
mol = psi4.geometry("""
    0 3
    O
    O 1 1.2
symmetry c1
""")

psi4.set_options({
    'guess': 'core',
    'basis': 'aug-cc-pvdz',
    'scf_type': 'pk',
    'e_convergence': 1e-8,
    'reference': 'rohf'
})

wfn = psi4.core.Wavefunction.build(mol, psi4.core.get_global_option('BASIS'))

# Set occupations
nocc = wfn.nalpha()
ndocc = wfn.nbeta()
nsocc = nocc - ndocc

# Set defaults
maxiter = 10
max_micro = 4
micro_print = True
예제 #39
0
C    0.69705   -1.20732   0.00000
C   -0.69705   -1.20732   0.00000
C   -1.39410    0.00000   0.00000
C   -0.69705    1.20732   0.00000
C    0.69705    1.20732   0.00000
H    2.47618    0.00000   0.00000
H    1.23809   -2.14444   0.00000
H   -1.23809   -2.14444   0.00000
H   -2.47618    0.00000   0.00000
H   -1.23809    2.14444   0.00000
H    1.23809    2.14444   0.00000
symmetry c1
""")

# Basis used in mp2 density fitting
psi4.set_options({'basis': 'aug-cc-pVDZ', 'df_basis_scf': 'aug-cc-pvdz-ri'})

check_energy = False

print('\nStarting RHF...')
t = time.time()
RHF_E, wfn = psi4.energy('SCF', return_wfn=True)
print('...RHF finished in %.3f seconds:   %16.10f' % (time.time() - t, RHF_E))

# Grab data from Wavfunction clas
ndocc = wfn.nalpha()
nbf = wfn.nso()
nvirt = nbf - ndocc

# Split eigenvectors and eigenvalues into o and v
eps_occ = np.asarray(wfn.epsilon_a_subset("AO", "ACTIVE_OCC"))
예제 #40
0
def sf_cas(new_charge,
           new_multiplicity,
           ref_mol,
           conf_space="",
           add_opts={},
           return_ci_wfn=False,
           return_rohf_wfn=False,
           return_rohf_e=False,
           read_rohf_wfn=False,
           wfn_rohf_in=None,
           write_rohf_wfn="",
           write_ci_vects=False,
           localize=False,
           frozen_docc=0,
           frozen_uocc=0):
    """
    A method to run a RAS-nSF-IP/EA calculation.

    This runs a RAS-nSF-IP/EA calculation using Psi4's DETCI module. The 
    number of spin-flips and IP/EA is determined based on setting the 
    ``new_charge`` and ``new_multiplicity`` of the desired target state.
    Additional excitations are included by setting the ``conf_space`` 
    keyword; excitations through the CISDT level are currently supported.

    Parameters
    ----------
    new_charge : int
        Target charge of the molecule.
    new_multiplicity : int
        Target multiplicity of the molecule.
    ref_mol : psi4.core.Molecule
        Molecule to run the calculation on.
    conf_space : str ("")
        Option for including additional excitations outside of the CAS space. 
        Defaults to CAS-nSF-IP/EA. Valid options include:
            * ``""`` CAS-nSF-IP/EA
            * ``"h"`` RAS(h)-nSF-IP/EA
            * ``"p"`` RAS(p)-nSF-IP/EA
            * ``"1x"`` RAS(h,p)-nSF-IP/EA
            * ``"S"`` RAS(S)-nSF-IP/EA
            * ``"SD"`` RAS(SD)-nSF-IP/EA
            * ``"SDT"`` RAS(SDT)-nSF-IP/EA
    add_opts : dict ({})
        Additional options to pass into Psi4.
    return_ci_wfn : bool (False)
        Whether to return the CI wavefunction object.
    return_rohf_wfn : bool (False)
        Whether to return the ROHF wavefunction object.
    return_rohf_e : bool (False)
        Whether to return the ROHF energy.
    read_rohf_wfn : bool (False)
        Whether to read a Psi4 ROHF wavefunction.
    rohf_wfn_in : psi4.core.Wavefunction
        The Psi4 ROHF reference wavefunction (pre-computed).
    write_rohf_wfn : str ("")
        Name of file (.npz) to write
    localize : bool (False)
        Perform BOYS localization on the RAS 2 space before DETCI call?
        Can help with visualization and analysis of orbitals.

    Returns
    -------
    e_ci : double
        The SF-CAS([conf_space]) energy.
    return_ci_wfn : psi4.core.Wavefunction
        (optional) The SF-CAS([conf_space]) wavefunction.
    return_rohf_e : double
        (optional) The ROHF energy.
    return_rohf_wfn : psi4.core.Wavefunction
        (optional) The ROHF wavefunction.
    """
    # printing initial information about the calculation
    print("SF-CAS(%s) CALCULATION" % conf_space)
    # default options for Psi4
    opts = {
        'scf_type': 'pk',
        'basis': 'cc-pvdz',
        'reference': 'rohf',
        'mixed': False,
        'maxiter': 1000,
        'ci_maxiter': 50
    }
    opts.update(add_opts)  # add additional options from user

    # run ROHF calculation on reference state or read it in
    psi4.core.clean()  # cleanup in case Psi4 has been run before
    psi4.set_options(opts)
    mol = ref_mol.clone()  # clone molecule so original isn't modified
    # read in ROHF guess wavefunction if provided
    if (read_rohf_wfn):
        # set up options and run
        psi4.set_options(opts)
        print("USING ROHF FROM REFERENCE...\tCHARGE %i\tMULT %i" %
              (ref_mol.molecular_charge(), ref_mol.multiplicity()))
        wfn_rohf = wfn_rohf_in
        e_rohf = wfn_rohf.energy()
    # else, run ROHF on reference state
    else:
        print("RUNNING REFERENCE...\tCHARGE %i\tMULT %i" %
              (ref_mol.molecular_charge(), ref_mol.multiplicity()))
        e_rohf, wfn_rohf = psi4.energy('scf',
                                       molecule=mol,
                                       return_wfn=True,
                                       options=opts)
        print("SCF (%i %i): %6.12f" %
              (mol.molecular_charge(), mol.multiplicity(), e_rohf))

    # change charge and multiplicity to new target values
    print("DOING SPIN-FLIP: CHARGE %i, MULTIPLICITY %i" %
          (new_charge, new_multiplicity))

    # saving npz file of wavefunction
    if (write_rohf_wfn != ""):
        wfn_rohf.to_file(write_rohf_wfn)

    # update molecular charge and multiplicity
    mol.set_molecular_charge(new_charge)
    mol.set_multiplicity(new_multiplicity)

    # set up reference wfn to pass into detci
    # save orbital values from reference calculation
    doccpi = wfn_rohf.doccpi()[0]
    soccpi = wfn_rohf.soccpi()[0]
    nmo = wfn_rohf.nmo()
    # calculate soccpi and doccpi
    new_soccpi = mol.multiplicity() - 1
    del_electrons = ref_mol.molecular_charge() - mol.molecular_charge()
    n_total = wfn_rohf.nalpha() + wfn_rohf.nbeta() + del_electrons
    # set orbital occupations
    wfn_rohf.force_soccpi(psi4.core.Dimension([new_soccpi]))
    wfn_rohf.force_doccpi(
        psi4.core.Dimension([(int)((n_total - new_soccpi) / 2)]))

    # if we need to localize...
    if (localize):
        C = psi4.core.Matrix.to_array(wfn_rohf.Ca(), copy=True)
        ras1_C = C[:, :doccpi]
        ras2_C = C[:, doccpi:doccpi + soccpi]
        ras3_C = C[:, doccpi + soccpi:]
        loc = psi4.core.Localizer.build('BOYS', wfn_rohf.basisset(),
                                        psi4.core.Matrix.from_array(ras2_C))
        loc.localize()
        ras2_localized = psi4.core.Matrix.to_array(loc.L, copy=True)
        localized_orbs = np.column_stack((ras1_C, ras2_localized, ras3_C))
        new_Ca = psi4.core.Matrix.from_array(localized_orbs, name="Ca")
        new_Cb = psi4.core.Matrix.from_array(localized_orbs, name="Cb")
        wfn_rohf.Ca().copy(new_Ca)
        wfn_rohf.Cb().copy(new_Cb)

    # set active space and docc space based on configuration space input
    # Regular CAS configuration space
    # includes only active space configurations
    if (conf_space == ""):
        opts.update({'frozen_docc': [doccpi]})
        opts.update({'ras1': [0]})
        opts.update({'ras2': [soccpi]})
        opts.update({'ras3': [0]})
        opts.update({'ras4': [0]})
    # just (h) excitations
    elif (conf_space == "h"):
        opts.update({'ex_level': 0})
        opts.update({'val_ex_level': 1})
        opts.update({'ras3_max': 0})
        opts.update({'frozen_docc': [frozen_docc]})
        opts.update({'ras1': [doccpi - frozen_docc]})
        opts.update({'ras2': [soccpi]})
        opts.update({'ras3': [0]})
        opts.update({'ras4': [0]})
    # just (p) excitations
    elif (conf_space == "p"):
        opts.update({'ex_level': 0})
        opts.update({'val_ex_level': 0})
        opts.update({'ras3_max': 1})
        opts.update({'frozen_docc': [doccpi]})
        opts.update({'ras1': [0]})
        opts.update({'ras2': [soccpi]})
        opts.update({'ras3': [nmo - soccpi - doccpi - frozen_uocc]})
        opts.update({'frozen_uocc': [frozen_uocc]})
        opts.update({'ras4': [0]})
    # 1x configuration space
    # includes (h, p) excitations
    elif (conf_space == "1x"):
        opts.update({'frozen_docc': [0]})
        opts.update({'ex_level': 0})
        opts.update({'val_ex_level': 1})
        opts.update({'ras3_max': 1})
        opts.update({'frozen_docc': [frozen_docc]})
        opts.update({'ras1': [doccpi - frozen_docc]})
        opts.update({'ras2': [soccpi]})
        opts.update({'ras3': [nmo - soccpi - doccpi - frozen_uocc]})
        opts.update({'frozen_uocc': [frozen_uocc]})
        opts.update({'ras4': [0]})
    # S configuration space
    # includes (h, p, hp) excitations
    elif (conf_space == "S" or conf_space == "xcis"):
        opts.update({'frozen_docc': [0]})
        opts.update({'ex_level': 1})
        opts.update({'frozen_docc': [frozen_docc]})
        opts.update({'ras1': [doccpi - frozen_docc]})
        opts.update({'ras2': [soccpi]})
        opts.update({'ras3': [nmo - soccpi - doccpi - frozen_uocc]})
        opts.update({'frozen_uocc': [frozen_uocc]})
        opts.update({'ras4': [0]})
    elif (conf_space == "SD"):
        opts.update({'frozen_docc': [0]})
        opts.update({'ex_level': 2})
        opts.update({'frozen_docc': [frozen_docc]})
        opts.update({'ras1': [doccpi - frozen_docc]})
        opts.update({'ras2': [soccpi]})
        opts.update({'ras3': [nmo - soccpi - doccpi - frozen_uocc]})
        opts.update({'frozen_uocc': [frozen_uocc]})
        opts.update({'ras4': [0]})
    elif (conf_space == "SDT"):
        opts.update({'frozen_docc': [0]})
        opts.update({'ex_level': 3})
        opts.update({'frozen_docc': [frozen_docc]})
        opts.update({'ras1': [doccpi - frozen_docc]})
        opts.update({'ras2': [soccpi]})
        opts.update({'ras3': [nmo - soccpi - doccpi - frozen_uocc]})
        opts.update({'frozen_uocc': [frozen_uocc]})
        opts.update({'ras4': [0]})
    # Other configuration spaces aren't supported yet
    else:
        print("Configuration space %s not supported. Exiting..." % conf_space)
        exit()

    # run cas
    print("RUNNING CAS...\t\tCHARGE %i\tMULT %i" %
          (mol.molecular_charge(), mol.multiplicity()))
    psi4.set_options(opts)
    e_cas, wfn_cas = psi4.energy('detci',
                                 ref_wfn=wfn_rohf,
                                 return_wfn=True,
                                 molecule=mol)
    print("CAS (%i %i): %6.12f" %
          (mol.molecular_charge(), mol.multiplicity(), e_cas))

    # obtain eigenvectors if needed
    # partly based on Daniel Smith's answer on Psi4 forums
    if (write_ci_vects):
        wfn_cas_2 = psi4.core.CIWavefunction(wfn_rohf)
        n_roots = add_opts['NUM_ROOTS']
        C = np.zeros((wfn_cas_2.ndet(), n_roots))
        print(C.shape)
        for i in range(n_roots):
            dvec = wfn_cas_2.new_civector(i + 1, 53, True, True)
            dvec.set_nvec(i + 1)
            dvec.init_io_files(True)
            dvec.read(i, 0)
            C[:, i] = np.array(dvec)
        np.savetxt('ci_vect.txt', C)

    psi4.core.print_variables()  # printing Psi4 variables
    psi4.core.clean_options()  # more cleanup

    # return output specified by the user
    if ((not return_ci_wfn) and (not return_rohf_wfn) and (not return_rohf_e)):
        return e_cas
    else:
        out = (e_cas, )
        if (return_ci_wfn):
            out = out + (wfn_cas, )
        if (return_rohf_wfn):
            out = out + (wfn_rohf, )
        if (return_rohf_e):
            out = out + (e_rohf, )
        return out
예제 #41
0
# examples/api/05_casscf-doublet-guess.py
"""Example of a CASSCF computation on singlet methylene starting from doublet ROHF orbitals (from psi4)"""

import psi4
import forte

psi4.geometry("""
1 2
C
H 1 1.085
H 1 1.085 2 135.5
""")

psi4.set_options({
    'basis': 'DZ',
    'scf_type': 'pk',
    'e_convergence': 12,
    'reference': 'rohf'
})

e, wfn = psi4.energy('scf', return_wfn=True)

psi4.set_options({
    'forte__job_type': 'mcscf_two_step',
    'forte__charge': 0,  # <-- to override charge = +1 assumed from geometry
    'forte__multiplicity':
    1,  # <-- to override multiplicity = 2 assumed from geometry
    'forte__ms': 0,  # <-- to override ms = 1/2 assumed from geometry
    'forte__active_space_solver': 'fci',
    'forte__restricted_docc': [1, 0, 0, 0],
    'forte__active': [3, 0, 2, 2],
})
예제 #42
0
def runner_asserter(inp, subject, method, basis, tnm):

    qc_module_in = "-".join(["psi4", inp["keywords"].get("qc_module", "")
                             ]).strip("-")  # returns "psi4"|"psi4-<module>"
    driver = inp["driver"]
    reference = inp["keywords"]["reference"]
    fcae = {"true": "fc", "false": "ae"}[inp["keywords"]["freeze_core"]]

    if qc_module_in == "psi4-detci" and basis != "cc-pvdz":
        pytest.skip(f"basis {basis} too big for {qc_module_in}")

    # <<<  Reference Values  >>>

    # ? precedence on next two
    scf_type = inp.get("corl_type", inp["keywords"].get(
        "scf_type", "df"))  # hard-code of read_options.cc SCF_TYPE
    mp2_type = inp.get("corl_type", inp["keywords"].get(
        "mp2_type", "df"))  # hard-code of read_options.cc MP2_TYPE
    if method in ["mp2.5", "mp3"]:
        mp_type = inp.get("corl_type", inp["keywords"].get(
            "mp_type", "df"))  # hard-code of proc.py run_dfocc MP_TYPE
    else:
        mp_type = inp.get("corl_type", inp["keywords"].get(
            "mp_type", "conv"))  # hard-code of read_options.cc MP_TYPE
    cc_type = inp.get("corl_type", inp["keywords"].get(
        "cc_type", "conv"))  # hard-code of read_options.cc CC_TYPE
    corl_natural_values = {
        "hf": "df",  # dummy to assure df/cd/conv scf_type refs available
        "mp2": mp2_type,
        "mp2.5": mp_type,
        "mp3": mp_type,
        "lccd": cc_type,
        "lccsd": cc_type,
        "ccsd": cc_type,
        "ccsd(t)": cc_type,
        "olccd": cc_type,
    }
    corl_type = corl_natural_values[method]

    natural_ref = {"conv": "pk", "df": "df", "cd": "cd"}
    scf_type = inp["keywords"].get("scf_type", natural_ref[corl_type])
    natural_values = {
        "pk": "pk",
        "direct": "pk",
        "df": "df",
        "mem_df": "df",
        "disk_df": "df",
        "cd": "cd"
    }
    scf_type = natural_values[scf_type]

    atol = 1.0e-6
    if driver == "hessian":
        atol = 2.0e-6  # todo implement more elaborate e/g/h atol like at qcdb & qcng: https://github.com/qcdb/qcdb/blob/master/qcdb/tests/standard_suite_runner.py#L144-L152
    chash = answer_hash(
        system=subject.name(),
        basis=basis,
        fcae=fcae,
        scf_type=scf_type,
        reference=reference,
        corl_type=corl_type,
    )

    # check all calcs against conventional reference to looser tolerance
    atol_conv = 3.0e-4  # for df-ccsd. mp2 ok with 1.e-4
    chash_conv = answer_hash(
        system=subject.name(),
        basis=basis,
        fcae=fcae,
        reference=reference,
        corl_type="conv",
        scf_type="pk",
    )
    ref_block_conv = std_suite[chash_conv]

    # <<<  Prepare Calculation and Call API  >>>

    driver_call = {
        "energy": psi4.energy,
        "gradient": psi4.gradient,
        "hessian": psi4.hessian
    }

    psi4.set_options({
        # reference generation conv crit
        # "guess": "sad",
        # "e_convergence": 10,
        # "d_convergence": 9,
        # "r_convergence": 9,
        # "pcg_convergence": 9,

        # runtime conv crit
        "points": 5,
        "fd_project": False,
    })
    extra_kwargs = inp["keywords"].pop("function_kwargs", {})
    psi4.set_options(inp["keywords"])

    if "error" in inp:
        errtype, errmsg = inp["error"]
        with pytest.raises(errtype) as e:
            driver_call[driver](inp["call"], molecule=subject, **extra_kwargs)

        assert errmsg in str(e.value), f"({errmsg}) not in ({e.value})"
        return

    ret, wfn = driver_call[driver](inp["call"],
                                   molecule=subject,
                                   return_wfn=True,
                                   **extra_kwargs)
    qc_module_out = "psi4-" + ("occ" if wfn.module() == "dfocc" else
                               wfn.module())  # returns "psi4-<module>"

    # <<<  Comparison Tests  >>>

    if qc_module_in != "psi4":
        assert qc_module_out == qc_module_in, f"QC_MODULE used ({qc_module_in}) != requested ({qc_module_out})"

    ref_block = std_suite[chash]

    # qcvars
    contractual_args = [
        qc_module_in,
        driver,
        reference,
        method,
        corl_type,
        fcae,
    ]
    asserter_args = [
        [psi4.core, wfn],
        ref_block,
        atol,
        ref_block_conv,
        atol_conv,
        tnm,
    ]

    def qcvar_assertions():
        print("BLOCK", chash, contractual_args)
        if method == "hf":
            _asserter(asserter_args, contractual_args, contractual_hf)
        elif method == "mp2":
            _asserter(asserter_args, contractual_args, contractual_mp2)
        elif method == "mp2.5":
            _asserter(asserter_args, contractual_args, contractual_mp2)
            _asserter(asserter_args, contractual_args, contractual_mp3)
            _asserter(asserter_args, contractual_args, contractual_mp2p5)
        elif method == "mp3":
            _asserter(asserter_args, contractual_args, contractual_mp2)
            _asserter(asserter_args, contractual_args, contractual_mp2p5)
            _asserter(asserter_args, contractual_args, contractual_mp3)
        elif method == "lccd":
            _asserter(asserter_args, contractual_args, contractual_mp2)
            _asserter(asserter_args, contractual_args, contractual_lccd)
        elif method == "lccsd":
            _asserter(asserter_args, contractual_args, contractual_mp2)
            _asserter(asserter_args, contractual_args, contractual_lccsd)
        elif method == "ccsd":
            _asserter(asserter_args, contractual_args, contractual_mp2)
            _asserter(asserter_args, contractual_args, contractual_ccsd)
        elif method == "ccsd(t)":
            _asserter(asserter_args, contractual_args, contractual_mp2)
            _asserter(asserter_args, contractual_args, contractual_ccsd)
            _asserter(asserter_args, contractual_args, contractual_ccsd_prt_pr)
        elif method == "olccd":
            _asserter(asserter_args, contractual_args, contractual_mp2)
            _asserter(asserter_args, contractual_args, contractual_olccd)

    if "wrong" in inp:
        errmsg, reason = inp["wrong"]
        with pytest.raises(AssertionError) as e:
            qcvar_assertions()

        # print("WRONG", errmsg, reason, str(e.value), "ENDW")
        assert errmsg in str(e.value)
        pytest.xfail(reason)

    qcvar_assertions()

    # aliases
    _asserter(asserter_args, contractual_args, contractual_current)

    # returns
    tf, errmsg = compare_values(
        ref_block[f"{method.upper()} TOTAL ENERGY"],
        wfn.energy(),
        tnm + " wfn",
        atol=atol,
        return_message=True,
        quiet=True,
    )
    assert compare_values(ref_block[f"{method.upper()} TOTAL ENERGY"],
                          wfn.energy(),
                          tnm + " wfn",
                          atol=atol), errmsg

    if driver == "energy":
        assert compare_values(ref_block[f"{method.upper()} TOTAL ENERGY"], ret,
                              tnm + " return")

    elif driver == "gradient":
        assert compare_values(ref_block[f"{method.upper()} TOTAL GRADIENT"],
                              wfn.gradient().np,
                              tnm + " grad wfn",
                              atol=atol)
        assert compare_values(ref_block[f"{method.upper()} TOTAL GRADIENT"],
                              ret.np,
                              tnm + " grad return",
                              atol=atol)

    elif driver == "hessian":
        tf, errmsg = compare_values(
            ref_block[f"{method.upper()} TOTAL HESSIAN"],
            wfn.hessian().np,
            tnm + " hess wfn",
            atol=atol,
            return_message=True,
            quiet=True)
        assert compare_values(ref_block[f"{method.upper()} TOTAL HESSIAN"],
                              wfn.hessian().np,
                              tnm + " hess wfn",
                              atol=atol), errmsg
        assert compare_values(ref_block[f"{method.upper()} TOTAL HESSIAN"],
                              wfn.hessian().np,
                              tnm + " hess wfn",
                              atol=atol)
        assert compare_values(ref_block[f"{method.upper()} TOTAL GRADIENT"],
                              wfn.gradient().np,
                              tnm + " grad wfn",
                              atol=atol)
        assert compare_values(ref_block[f"{method.upper()} TOTAL HESSIAN"],
                              ret.np,
                              tnm + " hess return",
                              atol=atol)

    # generics
    # yapf: disable
    assert compare(ref_block["N BASIS FUNCTIONS"], wfn.nso(), tnm + " nbasis wfn"), f"nbasis {wfn.nso()} != {ref_block['N BASIS FUNCTIONS']}"
    assert compare(ref_block["N MOLECULAR ORBITALS"], wfn.nmo(), tnm + " nmo wfn"), f"nmo {wfn.nmo()} != {ref_block['N MOLECULAR ORBITALS']}"
    assert compare(ref_block["N ALPHA ELECTRONS"], wfn.nalpha(), tnm + " nalpha wfn"), f"nalpha {wfn.nalpha()} != {ref_block['N ALPHA ELECTRONS']}"
    assert compare(ref_block["N BETA ELECTRONS"], wfn.nbeta(), tnm + " nbeta wfn"), f"nbeta {wfn.nbeta()} != {ref_block['N BETA ELECTRONS']}"
예제 #43
0
# psi4.core.set_memory(int(2e9), False)
psi4.core.set_output_file('output.dat', False)

# Memory for numpy in GB
numpy_memory = 2

mol = psi4.geometry("""
O
H 1 1.1
H 1 1.1 2 104
symmetry c1
""")


psi4.set_options({'basis': 'sto-3g',
                  'scf_type': 'pk',
                  'e_convergence': 1e-8,
                  'd_convergence': 1e-8})

print('\nStarting SCF and integral build...')
t = time.time()

# First compute SCF energy using Psi4
scf_e, wfn = psi4.energy('SCF', return_wfn=True)

# Grab data from wavfunction class 
C = wfn.Ca()
ndocc = wfn.doccpi()[0]
nmo = wfn.nmo()
nvirt = nmo - ndocc
nDet_S = ndocc * nvirt * 2
예제 #44
0
        self.T3onT2 = self.T3onT2 + np.einsum('ijab -> jiba', self.T3onT2)

        ## Contribution of disconnected T3*T1 terms to T2 equations via relax_t3t1ont2 function.

        self.relax_t3t1ont2()

        print('T3')
        printtensor(self.T3)


if __name__ == '__main__':

    mol = psi4.geometry("""
    0 1
    O
    H 1 0.96
    H 1 0.96 2 104.5
    symmetry c1""")
    mol.update_geometry()

    psi4.set_options({
        'basis': 'sto-3g',
        'scf_type': 'pk',
        'FCI': True,
        'reference': 'rhf'
    })

    E, wfn = psi4.energy('detci', return_wfn=True)
    CASCCSD(wfn)
    print(E)
예제 #45
0
import psi4

psi4.set_output_file("output.dat", False)

# Benzene
mol = psi4.geometry("""
0 1
O
H 1 1.1
H 1 1.1 2 104
symmetry c1
""")

psi4.set_options({
    "basis": "aug-cc-pVDZ",
    "scf_type": "df",
    "e_convergence": 1e-8
})

# Set tolerances
maxiter = 12
E_conv = 1.0E-6
D_conv = 1.0E-5

# Integral generation from Psi4's MintsHelper
wfn = psi4.core.Wavefunction.build(mol, psi4.core.get_global_option("BASIS"))
mints = psi4.core.MintsHelper(wfn.basisset())
S = mints.ao_overlap()

# Get nbf and ndocc for closed shell molecules
nbf = wfn.nso()
예제 #46
0
파일: input.py 프로젝트: zachglick/psi4
    S   1   1.00
          0.1831920              1.0000000
    ****
    C     0
    S   3   1.00
        172.2560000              0.0617669
         25.9109000              0.3587940
          5.5333500              0.7007130
    SP   2   1.00
          3.6649800             -0.3958970              0.2364600
          0.7705450              1.2158400              0.8606190
    SP   1   1.00
          0.1958570              1.0000000              1.0000000
    ****
    [DZ]
    spherical
    ****
    H     0 
    S   3   1.00
         19.2406000              0.0328280        
          2.8992000              0.2312080        
          0.6534000              0.8172380        
    S   1   1.00
          0.1776000              1.0000000        
    ****
""")

psi4.set_options({'d_convergence': 11, 'e_convergence': 11, 'scf_type': 'pk'})

scfenergy = psi4.energy('scf')
예제 #47
0
def test_geometric_hessian_rhf_outside_solver_psi4numpy():
    psi4.core.set_output_file("output.dat", False)

    mol = psi4.geometry(
        """
    O
    H 1 1.1
    H 1 1.1 2 104
    symmetry c1
    """
    )

    psi4.core.set_active_molecule(mol)

    options = {
        "BASIS": "STO-3G",
        "SCF_TYPE": "PK",
        "E_CONVERGENCE": 1e-10,
        "D_CONVERGENCE": 1e-10,
    }

    psi4.set_options(options)

    _, wfn = psi4.energy("SCF", return_wfn=True)

    # Assuming C1 symmetry
    occ = wfn.doccpi()[0]
    nmo = wfn.nmo()
    vir = nmo - occ

    C = wfn.Ca_subset("AO", "ALL")
    npC = np.asarray(C)

    mints = psi4.core.MintsHelper(wfn.basisset())
    H_ao = np.asarray(mints.ao_kinetic()) + np.asarray(mints.ao_potential())

    # Update H, transform to MO basis
    H = np.einsum("uj,vi,uv", npC, npC, H_ao)

    # Integral generation from Psi4's MintsHelper
    MO = np.asarray(mints.mo_eri(C, C, C, C))
    # Physicist notation
    MO = MO.swapaxes(1, 2)

    F = H + 2.0 * np.einsum("pmqm->pq", MO[:, :occ, :, :occ])
    F -= np.einsum("pmmq->pq", MO[:, :occ, :occ, :])
    # Uncomment every `np.save` call to regenerate reference data.
    # np.save(os.path.join(datadir, 'F.npy'), F)
    F_ref = np.load(os.path.join(datadir, "F.npy"))
    np.testing.assert_allclose(F, F_ref, rtol=0, atol=1.0e-10)
    natoms = mol.natom()
    cart = ["_X", "_Y", "_Z"]
    oei_dict = {"S": "OVERLAP", "T": "KINETIC", "V": "POTENTIAL"}

    deriv1_mat = {}
    deriv1 = {}

    # 1st Derivative of OEIs

    for atom in range(natoms):
        for key in oei_dict:
            deriv1_mat[key + str(atom)] = mints.mo_oei_deriv1(oei_dict[key], atom, C, C)
            for p in range(3):
                map_key = key + str(atom) + cart[p]
                deriv1[map_key] = np.asarray(deriv1_mat[key + str(atom)][p])
                # np.save(os.path.join(datadir, f'{map_key}.npy'), deriv1[map_key])
                deriv1_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
                np.testing.assert_allclose(deriv1[map_key], deriv1_ref, rtol=0, atol=1.0e-10)

    # 1st Derivative of TEIs

    for atom in range(natoms):
        string = "TEI" + str(atom)
        deriv1_mat[string] = mints.mo_tei_deriv1(atom, C, C, C, C)
        for p in range(3):
            map_key = string + cart[p]
            deriv1[map_key] = np.asarray(deriv1_mat[string][p])
            # np.save(os.path.join(datadir, f'{map_key}.npy'), deriv1[map_key])
            deriv1_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
            np.testing.assert_allclose(deriv1[map_key], deriv1_ref, rtol=0, atol=1.0e-10)

    Hes = {}
    deriv2_mat = {}
    deriv2 = {}

    Hes["S"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["V"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["T"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["N"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["J"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["K"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["R"] = np.zeros((3 * natoms, 3 * natoms))
    Hessian = np.zeros((3 * natoms, 3 * natoms))

    Hes["N"] = np.asarray(mol.nuclear_repulsion_energy_deriv2())

    psi4.core.print_out("\n\n")
    Mat = psi4.core.Matrix.from_array(Hes["N"])
    Mat.name = "NUCLEAR HESSIAN"
    Mat.print_out()

    # 2nd Derivative of OEIs

    for atom1 in range(natoms):
        for atom2 in range(atom1 + 1):
            for key in oei_dict:
                string = key + str(atom1) + str(atom2)
                deriv2_mat[string] = mints.mo_oei_deriv2(oei_dict[key], atom1, atom2, C, C)
                pq = 0
                for p in range(3):
                    for q in range(3):
                        map_key = string + cart[p] + cart[q]
                        deriv2[map_key] = np.asarray(deriv2_mat[string][pq])
                        # np.save(os.path.join(datadir, f'{map_key}.npy'), deriv2[map_key])
                        deriv2_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
                        np.testing.assert_allclose(
                            deriv2[map_key], deriv2_ref, rtol=0, atol=1.0e-10
                        )
                        pq = pq + 1
                        row = 3 * atom1 + p
                        col = 3 * atom2 + q
                        if key == "S":
                            Hes[key][row][col] = -2.0 * np.einsum(
                                "ii,ii->", F[:occ, :occ], deriv2[map_key][:occ, :occ]
                            )
                        else:
                            Hes[key][row][col] = 2.0 * np.einsum(
                                "ii->", deriv2[map_key][:occ, :occ]
                            )
                        Hes[key][col][row] = Hes[key][row][col]
                        Hes[key][col][row] = Hes[key][row][col]
                        # np.save(os.path.join(datadir, f'Hes_{map_key}.npy'), Hes[key])
                        Hes_ref = np.load(os.path.join(datadir, f"Hes_{map_key}.npy"))
                        np.testing.assert_allclose(Hes[key], Hes_ref, rtol=0, atol=1.0e-10)

    for key in Hes:
        Mat = psi4.core.Matrix.from_array(Hes[key])
        if key in oei_dict:
            Mat.name = oei_dict[key] + " HESSIAN"
            Mat.print_out()
            psi4.core.print_out("\n")

    # 2nd Derivative of TEIs

    for atom1 in range(natoms):
        for atom2 in range(atom1 + 1):
            string = "TEI" + str(atom1) + str(atom2)
            deriv2_mat[string] = mints.mo_tei_deriv2(atom1, atom2, C, C, C, C)
            pq = 0
            for p in range(3):
                for q in range(3):
                    map_key = string + cart[p] + cart[q]
                    deriv2[map_key] = np.asarray(deriv2_mat[string][pq])
                    # np.save(os.path.join(datadir, f'{map_key}.npy'), deriv2[map_key])
                    deriv2_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
                    np.testing.assert_allclose(deriv2[map_key], deriv2_ref, rtol=0, atol=1.0e-10)
                    pq = pq + 1
                    row = 3 * atom1 + p
                    col = 3 * atom2 + q
                    Hes["J"][row][col] = 2.0 * np.einsum(
                        "iijj->", deriv2[map_key][:occ, :occ, :occ, :occ]
                    )
                    Hes["K"][row][col] = -1.0 * np.einsum(
                        "ijij->", deriv2[map_key][:occ, :occ, :occ, :occ]
                    )

                    Hes["J"][col][row] = Hes["J"][row][col]
                    Hes["K"][col][row] = Hes["K"][row][col]
    for map_key in ("J", "K"):
        # np.save(os.path.join(datadir, f'Hes_{map_key}.npy'), Hes[map_key])
        Hes_ref = np.load(os.path.join(datadir, f"Hes_{map_key}.npy"))
        np.testing.assert_allclose(Hes[map_key], Hes_ref, rtol=0, atol=1.0e-10)

    JMat = psi4.core.Matrix.from_array(Hes["J"])
    KMat = psi4.core.Matrix.from_array(Hes["K"])
    JMat.name = " COULOMB  HESSIAN"
    KMat.name = " EXCHANGE HESSIAN"
    JMat.print_out()
    KMat.print_out()

    # Solve the CPHF equations here,  G_aibj Ubj^x = Bai^x (Einstein summation),
    # where G is the electronic hessian,
    # G_aibj = delta_ij * delta_ab * epsilon_ij * epsilon_ab + 4 <ij|ab> - <ij|ba> - <ia|jb>,
    # where epsilon_ij = epsilon_i - epsilon_j, (epsilon -> orbital energies),
    # x refers to the perturbation, Ubj^x are the corresponsing CPHF coefficients
    # and Bai^x = Sai^x * epsilon_ii - Fai^x + Smn^x  * (2<am|in> - <am|ni>),
    # where, S^x =  del(S)/del(x), F^x =  del(F)/del(x).

    I_occ = np.diag(np.ones(occ))
    I_vir = np.diag(np.ones(vir))
    epsilon = np.asarray(wfn.epsilon_a())
    eps_diag = epsilon[occ:].reshape(-1, 1) - epsilon[:occ]

    # Build the electronic hessian G

    G = 4 * MO[:occ, :occ, occ:, occ:]
    G -= MO[:occ, :occ, occ:, occ:].swapaxes(2, 3)
    G -= MO[:occ, occ:, :occ, occ:].swapaxes(1, 2)
    G = G.swapaxes(1, 2)
    G += np.einsum("ai,ij,ab->iajb", eps_diag, I_occ, I_vir)
    # np.save(os.path.join(datadir, 'G.npy'), G)
    G_ref = np.load(os.path.join(datadir, "G.npy"))
    np.testing.assert_allclose(G, G_ref, rtol=0, atol=1.0e-10)

    # Inverse of G
    Ginv = np.linalg.inv(G.reshape(occ * vir, -1))
    Ginv = Ginv.reshape(occ, vir, occ, vir)

    B = {}
    F_grad = {}
    U = {}

    # Build Fpq^x now

    for atom in range(natoms):
        for p in range(3):
            key = str(atom) + cart[p]
            F_grad[key] = deriv1["T" + key]
            F_grad[key] += deriv1["V" + key]
            F_grad[key] += 2.0 * np.einsum("pqmm->pq", deriv1["TEI" + key][:, :, :occ, :occ])
            F_grad[key] -= 1.0 * np.einsum("pmmq->pq", deriv1["TEI" + key][:, :occ, :occ, :])
            # np.save(os.path.join(datadir, f'F_grad_{key}.npy'), F_grad[key])
            F_grad_ref = np.load(os.path.join(datadir, f"F_grad_{key}.npy"))
            np.testing.assert_allclose(F_grad[key], F_grad_ref, rtol=0, atol=1.0e-10)

    psi4.core.print_out("\n\n CPHF Coefficients:\n")

    # Build Bai^x now

    for atom in range(natoms):
        for p in range(3):
            key = str(atom) + cart[p]
            B[key] = np.einsum("ai,ii->ai", deriv1["S" + key][occ:, :occ], F[:occ, :occ])
            B[key] -= F_grad[key][occ:, :occ]
            B[key] += 2.0 * np.einsum(
                "amin,mn->ai", MO[occ:, :occ, :occ, :occ], deriv1["S" + key][:occ, :occ]
            )
            B[key] += -1.0 * np.einsum(
                "amni,mn->ai", MO[occ:, :occ, :occ, :occ], deriv1["S" + key][:occ, :occ]
            )

            print(f"B[{key}]")
            print(B[key])
            # np.save(os.path.join(datadir, f'B_{key}.npy'), B[key])
            B_ref = np.load(os.path.join(datadir, f"B_{key}.npy"))
            np.testing.assert_allclose(B[key], B_ref, rtol=0, atol=1.0e-10)

            # Compute U^x now: U_ai^x = G^(-1)_aibj * B_bj^x

            U[key] = np.einsum("iajb,bj->ai", Ginv, B[key])
            psi4.core.print_out("\n")
            UMat = psi4.core.Matrix.from_array(U[key])
            UMat.name = key
            UMat.print_out()

            # np.save(os.path.join(datadir, f'U_{key}.npy'), U[key])
            U_ref = np.load(os.path.join(datadir, f"U_{key}.npy"))
            np.testing.assert_allclose(U[key], U_ref, rtol=0, atol=1.0e-10)

    # Build the response Hessian

    for atom1 in range(natoms):
        for atom2 in range(atom1 + 1):
            for p in range(3):
                for q in range(3):
                    key1 = str(atom1) + cart[p]
                    key2 = str(atom2) + cart[q]
                    key1S = "S" + key1
                    key2S = "S" + key2
                    r = 3 * atom1 + p
                    c = 3 * atom2 + q

                    Hes["R"][r][c] = -2.0 * np.einsum(
                        "ij,ij->", deriv1[key1S][:occ, :occ], F_grad[key2][:occ, :occ]
                    )
                    Hes["R"][r][c] -= 2.0 * np.einsum(
                        "ij,ij->", deriv1[key2S][:occ, :occ], F_grad[key1][:occ, :occ]
                    )
                    Hes["R"][r][c] += 4.0 * np.einsum(
                        "ii,mi,mi->",
                        F[:occ, :occ],
                        deriv1[key2S][:occ, :occ],
                        deriv1[key1S][:occ, :occ],
                    )

                    Hes["R"][r][c] += 4.0 * np.einsum(
                        "ij,mn,imjn->",
                        deriv1[key1S][:occ, :occ],
                        deriv1[key2S][:occ, :occ],
                        MO[:occ, :occ, :occ, :occ],
                    )
                    Hes["R"][r][c] -= 2.0 * np.einsum(
                        "ij,mn,imnj->",
                        deriv1[key1S][:occ, :occ],
                        deriv1[key2S][:occ, :occ],
                        MO[:occ, :occ, :occ, :occ],
                    )

                    Hes["R"][r][c] -= 4.0 * np.einsum("ai,ai->", U[key2], B[key1])
                    Hes["R"][c][r] = Hes["R"][r][c]

    # np.save(os.path.join(datadir, 'Hes_R.npy'), Hes["R"])
    Hes_ref = np.load(os.path.join(datadir, "Hes_R.npy"))
    np.testing.assert_allclose(Hes["R"], Hes_ref, rtol=0, atol=1.0e-10)

    Mat = psi4.core.Matrix.from_array(Hes["R"])
    Mat.name = " RESPONSE HESSIAN"
    Mat.print_out()

    for key in Hes:
        Hessian += Hes[key]

    # print('deriv1_mat')
    # print(deriv1_mat.keys())
    # print('deriv1')
    # print(deriv1.keys())
    # print('deriv2_mat')
    # print(deriv2_mat.keys())
    # print('deriv2')
    # print(deriv2.keys())
    # print('B')
    # print(B.keys())
    # print('F_grad')
    # print(F_grad.keys())
    # print('U')
    # print(U.keys())
    # print('Hes')
    # print(Hes.keys())

    Mat = psi4.core.Matrix.from_array(Hessian)
    Mat.name = " TOTAL HESSIAN"
    Mat.print_out()

    # pylint: disable=bad-whitespace
    H_psi4 = psi4.core.Matrix.from_list(
        [
            [
                7.613952269164418751e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -3.806976134297335168e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -3.806976134297410108e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
            ],
            [
                0.000000000000000000e00,
                4.829053723748517601e-01,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -2.414526861845633920e-01,
                1.589001558536450587e-01,
                0.000000000000000000e00,
                -2.414526861845646133e-01,
                -1.589001558536444758e-01,
            ],
            [
                0.000000000000000000e00,
                0.000000000000000000e00,
                4.373449597848400039e-01,
                0.000000000000000000e00,
                7.344233774055003439e-02,
                -2.186724798895446076e-01,
                0.000000000000000000e00,
                -7.344233774054893804e-02,
                -2.186724798895475219e-01,
            ],
            [
                -3.806976134297335168e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                4.537741758645107149e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -7.307656243475501093e-03,
                0.000000000000000000e00,
                0.000000000000000000e00,
            ],
            [
                0.000000000000000000e00,
                -2.414526861845633920e-01,
                7.344233774055003439e-02,
                0.000000000000000000e00,
                2.578650065921952450e-01,
                -1.161712467970963669e-01,
                0.000000000000000000e00,
                -1.641232040762596878e-02,
                4.272890905654690846e-02,
            ],
            [
                0.000000000000000000e00,
                1.589001558536450587e-01,
                -2.186724798895446076e-01,
                0.000000000000000000e00,
                -1.161712467970963669e-01,
                1.977519807685419462e-01,
                0.000000000000000000e00,
                -4.272890905654720684e-02,
                2.092049912100946499e-02,
            ],
            [
                -3.806976134297410108e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -7.307656243475501093e-03,
                0.000000000000000000e00,
                0.000000000000000000e00,
                4.537741758645268131e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
            ],
            [
                0.000000000000000000e00,
                -2.414526861845646133e-01,
                -7.344233774054893804e-02,
                0.000000000000000000e00,
                -1.641232040762596878e-02,
                -4.272890905654720684e-02,
                0.000000000000000000e00,
                2.578650065921969103e-01,
                1.161712467970957008e-01,
            ],
            [
                0.000000000000000000e00,
                -1.589001558536444758e-01,
                -2.186724798895475219e-01,
                0.000000000000000000e00,
                4.272890905654690846e-02,
                2.092049912100946499e-02,
                0.000000000000000000e00,
                1.161712467970957008e-01,
                1.977519807685442221e-01,
            ],
        ]
    )
    H_python_mat = psi4.core.Matrix.from_array(Hessian)
    psi4.compare_matrices(H_psi4, H_python_mat, 10, "RHF-HESSIAN-TEST")  # TEST
예제 #48
0
파일: test_addons.py 프로젝트: votavap/psi4
def test_erd():
    """erd/scf5"""

    psi4.set_options({'integral_package': 'ERD'})
    _test_scf5()
예제 #49
0
# O     0.0000000000    0.0000000000    2.3054658725
# H     1.7822044879    0.0000000000   -1.0289558751
# H    -1.7822044879    0.0000000000   -1.0289558751
# C     0.0000000000    0.0000000000    0.0000000000
# symmetry c1
# """)

mol = psi4.geometry("""
O 0.000000000000  -0.143225816552   0.000000000000
H 1.638036840407   1.136548822547  -0.000000000000
H -1.638036840407   1.136548822547  -0.000000000000
units bohr
symmetry c1
""")

psi4.set_options({"SAVE_JK": True, 'scf_type': 'pk', 'd_convergence': 10})
e, wfn = psi4.energy("HF/sto-3g", return_wfn=True)
prod = AB_product_factory(wfn)

F_ako = prod.mFa.to_array()
C = prod.mCa.to_array()
Fmo = (C.T).dot(F_ao).dot(C)
F_ij = Fmo[prod.o, prod.o]
F_ab = Fmo[prod.v, prod.v]
print("F_ij: ", " x ".join(str(x) for x in F_ij.shape))
print("")
print("F_ab: ", " x ".join(str(x) for x in F_ab.shape))
Iiajb = prod.mints.mo_eri(prod.mCa_occ, prod.mCa_virt, prod.mCa_occ, prod.mCa_virt).to_array()
Iabji = prod.mints.mo_eri(prod.mCa_virt, prod.mCa_virt, prod.mCa_occ, prod.mCa_occ).to_array()
A = np.einsum("ab,ij->iajb", F_ab, np.eye(prod.nocc))
A -= np.einsum("ij,ab->iajb", F_ij, np.eye(prod.nvir))
예제 #50
0
def test_chk(datadir):
    # run cc
    psi4.set_memory('600MB')
    psi4.core.set_output_file('output.dat', False)
    psi4.set_options({'basis': 'cc-pVDZ',
                      'scf_type': 'pk',
                      'mp2_type': 'conv',
                      'freeze_core': 'false',
                      'e_convergence': 1e-8,
                      'd_convergence': 1e-8,
                      'r_convergence': 1e-8,
                      'diis': 8})
    mol = psi4.geometry(moldict["H2"])

    # pull ref wfn, psi4 is picky about strings 
    rhf_dir = str(datadir.join(f"ref_wfn.npy"))
    rhf_wfn = psi4.core.Wavefunction.from_file(rhf_dir)

    e_conv = 1e-8
    r_conv = 1e-8
    cc = pycc.ccwfn(rhf_wfn)
    ecc = cc.solve_cc(e_conv, r_conv)
    hbar = pycc.cchbar(cc)
    cclambda = pycc.cclambda(cc, hbar)
    lecc = cclambda.solve_lambda(e_conv, r_conv)
    ccdensity = pycc.ccdensity(cc, cclambda)

    # narrow Gaussian pulse
    F_str = 0.001
    sigma = 0.01
    center = 0.05
    V = gaussian_laser(F_str, 0, sigma, center=center)

    # RTCC setup
    h = 0.1
    tf = 10
    rtcc = pycc.rtcc(cc,cclambda,ccdensity,V,magnetic=True,kick='z')

    # pull chk files for 0-5.1au
    chk_file = datadir.join(f"chk_5.pk")
    with open(chk_file,'rb') as cf:
        chk = pk.load(cf)

    # propagate to 10au
    ODE = rk2(h)
    y0 = chk['y']
    ti = chk['time']
    ofile = datadir.join(f"output.pk")
    tfile = datadir.join(f"t_out.pk")
    ret, ret_t = rtcc.propagate(ODE, y0, tf, ti=ti, ref=False, chk=True, tchk=1,
            ofile=ofile, tfile=tfile, k=2)

    # reference is "full" propagation (0-10au)
    refp_file = datadir.join(f"output_full.pk")
    with open(refp_file,'rb') as pf:
        ref_p = pk.load(pf)
    reft_file = datadir.join(f"t_out_full.pk")
    with open(reft_file,'rb') as ampf:
        ref_t = pk.load(ampf)
        
    # check properties
    pchk = ['ecc','mu_x','mu_y','mu_z','m_x','m_y','m_z']
    for k in ref_p.keys():
        for p in pchk:
            assert np.allclose(ret[k][p],ref_p[k][p])

    # check amplitudes
    tchk = ['t1','t2','l1','l2']
    for k in ref_t.keys():
        for t in tchk:
            assert np.allclose(ret_t[k][t],ref_t[k][t])
예제 #51
0
H    45.508000    40.786000    39.175000
H    43.151000    37.062000    37.180000
H    40.929000    35.954000    37.704000
H    39.378000    37.062000    39.158000
H    40.246000    38.878000    40.859000
symmetry c1
no_com
noreorient
""")

nroots = 3

psi4.set_options({
    "basis": "6-31G*",
    "freeze_core": "true",
    "roots_per_irrep": [nroots],
    "pe": "true",
    "ints_tolerance": 2.5e-11,
    "puream": "true",
})

psi4.set_module_options("pe", {
    "potfile": "nilered_in_blg_1000WAT.pot",
    "maxiter": 200
})

psi4.set_module_options("ccenergy", {"cachelevel": 0})

psi4.set_module_options("cclambda", {"r_convergence": 1e-3, "cachelevel": 0})
psi4.set_module_options("cceom", {
    "cachelevel": 0,
    "r_convergence": 1e-3,
예제 #52
0
def test_rtcc_water_cc_pvdz():
    """H2O cc-pVDZ"""
    psi4.set_memory('2 GiB')
    psi4.core.set_output_file('output.dat', False)
    psi4.set_options({
        'basis': 'cc-pVDZ',
        'scf_type': 'pk',
        'mp2_type': 'conv',
        'freeze_core': 'false',
        'e_convergence': 1e-13,
        'd_convergence': 1e-13,
        'r_convergence': 1e-13,
        'diis': 1
    })
    mol = psi4.geometry(moldict["H2O"])
    rhf_e, rhf_wfn = psi4.energy('SCF', return_wfn=True)

    e_conv = 1e-13
    r_conv = 1e-13

    cc = pycc.ccwfn(rhf_wfn)
    ecc = cc.solve_cc(e_conv, r_conv)

    hbar = pycc.cchbar(cc)

    cclambda = pycc.cclambda(cc, hbar)
    lecc = cclambda.solve_lambda(e_conv, r_conv)

    ccdensity = pycc.ccdensity(cc, cclambda)

    # Gaussian pulse (a.u.)
    F_str = 0.01
    omega = 0
    sigma = 0.01
    center = 0.05
    V = gaussian_laser(F_str, omega, sigma, center)

    # RT-CC Setup
    t0 = 0
    tf = 1
    h = 0.01
    t = t0
    rtcc = pycc.rtcc(cc, cclambda, ccdensity, V)
    y0 = rtcc.collect_amps(cc.t1, cc.t2, cclambda.l1,
                           cclambda.l2).astype('complex128')
    y = y0
    # Setting for the adaptive integrator
    maxiter = 10
    yconv = 1e-7
    ODE = ck(maxiter, yconv)
    t1, t2, l1, l2 = rtcc.extract_amps(y0)
    mu0_x, mu0_y, mu0_z = rtcc.dipole(t1, t2, l1, l2)
    ecc0 = rtcc.lagrangian(t0, t1, t2, l1, l2)

    # For saving data at each time step.
    """
    dip_x = []
    dip_y = []
    dip_z = []
    time_points = []
    dip_x.append(mu0_x)
    dip_y.append(mu0_y)
    dip_z.append(mu0_z)
    time_points.append(t)
    """

    while t < tf:
        (y, h_old, h) = ODE(rtcc.f, t, y, h)
        t += h_old
        t1, t2, l1, l2 = rtcc.extract_amps(y)
        mu_x, mu_y, mu_z = rtcc.dipole(t1, t2, l1, l2)
        ecc = rtcc.lagrangian(t, t1, t2, l1, l2)
        """
        dip_x.append(mu_x)
        dip_y.append(mu_y)
        dip_z.append(mu_z)
        time_points.append(t)
        """

    print(mu_z)
    mu_z_ref = -0.34894577
    assert (abs(mu_z_ref - mu_z.real) < 1e-3)
예제 #53
0
파일: test_addons.py 프로젝트: votavap/psi4
def test_simint():
    """simint/scf5"""

    psi4.set_options({'integral_package': 'simint'})
    _test_scf5()
예제 #54
0
def test_geometric_hessian_rhf_right_hand_side():

    mol = molecules.molecule_physicists_water_sto3g()
    mol.reset_point_group("c1")
    mol.update_geometry()
    psi4.core.set_active_molecule(mol)

    options = {
        "BASIS": "STO-3G",
        "SCF_TYPE": "PK",
        "E_CONVERGENCE": 1e-10,
        "D_CONVERGENCE": 1e-10,
    }

    psi4.set_options(options)

    _, wfn = psi4.energy("hf", return_wfn=True)

    occupations = occupations_from_psi4wfn(wfn)
    nocc, nvir, _, _ = occupations
    norb = nocc + nvir

    o = slice(0, nocc)
    v = slice(nocc, norb)

    C = wfn.Ca_subset("AO", "ALL")
    npC = np.asarray(C)

    mints = psi4.core.MintsHelper(wfn)
    T = np.asarray(mints.ao_kinetic())
    V = np.asarray(mints.ao_potential())
    H_ao = T + V

    H = np.einsum("up,vq,uv->pq", npC, npC, H_ao)

    MO = np.asarray(mints.mo_eri(C, C, C, C))

    F = H + 2.0 * np.einsum("pqii->pq", MO[:, :, o, o])
    F -= np.einsum("piqi->pq", MO[:, o, :, o])
    F_ref = np.load(os.path.join(datadir, "F.npy"))
    np.testing.assert_allclose(F, F_ref, rtol=0, atol=1.0e-10)
    natoms = mol.natom()
    cart = ["_X", "_Y", "_Z"]
    oei_dict = {"S": "OVERLAP", "T": "KINETIC", "V": "POTENTIAL"}

    deriv1 = dict()

    # 1st Derivative of OEIs

    for atom in range(natoms):
        for key in oei_dict:
            deriv1_mat = mints.mo_oei_deriv1(oei_dict[key], atom, C, C)
            for p in range(3):
                map_key = key + str(atom) + cart[p]
                deriv1[map_key] = np.asarray(deriv1_mat[p])
                deriv1_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
                np.testing.assert_allclose(deriv1[map_key], deriv1_ref, rtol=0, atol=1.0e-10)

    # 1st Derivative of TEIs

    for atom in range(natoms):
        string = "TEI" + str(atom)
        deriv1_mat = mints.mo_tei_deriv1(atom, C, C, C, C)
        for p in range(3):
            map_key = string + cart[p]
            deriv1[map_key] = np.asarray(deriv1_mat[p])
            deriv1_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
            np.testing.assert_allclose(deriv1[map_key], deriv1_ref, rtol=0, atol=1.0e-10)

    # B_ia^x = S_ia^x * epsilon_ii - F_ia^x + S_mn^x * [2(ia|mn) - (in|ma)]

    F_grad = dict()
    B = dict()

    # Build F_pq^x now

    for atom in range(natoms):
        for p in range(3):
            key = str(atom) + cart[p]
            F_grad[key] = deriv1["T" + key]
            F_grad[key] += deriv1["V" + key]
            F_grad[key] += 2.0 * np.einsum("pqmm->pq", deriv1["TEI" + key][:, :, o, o])
            F_grad[key] -= 1.0 * np.einsum("pmmq->pq", deriv1["TEI" + key][:, o, o, :])
            F_grad_ref = np.load(os.path.join(datadir, f"F_grad_{key}.npy"))
            np.testing.assert_allclose(F_grad[key], F_grad_ref, rtol=0, atol=1.0e-10)

    # Build B_ia^x now

    for atom in range(natoms):
        for p in range(3):
            key = str(atom) + cart[p]
            B[key] = np.einsum("ia,ii->ia", deriv1["S" + key][o, v], F[o, o])
            B[key] -= F_grad[key][o, v]
            B[key] += 2.0 * np.einsum("iamn,mn->ia", MO[o, v, o, o], deriv1["S" + key][o, o])
            B[key] += -1.0 * np.einsum("inma,mn->ia", MO[o, o, o, v], deriv1["S" + key][o, o])

            B_ref = np.load(os.path.join(datadir, f"B_{key}.npy"))
            np.testing.assert_allclose(B[key], B_ref.T, rtol=0, atol=1.0e-10)

    from pyresponse.integrals import _form_rhs_geometric

    B_func = _form_rhs_geometric(npC, occupations, natoms, MO, mints)
    assert B_func.keys() == B.keys()
    for k in B_func:
        np.testing.assert_allclose(B_func[k], B[k], rtol=0, atol=1.0e-12)

    return B_func
예제 #55
0
#! that symmetry of the Molecule observes the basis assignment to atoms.

#           cc-pvdz                 aug-cc-pvdz
# BASIS     H  5/ 5   C  14/15      H +4/ 4   C  +9/10
# RIFIT     H 14/15   C  56/66      H +9/10   C +16/20
# JKFIT     H 23/25   C  70/81      H +9/10   C +16/20


mymol = psi4.geometry("""
C    0.0  0.0 0.0
O    1.4  0.0 0.0
H_r -0.5 -0.7 0.0
H_l -0.5  0.7 0.0
""")

psi4.set_options({'basis': 'cc-pvdz'})

print('[1]    <<<  uniform cc-pVDZ  >>>')
wert = psi4.core.BasisSet.build(mymol, 'BASIS', psi4.core.get_global_option('BASIS'))
psi4.compare_strings('CC-PVDZ', psi4.core.get_global_option('BASIS'), 'name')  #TEST
psi4.compare_integers(38, wert.nbf(), 'nbf()')  #TEST
psi4.compare_integers(40, wert.nao(), 'nao()')  #TEST
psi4.compare_strings('c2v', mymol.schoenflies_symbol(), 'symm')  #TEST
psi4.compare_strings('CC-PVDZ', wert.name(), 'callby')  #TEST
psi4.compare_strings('CC-PVDZ', wert.blend(), 'blend')  #TEST
mymol.print_out()


print('[2]        <<<  RIFIT (default)  >>>')
wert = psi4.core.BasisSet.build(mymol, 'DF_BASIS_MP2', '', 'RIFIT', psi4.core.get_global_option('BASIS'))
psi4.compare_integers(140, wert.nbf(), 'nbf()')  #TEST
예제 #56
0
def test_atomic_polar_tensor_rhf():
    mol = molecules.molecule_physicists_water_sto3g()
    mol.reset_point_group("c1")
    mol.update_geometry()
    psi4.core.set_active_molecule(mol)

    options = {
        "BASIS": "STO-3G",
        "SCF_TYPE": "PK",
        "E_CONVERGENCE": 1e-10,
        "D_CONVERGENCE": 1e-10,
    }

    psi4.set_options(options)

    _, wfn = psi4.energy("hf", return_wfn=True)
    mints = psi4.core.MintsHelper(wfn)

    C = mocoeffs_from_psi4wfn(wfn)
    E = moenergies_from_psi4wfn(wfn)
    occupations = occupations_from_psi4wfn(wfn)
    nocc, nvir, _, _ = occupations
    norb = nocc + nvir

    # electric perturbation part
    ao2mo = AO2MO(C, occupations, I=np.asarray(mints.ao_eri()))
    ao2mo.perform_rhf_full()
    solver = ExactInv(C, E, occupations)
    solver.tei_mo = ao2mo.tei_mo
    solver.tei_mo_type = AO2MOTransformationType.full
    driver = CPHF(solver)
    operator_diplen = Operator(
        label="dipole", is_imaginary=False, is_spin_dependent=False, triplet=False
    )
    # integrals_diplen_ao = self.pyscfmol.intor('cint1e_r_sph', comp=3)
    M = np.stack([np.asarray(Mc) for Mc in mints.ao_dipole()])
    operator_diplen.ao_integrals = M
    driver.add_operator(operator_diplen)

    # geometric perturbation part
    operator_geometric = Operator(
        label="nuclear", is_imaginary=False, is_spin_dependent=False, triplet=False
    )
    operator_geometric.form_rhs_geometric(C, occupations, mol.natom(), solver.tei_mo[0], mints)
    print(operator_geometric.label)
    print(operator_geometric.mo_integrals_ai_alph)
    print(operator_diplen.label)
    print(operator_diplen.mo_integrals_ai_alph)
    # hack for dim check in solver
    operator_geometric.ao_integrals = np.zeros((3 * mol.natom(), M.shape[1], M.shape[2]))
    # bypass driver's call to form_rhs
    driver.solver.operators.append(operator_geometric)

    driver.run(
        hamiltonian=Hamiltonian.RPA,
        spin=Spin.singlet,
        program=Program.Psi4,
        program_obj=wfn,
    )
    print(driver.results[0])
    print(driver.results[0].T)
    print(driver.results[0] - driver.results[0].T)
    print(operator_geometric.rspvecs_alph[0])
    # Nuclear contribution to dipole gradient
    # Electronic contributions to static part of dipole gradient
    # Reorthonormalization part of dipole gradient
    # Static contribution to dipole gradient
    # Relaxation part of dipole gradient
    # Total dipole gradient - TRAROT

    print("Nuclear contribution to dipole gradient")
    natom = mol.natom()
    Z = np.asarray([mol.Z(i) for i in range(natom)])
    nuclear_contrib = np.concatenate([np.diag(Z.take(3 * [i])) for i in range(natom)])
    print(nuclear_contrib)

    return locals()
예제 #57
0
def test_unrestricted_RPA_C1():
    ch2 = psi4.geometry("""
    0 3
    c
    h 1 1.0
    h 1 1.0 2 125.0
    symmetry c1
    """)
    psi4.set_options({"scf_type": "pk", 'reference': 'UHF', 'save_jk': True})
    e, wfn = psi4.energy("hf/cc-pvdz", molecule=ch2, return_wfn=True)
    A_ref, B_ref = build_UHF_AB_C1(wfn)
    nI, nA, _, _ = A_ref['IAJB'].shape
    nIA = nI * nA
    ni, na, _, _ = A_ref['iajb'].shape
    nia = ni * na

    P_ref = {k: A_ref[k] + B_ref[k] for k in A_ref.keys()}
    M_ref = {k: A_ref[k] - B_ref[k] for k in A_ref.keys()}

    eng = TDUSCFEngine(wfn, ptype='rpa')
    X_jb = [
        psi4.core.Matrix.from_array(v.reshape((ni, na)))
        for v in tuple(np.eye(nia).T)
    ]
    zero_jb = [psi4.core.Matrix(ni, na) for x in range(nIA)]
    X_JB = [
        psi4.core.Matrix.from_array(v.reshape((nI, nA)))
        for v in tuple(np.eye(nIA).T)
    ]
    zero_JB = [psi4.core.Matrix(nI, nA) for x in range(nia)]
    # Guess Identity:
    #     X_I0          X_0I          =      X_I0      X_0I
    # [ I{nOV x nOV} | 0{nOV x nov}]  = [ X{KC,JB} | 0{KC, jb}]
    # [ 0{nov x nOV} | I{nov x nov}]    [ 0{kc,JB} | X{kc, jb}]

    # Products:
    # [ A+/-B{IA, KC}  A+/-B{IA, kc}] [ I{KC, JB} |  0{KC,jb}] = [A+/-B x X_I0] = [ (A+/-B)_IAJB, (A+/-B)_iaJB]
    # [ A+/-B{ia, KC}  A+/-B{ia, kc}] [ O{kc, JB} |  X{kc,jb}]   [A+/-B x X_0I] = [ (A+/-B)_IAjb, (A+/-B)_iajb]
    X_I0 = [[x, zero] for x, zero in zip(X_JB, zero_jb)]
    X_0I = [[zero, x] for zero, x in zip(zero_JB, X_jb)]
    Px_I0, Mx_I0 = eng.compute_products(X_I0)[:-1]
    Px_0I, Mx_0I = eng.compute_products(X_0I)[:-1]

    P_IAJB_test = np.column_stack([x[0].to_array().flatten() for x in Px_I0])
    assert compare_arrays(P_ref['IAJB'].reshape(nIA, nIA), P_IAJB_test, 8,
                          "A_IAJB")

    M_IAJB_test = np.column_stack([x[0].to_array().flatten() for x in Mx_I0])
    assert compare_arrays(M_ref['IAJB'].reshape(nIA, nIA), M_IAJB_test, 8,
                          "A_IAJB")

    P_iaJB_test = np.column_stack([x[1].to_array().flatten() for x in Px_I0])
    assert compare_arrays(P_ref['iaJB'].reshape(nia, nIA), P_iaJB_test, 8,
                          "P_iaJB")

    M_iaJB_test = np.column_stack([x[1].to_array().flatten() for x in Mx_I0])
    assert compare_arrays(M_ref['iaJB'].reshape(nia, nIA), M_iaJB_test, 8,
                          "M_iaJB")

    P_IAjb_test = np.column_stack([x[0].to_array().flatten() for x in Px_0I])
    assert compare_arrays(P_ref['IAjb'].reshape(nIA, nia), P_IAjb_test, 8,
                          "P_IAjb")

    M_IAjb_test = np.column_stack([x[0].to_array().flatten() for x in Mx_0I])
    assert compare_arrays(M_ref['IAjb'].reshape(nIA, nia), M_IAjb_test, 8,
                          "M_IAjb")

    P_iajb_test = np.column_stack([x[1].to_array().flatten() for x in Px_0I])
    assert compare_arrays(P_ref['iajb'].reshape(nia, nia), P_iajb_test, 8,
                          "P_iajb")

    M_iajb_test = np.column_stack([x[1].to_array().flatten() for x in Mx_0I])
    assert compare_arrays(M_ref['iajb'].reshape(nia, nia), M_iajb_test, 8,
                          "M_iajb")
예제 #58
0
def test_geometric_hessian_rhf_outside_solver_chemists():
    psi4.core.set_output_file("output2.dat", False)

    mol = molecules.molecule_physicists_water_sto3g()
    mol.reset_point_group("c1")
    mol.update_geometry()
    psi4.core.set_active_molecule(mol)

    options = {
        "BASIS": "STO-3G",
        "SCF_TYPE": "PK",
        "E_CONVERGENCE": 1e-10,
        "D_CONVERGENCE": 1e-10,
    }

    psi4.set_options(options)

    _, wfn = psi4.energy("hf", return_wfn=True)

    norb = wfn.nmo()
    nocc = wfn.nalpha()
    nvir = norb - nocc

    o = slice(0, nocc)
    v = slice(nocc, norb)

    C = wfn.Ca_subset("AO", "ALL")
    npC = np.asarray(C)

    mints = psi4.core.MintsHelper(wfn)
    T = np.asarray(mints.ao_kinetic())
    V = np.asarray(mints.ao_potential())
    H_ao = T + V

    H = np.einsum("up,vq,uv->pq", npC, npC, H_ao)

    MO = np.asarray(mints.mo_eri(C, C, C, C))

    F = H + 2.0 * np.einsum("pqii->pq", MO[:, :, o, o])
    F -= np.einsum("piqi->pq", MO[:, o, :, o])
    F_ref = np.load(os.path.join(datadir, "F.npy"))
    np.testing.assert_allclose(F, F_ref, rtol=0, atol=1.0e-10)
    natoms = mol.natom()
    cart = ["_X", "_Y", "_Z"]
    oei_dict = {"S": "OVERLAP", "T": "KINETIC", "V": "POTENTIAL"}

    deriv1_mat = {}
    deriv1 = {}

    # 1st Derivative of OEIs

    for atom in range(natoms):
        for key in oei_dict:
            deriv1_mat[key + str(atom)] = mints.mo_oei_deriv1(oei_dict[key], atom, C, C)
            for p in range(3):
                map_key = key + str(atom) + cart[p]
                deriv1[map_key] = np.asarray(deriv1_mat[key + str(atom)][p])
                deriv1_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
                np.testing.assert_allclose(deriv1[map_key], deriv1_ref, rtol=0, atol=1.0e-10)

    # 1st Derivative of TEIs

    for atom in range(natoms):
        string = "TEI" + str(atom)
        deriv1_mat[string] = mints.mo_tei_deriv1(atom, C, C, C, C)
        for p in range(3):
            map_key = string + cart[p]
            deriv1[map_key] = np.asarray(deriv1_mat[string][p])
            deriv1_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
            np.testing.assert_allclose(deriv1[map_key], deriv1_ref, rtol=0, atol=1.0e-10)

    Hes = {}
    deriv2_mat = {}
    deriv2 = {}

    Hes["S"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["V"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["T"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["N"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["J"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["K"] = np.zeros((3 * natoms, 3 * natoms))
    Hes["R"] = np.zeros((3 * natoms, 3 * natoms))
    Hessian = np.zeros((3 * natoms, 3 * natoms))

    Hes["N"] = np.asarray(mol.nuclear_repulsion_energy_deriv2())

    psi4.core.print_out("\n\n")
    Mat = psi4.core.Matrix.from_array(Hes["N"])
    Mat.name = "NUCLEAR HESSIAN"
    Mat.print_out()

    # 2nd Derivative of OEIs

    for atom1 in range(natoms):
        for atom2 in range(atom1 + 1):
            for key in oei_dict:
                string = key + str(atom1) + str(atom2)
                deriv2_mat[string] = mints.mo_oei_deriv2(oei_dict[key], atom1, atom2, C, C)
                pq = 0
                for p in range(3):
                    for q in range(3):
                        map_key = string + cart[p] + cart[q]
                        deriv2[map_key] = np.asarray(deriv2_mat[string][pq])
                        deriv2_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
                        np.testing.assert_allclose(
                            deriv2[map_key], deriv2_ref, rtol=0, atol=1.0e-10
                        )
                        pq = pq + 1
                        row = 3 * atom1 + p
                        col = 3 * atom2 + q
                        if key == "S":
                            Hes[key][row][col] = -2.0 * np.einsum(
                                "ii,ii->", F[o, o], deriv2[map_key][o, o]
                            )
                        else:
                            Hes[key][row][col] = 2.0 * np.einsum("ii->", deriv2[map_key][o, o])
                        Hes[key][col][row] = Hes[key][row][col]
                        Hes[key][col][row] = Hes[key][row][col]
                        Hes_ref = np.load(os.path.join(datadir, f"Hes_{map_key}.npy"))
                        np.testing.assert_allclose(Hes[key], Hes_ref, rtol=0, atol=1.0e-10)

    for key in Hes:
        Mat = psi4.core.Matrix.from_array(Hes[key])
        if key in oei_dict:
            Mat.name = oei_dict[key] + " HESSIAN"
            Mat.print_out()
            psi4.core.print_out("\n")

    # 2nd Derivative of TEIs

    for atom1 in range(natoms):
        for atom2 in range(atom1 + 1):
            string = "TEI" + str(atom1) + str(atom2)
            deriv2_mat[string] = mints.mo_tei_deriv2(atom1, atom2, C, C, C, C)
            pq = 0
            for p in range(3):
                for q in range(3):
                    map_key = string + cart[p] + cart[q]
                    deriv2[map_key] = np.asarray(deriv2_mat[string][pq])
                    deriv2_ref = np.load(os.path.join(datadir, f"{map_key}.npy"))
                    np.testing.assert_allclose(deriv2[map_key], deriv2_ref, rtol=0, atol=1.0e-10)
                    pq = pq + 1
                    row = 3 * atom1 + p
                    col = 3 * atom2 + q
                    Hes["J"][row][col] = 2.0 * np.einsum("iijj->", deriv2[map_key][o, o, o, o])
                    Hes["K"][row][col] = -1.0 * np.einsum("ijij->", deriv2[map_key][o, o, o, o])

                    Hes["J"][col][row] = Hes["J"][row][col]
                    Hes["K"][col][row] = Hes["K"][row][col]
    for map_key in ("J", "K"):
        Hes_ref = np.load(os.path.join(datadir, f"Hes_{map_key}.npy"))
        np.testing.assert_allclose(Hes[map_key], Hes_ref, rtol=0, atol=1.0e-10)

    JMat = psi4.core.Matrix.from_array(Hes["J"])
    KMat = psi4.core.Matrix.from_array(Hes["K"])
    JMat.name = " COULOMB  HESSIAN"
    KMat.name = " EXCHANGE HESSIAN"
    JMat.print_out()
    KMat.print_out()

    # Solve the CPHF equations here,  G_iajb U_jb^x = B_ia^x (Einstein summation),
    # where G is the electronic hessian,
    # G_iajb = delta_ij * delta_ab * epsilon_ij * epsilon_ab + 4(ia|jb) - (ij|ab) - (ib|ja),
    # where epsilon_ij = epsilon_i - epsilon_j, (epsilon -> orbital energies),
    # x refers to the perturbation, U_jb^x are the corresponsing CPHF coefficients
    # and B_ia^x = S_ia^x * epsilon_ii - F_ia^x + S_mn^x * [2(ia|mn) - (in|ma)],
    # where S^x = del(S)/del(x), F^x =  del(F)/del(x).

    I_occ = np.diag(np.ones(nocc))
    I_vir = np.diag(np.ones(nvir))
    epsilon = np.asarray(wfn.epsilon_a())
    eps_diag = epsilon[v].reshape(-1, 1) - epsilon[o]

    #  Build the electronic hessian G

    G = 4 * MO[o, v, o, v]
    G -= MO[o, o, v, v].swapaxes(1, 2)
    G -= MO[o, v, o, v].swapaxes(1, 3)
    G += np.einsum("ai,ij,ab->iajb", eps_diag, I_occ, I_vir)
    G_ref = np.load(os.path.join(datadir, "G.npy"))
    np.testing.assert_allclose(G, G_ref, rtol=0, atol=1.0e-10)

    # Inverse of G
    Ginv = np.linalg.inv(G.reshape(nocc * nvir, -1))
    Ginv = Ginv.reshape(nocc, nvir, nocc, nvir)

    B = {}
    F_grad = {}
    U = {}

    # Build F_pq^x now

    for atom in range(natoms):
        for p in range(3):
            key = str(atom) + cart[p]
            F_grad[key] = deriv1["T" + key]
            F_grad[key] += deriv1["V" + key]
            F_grad[key] += 2.0 * np.einsum("pqmm->pq", deriv1["TEI" + key][:, :, o, o])
            F_grad[key] -= 1.0 * np.einsum("pmmq->pq", deriv1["TEI" + key][:, o, o, :])
            F_grad_ref = np.load(os.path.join(datadir, f"F_grad_{key}.npy"))
            np.testing.assert_allclose(F_grad[key], F_grad_ref, rtol=0, atol=1.0e-10)

    psi4.core.print_out("\n\n CPHF Coefficients:\n")

    # Build B_ia^x now

    for atom in range(natoms):
        for p in range(3):
            key = str(atom) + cart[p]
            B[key] = np.einsum("ia,ii->ia", deriv1["S" + key][o, v], F[o, o])
            B[key] -= F_grad[key][o, v]
            B[key] += 2.0 * np.einsum("iamn,mn->ia", MO[o, v, o, o], deriv1["S" + key][o, o])
            B[key] += -1.0 * np.einsum("inma,mn->ia", MO[o, o, o, v], deriv1["S" + key][o, o])

            print(f"B[{key}]")
            print(B[key])
            B_ref = np.load(os.path.join(datadir, f"B_{key}.npy"))
            np.testing.assert_allclose(B[key], B_ref.T, rtol=0, atol=1.0e-10)

            # Compute U^x now: U_ia^x = G^(-1)_iajb * B_jb^x

            U[key] = np.einsum("iajb,jb->ia", Ginv, B[key])
            psi4.core.print_out("\n")
            UMat = psi4.core.Matrix.from_array(U[key])
            UMat.name = key
            UMat.print_out()

            U_ref = np.load(os.path.join(datadir, f"U_{key}.npy"))
            np.testing.assert_allclose(U[key], U_ref.T, rtol=0, atol=1.0e-10)

    # Build the response Hessian

    for atom1 in range(natoms):
        for atom2 in range(atom1 + 1):
            for p in range(3):
                for q in range(3):
                    key1 = str(atom1) + cart[p]
                    key2 = str(atom2) + cart[q]
                    key1S = "S" + key1
                    key2S = "S" + key2
                    r = 3 * atom1 + p
                    c = 3 * atom2 + q

                    Hes["R"][r][c] = -2.0 * np.einsum(
                        "ij,ij->", deriv1[key1S][o, o], F_grad[key2][o, o]
                    )
                    Hes["R"][r][c] -= 2.0 * np.einsum(
                        "ij,ij->", deriv1[key2S][o, o], F_grad[key1][o, o]
                    )
                    Hes["R"][r][c] += 4.0 * np.einsum(
                        "ii,mi,mi->", F[o, o], deriv1[key2S][o, o], deriv1[key1S][o, o]
                    )

                    Hes["R"][r][c] += 4.0 * np.einsum(
                        "ij,mn,ijmn->",
                        deriv1[key1S][o, o],
                        deriv1[key2S][o, o],
                        MO[o, o, o, o],
                    )
                    Hes["R"][r][c] -= 2.0 * np.einsum(
                        "ij,mn,inmj->",
                        deriv1[key1S][o, o],
                        deriv1[key2S][o, o],
                        MO[o, o, o, o],
                    )

                    Hes["R"][r][c] -= 4.0 * np.einsum("ia,ia->", U[key2], B[key1])
                    Hes["R"][c][r] = Hes["R"][r][c]

    Hes_ref = np.load(os.path.join(datadir, "Hes_R.npy"))
    np.testing.assert_allclose(Hes["R"], Hes_ref, rtol=0, atol=1.0e-10)

    Mat = psi4.core.Matrix.from_array(Hes["R"])
    Mat.name = " RESPONSE HESSIAN"
    Mat.print_out()

    for key in Hes:
        Hessian += Hes[key]

    # print('deriv1_mat')
    # print(deriv1_mat.keys())
    # print('deriv1')
    # print(deriv1.keys())
    # print('deriv2_mat')
    # print(deriv2_mat.keys())
    # print('deriv2')
    # print(deriv2.keys())
    # print('B')
    # print(B.keys())
    # print('F_grad')
    # print(F_grad.keys())
    # print('U')
    # print(U.keys())
    # print('Hes')
    # print(Hes.keys())

    Mat = psi4.core.Matrix.from_array(Hessian)
    Mat.name = " TOTAL HESSIAN"
    Mat.print_out()

    # pylint: disable=bad-whitespace
    H_psi4 = psi4.core.Matrix.from_list(
        [
            [
                7.613952269164418751e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -3.806976134297335168e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -3.806976134297410108e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
            ],
            [
                0.000000000000000000e00,
                4.829053723748517601e-01,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -2.414526861845633920e-01,
                1.589001558536450587e-01,
                0.000000000000000000e00,
                -2.414526861845646133e-01,
                -1.589001558536444758e-01,
            ],
            [
                0.000000000000000000e00,
                0.000000000000000000e00,
                4.373449597848400039e-01,
                0.000000000000000000e00,
                7.344233774055003439e-02,
                -2.186724798895446076e-01,
                0.000000000000000000e00,
                -7.344233774054893804e-02,
                -2.186724798895475219e-01,
            ],
            [
                -3.806976134297335168e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                4.537741758645107149e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -7.307656243475501093e-03,
                0.000000000000000000e00,
                0.000000000000000000e00,
            ],
            [
                0.000000000000000000e00,
                -2.414526861845633920e-01,
                7.344233774055003439e-02,
                0.000000000000000000e00,
                2.578650065921952450e-01,
                -1.161712467970963669e-01,
                0.000000000000000000e00,
                -1.641232040762596878e-02,
                4.272890905654690846e-02,
            ],
            [
                0.000000000000000000e00,
                1.589001558536450587e-01,
                -2.186724798895446076e-01,
                0.000000000000000000e00,
                -1.161712467970963669e-01,
                1.977519807685419462e-01,
                0.000000000000000000e00,
                -4.272890905654720684e-02,
                2.092049912100946499e-02,
            ],
            [
                -3.806976134297410108e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
                -7.307656243475501093e-03,
                0.000000000000000000e00,
                0.000000000000000000e00,
                4.537741758645268131e-02,
                0.000000000000000000e00,
                0.000000000000000000e00,
            ],
            [
                0.000000000000000000e00,
                -2.414526861845646133e-01,
                -7.344233774054893804e-02,
                0.000000000000000000e00,
                -1.641232040762596878e-02,
                -4.272890905654720684e-02,
                0.000000000000000000e00,
                2.578650065921969103e-01,
                1.161712467970957008e-01,
            ],
            [
                0.000000000000000000e00,
                -1.589001558536444758e-01,
                -2.186724798895475219e-01,
                0.000000000000000000e00,
                4.272890905654690846e-02,
                2.092049912100946499e-02,
                0.000000000000000000e00,
                1.161712467970957008e-01,
                1.977519807685442221e-01,
            ],
        ]
    )

    H_python_mat = psi4.core.Matrix.from_array(Hessian)
    psi4.compare_matrices(H_psi4, H_python_mat, 10, "RHF-HESSIAN-TEST")  # TEST
예제 #59
0
# Memory for Psi4 in GB
psi4.core.set_memory(int(2e9), False)
psi4.core.set_output_file('output.dat', False)

# Memory for numpy in GB
numpy_memory = 2

mol = psi4.geometry("""
O
H 1 1.1
H 1 1.1 2 104
symmetry c1
""")

# Set some options
psi4.set_options({"basis": "cc-pvdz", "scf_type": "pk", "e_convergence": 1e-8})

# Set defaults
maxiter = 40
E_conv = 1.0E-8
D_conv = 1.0E-3

# Integral generation from Psi4's MintsHelper
wfn = psi4.core.Wavefunction.build(mol, psi4.core.get_global_option('BASIS'))
t = time.time()
mints = psi4.core.MintsHelper(wfn.basisset())
S = np.asarray(mints.ao_overlap())

# Get nbf and ndocc for closed shell molecules
nbf = wfn.nso()
ndocc = wfn.nalpha()
예제 #60
0
파일: test_addons.py 프로젝트: votavap/psi4
def _test_scf5():
    """scf5"""
    #! Test of all different algorithms and reference types for SCF, on singlet and triplet O2, using the cc-pVTZ basis set and using ERD integrals.

    psi4.print_stdout(' Case Study Test of all SCF algorithms/spin-degeneracies: Singlet-Triplet O2')
    psi4.print_stdout('    -Integral package: {}'.format(psi4.core.get_global_option('integral_package')))

    #Ensure that the checkpoint file is always nuked
    psi4.core.IOManager.shared_object().set_specific_retention(32,False)

    Eref_nuc      =   30.78849213614545
    Eref_sing_can = -149.58723684929720
    Eref_sing_df  = -149.58715054487624
    Eref_uhf_can  = -149.67135517240553
    Eref_uhf_df   = -149.67125624291961
    Eref_rohf_can = -149.65170765757173
    Eref_rohf_df  = -149.65160796208073

    singlet_o2 = psi4.geometry("""
        0 1
        O
        O 1 1.1
        units    angstrom
    """)

    triplet_o2 = psi4.geometry("""
        0 3
        O
        O 1 1.1
        units    angstrom
    """)
    singlet_o2.update_geometry()
    triplet_o2.update_geometry()

    psi4.print_stdout('    -Nuclear Repulsion:')
    assert psi4.compare_values(Eref_nuc, triplet_o2.nuclear_repulsion_energy(), 9, "Triplet nuclear repulsion energy")
    assert psi4.compare_values(Eref_nuc, singlet_o2.nuclear_repulsion_energy(), 9, "Singlet nuclear repulsion energy")

    psi4.set_options({
        'basis': 'cc-pvtz',
        'df_basis_scf': 'cc-pvtz-jkfit',
        'print': 2})

    print('    -Singlet RHF:')
    psi4.set_module_options('scf', {'reference': 'rhf'})

    psi4.set_module_options('scf', {'scf_type': 'pk'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet PK RHF energy')

    psi4.set_module_options('scf', {'scf_type': 'direct'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet Direct RHF energy')

    psi4.set_module_options('scf', {'scf_type': 'out_of_core'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet Disk RHF energy')

    psi4.set_module_options('scf', {'scf_type': 'df'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_df, E, 6, 'Singlet DF RHF energy')

    print('    -Singlet UHF:')
    psi4.set_module_options('scf', {'reference': 'uhf'})

    psi4.set_module_options('scf', {'scf_type': 'pk'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet PK UHF energy')

    psi4.set_module_options('scf', {'scf_type': 'direct'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet Direct UHF energy')

    psi4.set_module_options('scf', {'scf_type': 'out_of_core'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet Disk UHF energy')

    psi4.set_module_options('scf', {'scf_type': 'df'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_df, E, 6, 'Singlet DF UHF energy')

    print('    -Singlet CUHF:')
    psi4.set_module_options('scf', {'reference': 'cuhf'})

    psi4.set_module_options('scf', {'scf_type': 'pk'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet PK CUHF energy')

    psi4.set_module_options('scf', {'scf_type': 'direct'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet Direct CUHF energy')

    psi4.set_module_options('scf', {'scf_type': 'out_of_core'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_can, E, 6, 'Singlet Disk CUHF energy')

    psi4.set_module_options('scf', {'scf_type': 'df'})
    E = psi4.energy('scf', molecule=singlet_o2)
    assert psi4.compare_values(Eref_sing_df, E, 6, 'Singlet DF CUHF energy')

    psi4.set_options({
        'basis': 'cc-pvtz',
        'df_basis_scf': 'cc-pvtz-jkfit',
        'guess': 'core',
        'print': 2})

    print('    -Triplet UHF:')
    psi4.set_module_options('scf', {'reference': 'uhf'})

    psi4.set_module_options('scf', {'scf_type': 'pk'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_uhf_can, E, 6, 'Triplet PK UHF energy')

    psi4.set_module_options('scf', {'scf_type': 'direct'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_uhf_can, E, 6, 'Triplet Direct UHF energy')

    psi4.set_module_options('scf', {'scf_type': 'out_of_core'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_uhf_can, E, 6, 'Triplet Disk UHF energy')

    psi4.set_module_options('scf', {'scf_type': 'df'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_uhf_df, E, 6, 'Triplet DF UHF energy')
    psi4.core.clean()

    print('    -Triplet ROHF:')
    psi4.set_module_options('scf', {'reference': 'rohf'})

    psi4.set_module_options('scf', {'scf_type': 'pk'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_can, E, 6, 'Triplet PK ROHF energy')
    psi4.core.clean()

    psi4.set_module_options('scf', {'scf_type': 'direct'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_can, E, 6, 'Triplet Direct ROHF energy')
    psi4.core.clean()

    psi4.set_module_options('scf', {'scf_type': 'out_of_core'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_can, E, 6, 'Triplet Disk ROHF energy')
    psi4.core.clean()

    psi4.set_module_options('scf', {'scf_type': 'df'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_df, E, 6, 'Triplet DF ROHF energy')
    psi4.core.clean()

    print('    -Triplet CUHF:')
    psi4.set_module_options('scf', {'reference': 'cuhf'})

    psi4.set_module_options('scf', {'scf_type': 'pk'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_can, E, 6, 'Triplet PK CUHF energy')
    psi4.core.clean()

    psi4.set_module_options('scf', {'scf_type': 'direct'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_can, E, 6, 'Triplet Direct CUHF energy')
    psi4.core.clean()

    psi4.set_module_options('scf', {'scf_type': 'out_of_core'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_can, E, 6, 'Triplet Disk CUHF energy')
    psi4.core.clean()

    psi4.set_module_options('scf', {'scf_type': 'df'})
    E = psi4.energy('scf', molecule=triplet_o2)
    assert psi4.compare_values(Eref_rohf_df, E, 6, 'Triplet DF CUHF energy')