Exemple #1
0
    def test_rhf_smearing(self):
        mf = pscf.RHF(cell)
        pscf.addons.smearing_(mf, 0.1, 'fermi')
        mo_energy = numpy.arange(nao)*.2+numpy.cos(.5)*.1
        mf.get_occ(mo_energy)
        self.assertAlmostEqual(mf.entropy, 3.0922723199786408, 9)

        mf.smearing_method = 'gauss'
        occ = mf.get_occ(mo_energy)
        self.assertAlmostEqual(mf.entropy, 0.4152467504725415, 9)

        mf.kernel()
        self.assertAlmostEqual(mf.entropy, 0, 15)
Exemple #2
0
    def test_ccsd_t_hf(self):
        '''Tests ccsd and ccsd_t for Hartree-Fock references using supercell
        vs k-point calculation.'''
        n = 14
        cell = make_test_cell.test_cell_n3([n] * 3)

        nk = [2, 1, 1]
        kpts = cell.make_kpts(nk)
        kpts -= kpts[0]
        kks = pbcscf.KRHF(cell, kpts=kpts)
        ekks = kks.kernel()

        khf = pbcscf.KRHF(cell)
        khf.__dict__.update(kks.__dict__)

        mycc = pbcc.KRCCSD(khf)
        eris = mycc.ao2mo()
        ekcc, t1, t2 = mycc.kernel(eris=eris)
        ekcc_t = mycc.ccsd_t(eris=eris)

        # Run supercell
        from pyscf.pbc.tools.pbc import super_cell
        supcell = super_cell(cell, nk)
        rks = pbcscf.RHF(supcell)
        erks = rks.kernel()

        rhf = pbcscf.RHF(supcell)
        rhf.__dict__.update(rks.__dict__)

        mycc = pbcc.RCCSD(rhf)
        eris = mycc.ao2mo()
        ercc, t1, t2 = mycc.kernel(eris=eris)
        self.assertAlmostEqual(ercc / np.prod(nk), -0.15530756381467772, 6)
        self.assertAlmostEqual(ercc / np.prod(nk), ekcc, 6)

        ercc_t = mycc.ccsd_t(eris=eris)
        self.assertAlmostEqual(ercc_t / np.prod(nk), -0.0011112735513837887, 6)
        self.assertAlmostEqual(ercc_t / np.prod(nk), ekcc_t, 6)
Exemple #3
0
    def test_ccsd_t_hf_frozen(self):
        '''Tests ccsd and ccsd_t for Hartree-Fock references with frozen orbitals
        using supercell vs k-point calculation.'''
        n = 14
        cell = make_test_cell.test_cell_n3([n] * 3)

        nk = [2, 1, 1]
        kpts = cell.make_kpts(nk)
        kpts -= kpts[0]
        kks = pbcscf.KRHF(cell, kpts=kpts)
        ekks = kks.kernel()

        khf = pbcscf.KRHF(cell)
        khf.__dict__.update(kks.__dict__)

        mycc = pbcc.KRCCSD(khf, frozen=1)
        eris = mycc.ao2mo()
        ekcc, t1, t2 = mycc.kernel(eris=eris)
        ekcc_t = mycc.ccsd_t(eris=eris)

        # Run supercell
        from pyscf.pbc.tools.pbc import super_cell
        supcell = super_cell(cell, nk)
        rks = pbcscf.RHF(supcell)
        erks = rks.kernel()

        rhf = pbcscf.RHF(supcell)
        rhf.__dict__.update(rks.__dict__)

        mycc = pbcc.RCCSD(rhf, frozen=2)
        eris = mycc.ao2mo()
        ercc, t1, t2 = mycc.kernel(eris=eris)
        self.assertAlmostEqual(ercc / np.prod(nk), -0.1137362020855094, 6)
        self.assertAlmostEqual(ercc / np.prod(nk), ekcc, 6)

        ercc_t = mycc.ccsd_t(eris=eris)
        self.assertAlmostEqual(ercc_t / np.prod(nk), -0.0006758642528821, 6)
        self.assertAlmostEqual(ercc_t / np.prod(nk), ekcc_t, 6)
Exemple #4
0
 def test_hf(self):
     with lib.light_speed(2) as c:
         mf = scf.RHF(cell).sfx2c1e()
         mf.with_df = df.AFTDF(cell)
         dm = mf.get_init_guess()
         h1 = mf.get_hcore()
         self.assertAlmostEqual(
             numpy.einsum('ij,ji', dm, h1),
             2 / 3.7865300454631 * -0.47578184212352159 + 0j, 8)
         kpts = cell.make_kpts([3, 1, 1])
         h1 = mf.get_hcore(kpt=kpts[1])
         self.assertAlmostEqual(
             numpy.einsum('ij,ji', dm, h1),
             2 / 3.7865300454631 * -0.09637799091491725 + 0j, 8)
Exemple #5
0
    def test_get_jk_with_casscf(self):
        from pyscf import mcscf
        pcell = cell2.copy()
        pcell.verbose = 0
        pcell.mesh = [8]*3
        mf = pbcscf.RHF(pcell)
        mf.exxdiv = None
        ehf = mf.kernel()

        mc = mcscf.CASSCF(mf, 1, 2).run()
        self.assertAlmostEqual(mc.e_tot, ehf, 9)

        mc = mcscf.CASSCF(mf, 2, 0).run()
        self.assertAlmostEqual(mc.e_tot, ehf, 9)
Exemple #6
0
    def test_krhf_vs_rhf(self):
        np.random.seed(1)
        k = np.random.random(3)
        mf = pscf.RHF(cell, k, exxdiv='vcut_sph')
        mf.max_cycle = 1
        mf.diis = None
        e1 = mf.kernel()

        kmf = pscf.KRHF(cell, [k], exxdiv='vcut_sph')
        kmf.max_cycle = 1
        kmf.diis = None
        e2 = kmf.kernel()
        self.assertAlmostEqual(e1, e2, 9)
        self.assertAlmostEqual(e1, -11.451118801956275, 9)
def get_scf(cell):

    scf = pbchf.RHF(cell, exxdiv=None)
    scf.conv_tol = 1e-10
    scf.conv_tol_grad = 1e-8
    scf.diis = True
    scf.diis_space = 20
    scf.direct_scf_tol = 1e-14
    scf.init_guess = 'minao'
    scf.max_cycle = 200
    scf.max_memory = 8000
    scf.verbose = 10
    scf.scf()

    return scf
Exemple #8
0
def k2gamma(kmf, kmesh=None):
    r'''
    convert the k-sampled mean-field object to the corresponding supercell
    gamma-point mean-field object.

    math:
         C_{\nu ' n'} = C_{\vecR\mu, \veck m} = \frac{1}{\sqrt{N_{\UC}}}
         \e^{\ii \veck\cdot\vecR} C^{\veck}_{\mu  m}
    '''
    def transform(mo_energy, mo_coeff, mo_occ):
        scell, E_g, C_gamma = mo_k2gamma(kmf.cell, mo_energy, mo_coeff,
                                         kmf.kpts, kmesh)[:3]
        E_sort_idx = np.argsort(np.hstack(mo_energy))
        mo_occ = np.hstack(mo_occ)[E_sort_idx]
        return scell, E_g, C_gamma, mo_occ

    if isinstance(kmf, scf.khf.KRHF):
        scell, E_g, C_gamma, mo_occ = transform(kmf.mo_energy, kmf.mo_coeff,
                                                kmf.mo_occ)
        mf = scf.RHF(scell)
    elif isinstance(kmf, scf.kuhf.KUHF):
        scell, Ea, Ca, occ_a = transform(kmf.mo_energy[0], kmf.mo_coeff[0],
                                         kmf.mo_occ[0])
        scell, Eb, Cb, occ_b = transform(kmf.mo_energy[1], kmf.mo_coeff[1],
                                         kmf.mo_occ[1])
        mf = scf.UHF(scell)
        E_g = [Ea, Eb]
        C_gamma = [Ca, Cb]
        mo_occ = [occ_a, occ_b]
    else:
        raise NotImplementedError('SCF object %s not supported' % kmf)

    mf.mo_coeff = C_gamma
    mf.mo_energy = E_g
    mf.mo_occ = mo_occ
    mf.converged = kmf.converged
    # Scale energy by number of primitive cells within supercell
    mf.e_tot = len(kmf.kpts) * kmf.e_tot

    # Use unfolded overlap matrix for better error cancellation
    #s_k = kmf.cell.pbc_intor('int1e_ovlp', hermi=1, kpts=kmf.kpts, pbcopt=lib.c_null_ptr())
    s_k = kmf.get_ovlp()
    ovlp = to_supercell_ao_integrals(kmf.cell, kmf.kpts, s_k)
    assert np.allclose(ovlp, ovlp.T)
    ovlp = (ovlp + ovlp.T) / 2
    mf.get_ovlp = lambda *args: ovlp

    return mf
Exemple #9
0
def setUpModule():
    global cell, cell1, mf0, kmdf, kmdf1, kpts
    L = 5.
    n = 11
    cell = pgto.Cell()
    cell.a = numpy.diag([L,L,L])
    cell.mesh = numpy.array([n,n,n])

    cell.atom = '''C    3.    2.       3.
                   C    1.    1.       1.'''
    cell.basis = 'ccpvdz'
    cell.verbose = 0
    cell.rcut = 17
    cell.build(0,0)

    mf0 = pscf.RHF(cell)
    mf0.exxdiv = 'vcut_sph'


    numpy.random.seed(1)
    kpts = numpy.random.random((5,3))
    kpts[0] = 0
    kpts[3] = kpts[0]-kpts[1]+kpts[2]
    kpts[4] *= 1e-5

    kmdf = mdf.MDF(cell)
    kmdf.linear_dep_threshold = 1e-7
    kmdf.auxbasis = 'weigend'
    kmdf.kpts = kpts
    kmdf.mesh = (11,)*3
    kmdf.eta = 0.154728892598

    cell1 = pgto.Cell()
    cell1.a = numpy.eye(3) * 3.
    cell1.mesh = [10]*3
    cell1.atom = '''C    3.    2.       3.
                   C    1.    1.       1.'''
    cell1.basis = [[0, (3.5, 1)], [0, (1.0, 1)], [1, (0.6, 1)]]
    cell1.rcut = 9.5
    cell1.build(0,0)

    kmdf1 = mdf.MDF(cell1)
    kmdf1.linear_dep_threshold = 1e-7
    kmdf1.auxbasis = df.aug_etb(cell1, 1.8)
    kmdf1.kpts = kpts
    kmdf1.mesh = [6]*3
    kmdf1.eta = 0.1
Exemple #10
0
def test_cell(cell, ngs, nk):
    #############################################
    # Do a supercell Gamma-pt calculation       #
    #############################################
    supcell = pyscf.pbc.tools.super_cell(cell, nk)
    supcell.gs = np.array([
        nk[0] * ngs + 1 * (nk[0] - 1) // 2, nk[1] * ngs + 1 * (nk[1] - 1) // 2,
        nk[2] * ngs + 1 * (nk[2] - 1) // 2
    ])
    print "supcell gs =", supcell.gs
    supcell.build()

    scaled_gamma = ase.dft.kpoints.monkhorst_pack((1, 1, 1))
    gamma = supcell.get_abs_kpts(scaled_gamma)

    #############################################
    # Running HF                                #
    #############################################
    print ""
    print "*********************************"
    print "STARTING HF                      "
    print "*********************************"
    print ""

    mf = pbchf.RHF(supcell, exxdiv=None)
    mf.conv_tol = 1e-15
    #mf.verbose = 7
    escf = mf.scf()
    escf_per_cell = escf / np.prod(nk)
    print "scf energy (per unit cell) = %.17g" % escf_per_cell

    #############################################
    # Running CCSD                              #
    #############################################
    print ""
    print "*********************************"
    print "STARTING CCSD                    "
    print "*********************************"
    print ""
    cc = pyscf.pbc.cc.CCSD(mf)
    cc.conv_tol = 1e-15
    #cc.verbose = 7
    ecc, t1, it2 = cc.kernel()
    ecc_per_cell = ecc / np.prod(nk)
    print "cc energy (per unit cell) = %.17g" % ecc_per_cell
    return escf_per_cell, ecc_per_cell
Exemple #11
0
    def test_get_veff(self):
        mf = pscf.RHF(cell)
        numpy.random.seed(1)
        nao = cell.nao_nr()
        dm = numpy.random.random((nao, nao)) + numpy.random.random(
            (nao, nao)) * 1j
        dm = dm + dm.conj().T
        v11 = mf.get_veff(cell, dm, kpt=cell.get_abs_kpts([.25, .25, .25]))
        v12 = mf.get_veff(cell,
                          dm,
                          kpts_band=cell.get_abs_kpts([.25, .25, .25]))
        v13 = mf.get_veff(cell,
                          dm,
                          kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
                          kpts_band=cell.get_abs_kpts([.25, .25, .25]))
        v14 = mf.get_veff(cell,
                          dm,
                          kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
                          kpts_band=cell.make_kpts([2, 1, 1]))
        self.assertTrue(v11.dtype == numpy.complex128)
        self.assertTrue(v12.dtype == numpy.complex128)

        mf = pscf.UHF(cell)
        v21 = mf.get_veff(cell, dm, kpt=cell.get_abs_kpts([.25, .25, .25]))
        dm = [dm * .5, dm * .5]
        v22 = mf.get_veff(cell,
                          dm,
                          kpts_band=cell.get_abs_kpts([.25, .25, .25]))
        v23 = mf.get_veff(cell,
                          dm,
                          kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
                          kpts_band=cell.get_abs_kpts([.25, .25, .25]))
        v24 = mf.get_veff(cell,
                          dm,
                          kpt=cell.get_abs_kpts([-1. / 3, 1. / 3, .25]),
                          kpts_band=cell.make_kpts([2, 1, 1]))
        self.assertAlmostEqual(abs(v11 - v21).max(), 0, 9)
        self.assertAlmostEqual(abs(v12 - v22).max(), 0, 9)
        self.assertAlmostEqual(abs(v13 - v23).max(), 0, 9)
        self.assertAlmostEqual(abs(v14 - v24).max(), 0, 9)
        self.assertAlmostEqual(lib.finger(v11),
                               -0.30110964334164825 + 0.81409418199767414j, 9)
        self.assertAlmostEqual(lib.finger(v12),
                               -2.1601376488983997 - 9.4070613374115908j, 9)
Exemple #12
0
    def test_ccsd_t_non_hf_frozen(self):
        '''Tests ccsd and ccsd_t for non-Hartree-Fock references with frozen orbitals
        using supercell vs k-point calculation.'''
        n = 14
        cell = make_test_cell.test_cell_n3([n] * 3)
        #import sys
        #cell.stdout = sys.stdout
        #cell.verbose = 7

        nk = [2, 1, 1]
        kpts = cell.make_kpts(nk)
        kpts -= kpts[0]
        kks = pbcdft.KRKS(cell, kpts=kpts)
        ekks = kks.kernel()

        khf = pbcscf.KRHF(cell)
        khf.__dict__.update(kks.__dict__)

        mycc = pbcc.KRCCSD(khf, frozen=1)
        eris = mycc.ao2mo()
        ekcc, t1, t2 = mycc.kernel(eris=eris)

        ekcc_t = mycc.ccsd_t(eris=eris)

        # Run supercell
        from pyscf.pbc.tools.pbc import super_cell
        supcell = super_cell(cell, nk)
        rks = pbcdft.RKS(supcell)
        erks = rks.kernel()

        rhf = pbcscf.RHF(supcell)
        rhf.__dict__.update(rks.__dict__)

        mycc = pbcc.RCCSD(rhf, frozen=2)
        eris = mycc.ao2mo()
        ercc, t1, t2 = mycc.kernel(eris=eris)
        self.assertAlmostEqual(ercc / np.prod(nk), -0.11467718013872311, 6)
        self.assertAlmostEqual(ercc / np.prod(nk), ekcc, 6)

        ercc_t = mycc.ccsd_t(eris=eris)
        self.assertAlmostEqual(ercc_t / np.prod(nk), -0.00066503872045200996,
                               6)
        self.assertAlmostEqual(ercc_t / np.prod(nk), ekcc_t, 6)
Exemple #13
0
def run_cell(cell, n, nk):
    #############################################
    # Do a supercell Gamma-pt calculation       #
    #############################################
    supcell = pyscf.pbc.tools.super_cell(cell, nk)
    supcell.build()
    gamma = [0, 0, 0]

    mf = pbchf.RHF(supcell, exxdiv=None)
    mf.conv_tol = 1e-14
    #mf.verbose = 7
    escf = mf.scf()
    escf_per_cell = escf / np.prod(nk)

    cc = pyscf.pbc.cc.CCSD(mf)
    cc.conv_tol = 1e-8
    ecc, t1, it2 = cc.kernel()
    ecc_per_cell = ecc / np.prod(nk)
    return escf_per_cell, ecc_per_cell
Exemple #14
0
    def test_jk_single_kpt_high_cost(self):
        mf0 = pscf.RHF(cell)
        mf0.exxdiv = None
        mf = df_jk.density_fit(mf0, auxbasis='weigend', mesh=(11,)*3)
        mf.with_df.mesh = cell.mesh
        mf.with_df.eta = 0.3
        mf.with_df.exp_to_discard = 0.3
        dm = mf.get_init_guess()
        vj, vk = mf.get_jk(cell, dm)
        ej1 = numpy.einsum('ij,ji->', vj, dm)
        ek1 = numpy.einsum('ij,ji->', vk, dm)
        j_ref = 48.283789539266174  # rsjk result
        k_ref = 32.30441176447805   # rsjk result
        self.assertAlmostEqual(ej1, j_ref, 4)
        self.assertAlmostEqual(ek1, k_ref, 2)
        self.assertAlmostEqual(ej1, 48.283745538383684, 8)
        self.assertAlmostEqual(ek1, 32.30260871417842 , 8)

        numpy.random.seed(12)
        nao = cell.nao_nr()
        dm = numpy.random.random((nao,nao))
        dm = dm + dm.T
        vj1, vk1 = mf.get_jk(cell, dm, hermi=0)
        ej1 = numpy.einsum('ij,ji->', vj1, dm)
        ek1 = numpy.einsum('ij,ji->', vk1, dm)
        self.assertAlmostEqual(ej1, 242.04678235140264, 8)
        self.assertAlmostEqual(ek1, 280.15934926575903, 8)

        numpy.random.seed(1)
        kpt = numpy.random.random(3)
        mydf = df.DF(cell, [kpt]).set(auxbasis='weigend')
        mydf.linear_dep_threshold = 1e-7
        mydf.mesh = cell.mesh
        mydf.eta = 0.3
        mydf.exp_to_discard = mydf.eta
        vj, vk = mydf.get_jk(dm, 1, kpt, exxdiv=None)
        ej1 = numpy.einsum('ij,ji->', vj, dm)
        ek1 = numpy.einsum('ij,ji->', vk, dm)
        self.assertAlmostEqual(ej1, 241.15121903857556+0j, 8)
        self.assertAlmostEqual(ek1, 279.64649194057051+0j, 8)
        vj, vk = mydf.get_jk(dm, 1, kpt, with_j=False, exxdiv='ewald')
        ek1 = numpy.einsum('ij,ji->', vk, dm)
        self.assertAlmostEqual(ek1, 691.64624456329909+0j, 6)
Exemple #15
0
    def test_pp_int(self):
        from pyscf import gto, scf
        from pyscf.pbc import gto as pbcgto
        from pyscf.pbc import scf as pbcscf
        from pyscf.pbc import df
        cell = pbcgto.Cell()
        cell.atom = 'He 1. .5 .5; C .1 1.3 2.1'
        cell.basis = {
            'He': [(0, (2.5, 1)), (0, (1., 1))],
            'C': 'gth-szv',
        }
        cell.pseudo = {
            'C':
            'gth-pade',
            'He':
            pbcgto.pseudo.parse('''He
        2
         0.40000000    3    -1.98934751    -0.75604821    0.95604821
        2
         0.29482550    3     1.23870466    .855         .3
                                           .71         -1.1
                                                        .9
         0.32235865    2     2.25670239    -0.39677748
                                            0.93894690
                                                     ''')
        }
        cell.a = numpy.eye(3)
        cell.dimension = 0
        cell.build()
        mol = cell.to_mol()

        hcore = scf.RHF(mol).get_hcore()
        mydf = df.AFTDF(cell)
        ref = mydf.get_pp() + mol.intor('int1e_kin')
        self.assertAlmostEqual(abs(hcore - ref).max(), 0, 2)

        mf = pbcscf.RHF(cell)
        mf.with_df = mydf
        mf.run()
        e_ref = mf.e_tot

        e_tot = scf.RHF(mol).run().e_tot
        self.assertAlmostEqual(abs(e_ref - e_tot).max(), 0, 6)
Exemple #16
0
    def test_jk_single_kpt_high_cost(self):
        mf0 = pscf.RHF(cell)
        mf0.exxdiv = None
        mf = rsdf_jk.density_fit(mf0, auxbasis='weigend', mesh=(11,)*3)
        mf.with_df.mesh = cell.mesh
        mf.with_df.omega = 0.3
        mf.with_df.exp_to_discard = 0.3
        dm = mf.get_init_guess()
        vj, vk = mf.get_jk(cell, dm)
        ej1 = numpy.einsum('ij,ji->', vj, dm)
        ek1 = numpy.einsum('ij,ji->', vk, dm)
        j_ref = 48.283789539266174  # rsjk result
        k_ref = 32.30441176447805   # rsjk result
        self.assertAlmostEqual(ej1, j_ref, 4)
        self.assertAlmostEqual(ek1, k_ref, 2)
        self.assertAlmostEqual(ej1, 48.2837455394308037, 7)
        self.assertAlmostEqual(ek1, 32.3026087105977950, 7)

        numpy.random.seed(12)
        nao = cell.nao_nr()
        dm = numpy.random.random((nao,nao))
        dm = dm + dm.T
        vj1, vk1 = mf.get_jk(cell, dm, hermi=0)
        ej1 = numpy.einsum('ij,ji->', vj1, dm)
        ek1 = numpy.einsum('ij,ji->', vk1, dm)
        self.assertAlmostEqual(ej1, 242.0467816643269714, 7)
        self.assertAlmostEqual(ek1, 280.1593488661793572, 7)

        numpy.random.seed(1)
        kpt = numpy.random.random(3)
        mydf = rsdf.RSDF(cell, [kpt]).set(auxbasis='weigend')
        mydf.linear_dep_threshold = 1e-7
        mydf.omega = 0.3
        mydf.exp_to_discard = 0.3
        vj, vk = mydf.get_jk(dm, 1, kpt, exxdiv=None)
        ej1 = numpy.einsum('ij,ji->', vj, dm)
        ek1 = numpy.einsum('ij,ji->', vk, dm)
        self.assertAlmostEqual(ej1, 241.1512182675005249+0j, 7)
        self.assertAlmostEqual(ek1, 279.6464915858919085+0j, 7)
        vj, vk = mydf.get_jk(dm, 1, kpt, with_j=False, exxdiv='ewald')
        ek1 = numpy.einsum('ij,ji->', vk, dm)
        self.assertAlmostEqual(ek1, 691.6462442086188958+0j, 6)
Exemple #17
0
 def _get_pbc(self):
     import pyscf.pbc.gto as pbc_gto
     import pyscf.pbc.scf as pbc_scf
     cell = pbc_gto.Cell()
     cell.atom = '''
     C 0.000000000000   0.000000000000   0.000000000000
     C 1.685068664391   1.685068664391   1.685068664391
     '''
     cell.basis = 'gth-szv'
     cell.pseudo = 'gth-pade'
     cell.a = '''
     0.000000000, 3.370137329, 3.370137329
     3.370137329, 0.000000000, 3.370137329
     3.370137329, 3.370137329, 0.000000000'''
     cell.unit = 'B'
     cell.verbose = 0
     cell.build()
     pbc_mf = pbc_scf.RHF(cell, exxdiv=None)
     pbc_mf.kernel()
     return pbc_mf
Exemple #18
0
 def _get_pbc2(self):
     import pyscf.pbc.gto as pbc_gto
     import pyscf.pbc.scf as pbc_scf
     cell = pbc_gto.Cell()
     cell.atom = '''
     C 0.000000000000   0.000000000000   0.000000000000
     C 1.685068664391   1.685068664391   1.685068664391
     '''
     cell.basis = 'gth-szv'
     cell.pseudo = 'gth-pade'
     cell.a = '''
     0.000000000, 3.370137329, 3.370137329
     3.370137329, 0.000000000, 3.370137329
     3.370137329, 3.370137329, 0.000000000'''
     cell.unit = 'B'
     cell.verbose = 0
     cell.build()
     kpt = cell.make_kpts((1, 1, 1), scaled_center=(0, 0, 1./3.))
     pbc_mf2 = pbc_scf.RHF(cell, kpt=kpt, exxdiv=None)
     pbc_mf2.kernel()
     return pbc_mf2
Exemple #19
0
def k2gamma(kmf, kmesh=None):
    r'''
    convert the k-sampled mean-field object to the corresponding supercell
    gamma-point mean-field object.

    math:
         C_{\nu ' n'} = C_{\vecR\mu, \veck m} = \frac{1}{\sqrt{N_{\UC}}}
         \e^{\ii \veck\cdot\vecR} C^{\veck}_{\mu  m}
    '''

    scell, E_g, C_gamma = mo_k2gamma(kmf.cell, kmf.mo_energy, kmf.mo_coeff,
                                     kmf.kpts, kmesh)[:3]

    E_sort_idx = np.argsort(np.hstack(kmf.mo_energy))
    mo_occ = np.hstack(kmf.mo_occ)[E_sort_idx]

    mf = scf.RHF(scell)
    mf.mo_coeff = C_gamma
    mf.mo_energy = E_g
    mf.mo_occ = mo_occ
    return mf
Exemple #20
0
def run_cell(cell, n, nk):
    #############################################
    # Do a supercell Gamma-pt calculation       #
    #############################################
    supcell = pyscf.pbc.tools.super_cell(cell, nk)
    supcell.build()

    gamma = [0, 0, 0]

    #############################################
    # Running HF                                #
    #############################################
    #    print ""
    #    print "*********************************"
    #    print "STARTING HF                      "
    #    print "*********************************"
    #    print ""

    mf = pbchf.RHF(supcell, exxdiv=None)
    mf.conv_tol = 1e-14
    #mf.verbose = 7
    escf = mf.scf()
    escf_per_cell = escf / np.prod(nk)
    #    print "scf energy (per unit cell) = %.17g" % escf_per_cell

    #############################################
    # Running CCSD                              #
    #############################################
    #    print ""
    #    print "*********************************"
    #    print "STARTING CCSD                    "
    #    print "*********************************"
    #    print ""
    cc = pyscf.pbc.cc.CCSD(mf)
    cc.conv_tol = 1e-8
    #cc.verbose = 7
    ecc, t1, it2 = cc.kernel()
    ecc_per_cell = ecc / np.prod(nk)
    #    print "cc energy (per unit cell) = %.17g" % ecc_per_cell
    return escf_per_cell, ecc_per_cell
Exemple #21
0
    def test_single_kpt(self):
        cell = pbcgto.Cell()
        cell.atom = '''
        H 0 0 0
        H 1 0 0
        H 0 1 0
        H 0 1 1
        '''
        cell.a = np.eye(3) * 2
        cell.basis = [[0, [1.2, 1]], [1, [1.0, 1]]]
        cell.verbose = 0
        cell.build()

        kpts = cell.get_abs_kpts([.5, .5, .5]).reshape(1, 3)
        mf = pbcscf.KRHF(cell, kpts=kpts).run(conv_tol=1e-9)
        kcc = pyscf.pbc.cc.kccsd_rhf.RCCSD(mf)
        e0 = kcc.kernel()[0]

        mf = pbcscf.RHF(cell, kpt=kpts[0]).run()
        mycc = pyscf.pbc.cc.RCCSD(mf)
        e1 = mycc.kernel()[0]
        self.assertAlmostEqual(e0, e1, 7)
Exemple #22
0
def k2gamma(kmf, kmesh=None):
    r'''
    convert the k-sampled mean-field object to the corresponding supercell
    gamma-point mean-field object.

    math:
         C_{\nu ' n'} = C_{\vecR\mu, \veck m} = \frac{1}{\sqrt{N_{\UC}}}
         \e^{\ii \veck\cdot\vecR} C^{\veck}_{\mu  m}
    '''
    from pyscf.pbc import scf

    def transform(mo_energy, mo_coeff, mo_occ):
        scell, E_g, C_gamma = mo_k2gamma(kmf.cell, mo_energy, mo_coeff,
                                         kmf.kpts, kmesh)[:3]
        E_sort_idx = np.argsort(np.hstack(mo_energy))
        mo_occ = np.hstack(mo_occ)[E_sort_idx]
        return scell, E_g, C_gamma, mo_occ

    if isinstance(kmf, scf.khf.KRHF):
        scell, E_g, C_gamma, mo_occ = transform(kmf.mo_energy, kmf.mo_coeff,
                                                kmf.mo_occ)
        mf = scf.RHF(scell)
    elif isinstance(kmf, scf.kuhf.KUHF):
        scell, Ea, Ca, occ_a = transform(kmf.mo_energy[0], kmf.mo_coeff[0],
                                         kmf.mo_occ[0])
        scell, Eb, Cb, occ_b = transform(kmf.mo_energy[1], kmf.mo_coeff[1],
                                         kmf.mo_occ[1])
        mf = scf.UHF(scell)
        E_g = [Ea, Eb]
        C_gamma = [Ca, Cb]
        mo_occ = [occ_a, occ_b]
    else:
        raise NotImplementedError('SCF object %s not supported' % kmf)

    mf.mo_coeff = C_gamma
    mf.mo_energy = E_g
    mf.mo_occ = mo_occ
    return mf
Exemple #23
0
    def test_ccsd_t_non_hf(self):
        '''Tests ccsd and ccsd_t for non-Hartree-Fock references.'''
        n = 14
        cell = make_test_cell.test_cell_n3([n] * 3)

        nk = [2, 1, 1]
        kpts = cell.make_kpts(nk)
        kpts -= kpts[0]
        kks = pbcdft.KRKS(cell, kpts=kpts)
        ekks = kks.kernel()

        khf = pbcscf.KRHF(cell)
        khf.__dict__.update(kks.__dict__)

        mycc = pbcc.KRCCSD(khf)
        eris = mycc.ao2mo()
        ekcc, t1, t2 = mycc.kernel(eris=eris)

        ekcc_t = mycc.ccsd_t(eris=eris)

        # Run supercell
        from pyscf.pbc.tools.pbc import super_cell
        supcell = super_cell(cell, nk)
        rks = pbcdft.RKS(supcell)
        erks = rks.kernel()

        rhf = pbcscf.RHF(supcell)
        rhf.__dict__.update(rks.__dict__)

        mycc = pbcc.RCCSD(rhf)
        eris = mycc.ao2mo()
        ercc, t1, t2 = mycc.kernel(eris=eris)
        self.assertAlmostEqual(ercc / np.prod(nk), -0.15632445245405927, 6)
        self.assertAlmostEqual(ercc / np.prod(nk), ekcc, 6)

        ercc_t = mycc.ccsd_t(eris=eris)
        self.assertAlmostEqual(ercc_t / np.prod(nk), -0.00114619248449, 6)
        self.assertAlmostEqual(ercc_t / np.prod(nk), ekcc_t, 6)
Exemple #24
0
def setUpModule():
    global cell, cell1, cell2, kpts, kpt0, kpts1, mf0
    cell = pgto.Cell()
    cell.atom = 'He 1. .5 .5; C .1 1.3 2.1'
    cell.basis = {'He': [(0, (2.5, 1)), (0, (1., 1))],
                  'C' :'gth-szv',}
    cell.pseudo = {'C':'gth-pade'}
    cell.a = np.eye(3) * 2.5
    cell.mesh = [21] * 3
    cell.build()
    np.random.seed(1)
    kpts = np.random.random((4,3))
    kpts[3] = kpts[0]-kpts[1]+kpts[2]
    kpt0 = np.zeros(3)

    cell1 = pgto.Cell()
    cell1.atom = 'He 1. .5 .5; He .1 1.3 2.1'
    cell1.basis = {'He': [(0, (2.5, 1)), (0, (1., 1))]}
    cell1.a = np.eye(3) * 2.5
    cell1.mesh = [21] * 3
    cell1.build()

    cell2 = pgto.Cell()
    cell2.atom = '''
    He   1.3    .2       .3
    He    .1    .1      1.1 '''
    cell2.basis = {'He': [[0, [0.8, 1]],
                          [1, [0.6, 1]]]}
    cell2.mesh = [17]*3
    cell2.a = numpy.array(([2.0,  .9, 0. ],
                           [0.1, 1.9, 0.4],
                           [0.8, 0  , 2.1]))
    cell2.build()
    kpts1 = np.random.random((4,3))
    kpts1[3] = kpts1[0]-kpts1[1]+kpts1[2] + cell2.reciprocal_vectors().T.dot(np.ones(3))

    mf0 = pbcscf.RHF(cell)
    mf0.exxdiv = None
Exemple #25
0
    def test_kpt_vs_supercell_high_cost(self):
        # For large n, agreement is always achieved
        # n = 17
        # For small n, agreement only achieved if "wrapping" k-k'+G in get_coulG
        n = 9
        nk = (3, 1, 1)
        cell = make_primitive_cell([n] * 3)

        abs_kpts = cell.make_kpts(nk, wrap_around=True)
        kmf = khf.KRHF(cell, abs_kpts, exxdiv='vcut_sph')
        ekpt = kmf.scf()
        self.assertAlmostEqual(ekpt, -11.221426249047617, 8)

        #        nk = (5, 1, 1)
        #        abs_kpts = cell.make_kpts(nk, wrap_around=True)
        #        kmf = khf.KRHF(cell, abs_kpts, exxdiv='vcut_sph')
        #        ekpt = kmf.scf()
        #        self.assertAlmostEqual(ekpt, -12.337299166550796, 8)

        supcell = pyscf.pbc.tools.super_cell(cell, nk)
        mf = pscf.RHF(supcell, exxdiv='vcut_sph')
        esup = mf.scf() / np.prod(nk)
        self.assertAlmostEqual(ekpt, esup, 8)
Exemple #26
0
L = 5.
n = 11
cell = pgto.Cell()
cell.a = numpy.diag([L,L,L])
cell.mesh = numpy.array([n,n,n])

cell.atom = '''C    3.    2.       3.
               C    1.    1.       1.'''
cell.basis = 'ccpvdz'
cell.verbose = 0
cell.max_memory = 0
cell.rcut = 28.3
cell.build()

mf0 = pscf.RHF(cell)
mf0.exxdiv = None


def finger(a):
    w = numpy.cos(numpy.arange(a.size))
    return numpy.dot(a.ravel(), w)

class KnowValues(unittest.TestCase):
    def test_jk_single_kpt(self):
        mf = mdf_jk.density_fit(mf0, auxbasis='weigend', mesh=(11,)*3)
        mf.with_df.mesh = [11]*3
        mf.with_df.eta = 0.3
        mf.with_df.linear_dep_threshold = 1e-7
        dm = mf.get_init_guess()
        vj, vk = mf.get_jk(cell, dm)
Exemple #27
0
cell.unit = 'A'
cell.a = [[4, 0, 0], [0, 1, 0], [0, 0, 1]]
cell.atom = '''
H       0.0000000   0.0000000   0.0000000
H       1.0000000   0.0000000   0.0000000
H       2.0000000   0.0000000   0.0000000
H       3.0000000   0.0000000   0.0000000
'''
cell.basis = 'sto-6g'
cell.dimension = 1
cell.verbose = 4
cell.build()

gdf = df.GDF(cell)

mf = scf.RHF(cell)
mf.with_df = gdf
mf.with_df.auxbasis = 'cc-pvdz-jkfit'
mf.max_cycle = 150
mf.chkfile = name + '.chk'
#mf.with_df._cderi_to_save = name+'_eri.h5'
#mf.with_df._cderi = name+'_eri.h5'
#mf = mole_scf.addons.remove_linear_dep_(mf)
#mf.__dict__.update(scf.chkfile.load(name+'.chk', 'scf'))
#dm = mf.make_rdm1()
ehf = mf.kernel()

ncore = 0
nao, nmo = mf.mo_coeff.shape
nocc = cell.nelectron // 2 - ncore
nvir = nmo - nocc - ncore
Exemple #28
0
    n = 5
    cell = pgto.Cell()
    cell.a = numpy.diag([L, L, L])
    cell.gs = numpy.array([n, n, n])

    cell.atom = '''C    3.    2.       3.
                   C    1.    1.       1.'''
    #cell.basis = {'He': [[0, (1.0, 1.0)]]}
    #cell.basis = '631g'
    #cell.basis = {'He': [[0, (2.4, 1)], [1, (1.1, 1)]]}
    cell.basis = 'ccpvdz'
    cell.verbose = 0
    cell.build(0, 0)
    cell.verbose = 5

    mf = pscf.RHF(cell)
    dm = mf.get_init_guess()
    auxbasis = 'weigend'
    #from pyscf import df
    #auxbasis = df.addons.aug_etb_for_dfbasis(cell, beta=1.5, start_at=0)
    #from pyscf.pbc.df import mdf
    #mf.with_df = mdf.MDF(cell)
    #mf.auxbasis = auxbasis
    mf = density_fit(mf, auxbasis)
    mf.with_df.gs = (5, ) * 3
    vj = mf.with_df.get_jk(dm, exxdiv=mf.exxdiv, with_k=False)[0]
    print(numpy.einsum('ij,ji->', vj, dm), 'ref=46.698942480902062')
    vj, vk = mf.with_df.get_jk(dm, exxdiv=mf.exxdiv)
    print(numpy.einsum('ij,ji->', vj, dm), 'ref=46.698942480902062')
    print(numpy.einsum('ij,ji->', vk, dm), 'ref=37.348163681114187')
    print(numpy.einsum('ij,ji->', mf.get_hcore(cell), dm),
Exemple #29
0
3.370137329, 3.370137329, 0.000000000'''
cell.unit = 'B'
cell.verbose = 5
cell.precision = 1e-12
cell.build()

cell.rcut *= 2.0
cell.build()

omegas = [-10.99479191]

#
#Run old code
#
supcell = super_cell(cell, nmp)
mf = scf.RHF(supcell, exxdiv=None)
mf.diis = None
mf.conv_tol_grad = 1e-8
mf.conv_tol = 1e-8
ehf = mf.kernel()
mf.analyze()
mycc = cc.RCCSD(mf)
mycc.frozen = [0, 1, 3, 4, 5, 6, 9, 10, 11, 12, 14, 15]
mycc.ip_partition = None
mycc.ea_partition = None
mycc.conv_tol_normt = 1e-10
mycc.conv_tol = 1e-10
mycc.kernel()
#p=[8,9,10,11,12,13,14,15]
#q=[8,9,10,11,12,13,14,15]
p = [2, 3]
Exemple #30
0
            f.write(''.join(['%5.3s' % atomN[0]
                             for atomN in vaspAtomicInfo]) + '\n')
            f.write(''.join(['%5d' % atomN[1]
                             for atomN in vaspAtomicInfo]) + '\n')
            f.write('Cartesian \n')
            for ia in range(cell.natm):
                f.write(' %14.8f %14.8f %14.8f\n' % tuple(swappedCoords[ia]))
            f.write('\n')
            f.write('%6.5s %6.5s %6.5s \n' % (self.nx, self.ny, self.nz))
            fmt = ' %14.8e '
            for iz in range(self.nz):
                for iy in range(self.ny):
                    f.write('\n')
                    for ix in range(self.nx):
                        f.write(fmt % field[ix, iy, iz])

    def read(self, chgcar_file):
        raise NotImplementedError


if __name__ == '__main__':
    from pyscf.pbc import scf
    from pyscf.tools import chgcar
    cell = gto.M(atom='H 0 0 0; H 0 0 1', a=numpy.eye(3) * 3)
    mf = scf.RHF(cell).run()
    chgcar.density(cell, 'h2.CHGCAR', mf.make_rdm1())  #makes total density
    chgcar.orbital(cell, 'h2_mo1.CHGCAR', mf.mo_coeff[:,
                                                      0])  # makes mo#1 (sigma)
    chgcar.orbital(cell, 'h2_mo2.CHGCAR',
                   mf.mo_coeff[:, 1])  # makes mo#2 (sigma*)