Пример #1
0
    def test_rsh_df(self):
        mf = pbcdft.UKS(cell)
        mf.xc = 'camb3lyp'
        mf.kernel()
        self.assertAlmostEqual(mf.e_tot, -2.3032261128220544, 7)

        mf = pbcdft.UKS(cell).density_fit()
        mf.xc = 'camb3lyp'
        mf.omega = .15
        mf.kernel()
        self.assertAlmostEqual(mf.e_tot, -2.3987656490734555, 7)
Пример #2
0
    def test_pp_UKS(self):
        cell = pbcgto.Cell()

        cell.unit = 'A'
        cell.atom = '''
            Si    2.715348700    2.715348700    0.000000000;
            Si    2.715348700    0.000000000    2.715348700;
        '''
        cell.basis = 'gth-szv'
        cell.pseudo = 'gth-pade'

        Lx = Ly = Lz = 5.430697500
        cell.a = np.diag([Lx, Ly, Lz])
        cell.mesh = np.array([17] * 3)

        cell.verbose = 5
        cell.output = '/dev/null'
        cell.build()

        mf = pbcdft.UKS(cell)
        mf.xc = 'blyp'
        self.assertAlmostEqual(mf.scf(), -7.6058004283213396, 8)

        mf.xc = 'lda,vwn'
        self.assertAlmostEqual(mf.scf(), -7.6162130840535092, 8)
Пример #3
0
 def test_nr_uks_gga(self):
     mf = dft.UKS(cell)
     mf.xc = 'b88,'
     mf = scf.newton(mf)
     mf.conv_tol_grad = 1e-4
     mf.kernel()
     self.assertAlmostEqual(mf.e_tot, -9.9355341416893559, 8)
Пример #4
0
 def test_nr_uks_lda(self):
     mf = dft.UKS(cell)
     mf.xc = 'lda,'
     mf = scf.newton(mf)
     mf.conv_tol_grad = 1e-4
     mf.kernel()
     self.assertAlmostEqual(mf.e_tot, -9.7670882971475663, 8)
Пример #5
0
    def test_gen_uhf_response(self):
        numpy.random.seed(9)
        dm1 = numpy.random.random(dm_he.shape)
        dm1 = dm1 + dm1.transpose(0, 2, 1)
        mydf = df.FFTDF(cell_he)
        ni = dft.numint.NumInt()

        mf = dft.UKS(cell_he)
        mf.with_df = multigrid.MultiGridFFTDF(cell_he)

        mf.xc = 'lda,'
        ref = dft.numint.nr_uks_fxc(ni, cell_he, mydf.grids, mf.xc, dm_he, dm1)
        vj = mydf.get_jk(dm1, with_k=False)[0]
        ref += vj[0] + vj[1]
        v = multigrid._gen_uhf_response(mf, dm_he, with_j=True)(dm1)
        self.assertEqual(ref.dtype, v.dtype)
        self.assertEqual(ref.shape, v.shape)
        self.assertAlmostEqual(abs(v - ref).max(), 0, 9)

        mf.xc = 'b88,'
        ref = dft.numint.nr_uks_fxc(ni, cell_he, mydf.grids, mf.xc, dm_he, dm1)
        ref += vj[0] + vj[1]
        v = multigrid._gen_uhf_response(mf, dm_he, with_j=True)(dm1)
        self.assertEqual(ref.dtype, v.dtype)
        self.assertEqual(ref.shape, v.shape)
        self.assertAlmostEqual(abs(v - ref).max(), 0, 7)
Пример #6
0
 def test_multigrid_uks(self):
     mf = dft.UKS(cell_he)
     mf.xc = 'lda,'
     ref = mf.get_veff(cell_he, numpy.array((dm_he[0], dm_he[0])))
     out = multigrid.multigrid(mf).get_veff(cell_he, (dm_he[0], dm_he[0]))
     self.assertAlmostEqual(float(abs(ref - out).max()), 0, 9)
     self.assertAlmostEqual(abs(ref.exc - out.exc).max(), 0, 9)
     self.assertAlmostEqual(abs(ref.ecoul - out.ecoul).max(), 0, 9)
Пример #7
0
def get_solids_energy(xc="lda", with_df=False):
    solnames = ["Li"]
    for solname in solnames:
        t0 = time.time()
        sol = get_solid(solname)
        mf = dft.UKS(sol)
        if with_df:
            auxbasis = "def2-svp-jkfit"
            mf = mf.density_fit(auxbasis=auxbasis)
        mf.xc = xc
        mf.grids.level = 4
        energy = mf.kernel()
        t1 = time.time()
        print("Solid %s: %.8e (%.3e)" % (solname, energy, t1 - t0))
Пример #8
0
 def test_getattr(self):
     from pyscf.pbc import scf, dft, cc, tdscf
     cell = pgto.M(atom='He', a=np.eye(3) * 4, basis={'He': [[0, (1, 1)]]})
     self.assertEqual(cell.HF().__class__, scf.HF(cell).__class__)
     self.assertEqual(cell.KS().__class__, dft.KS(cell).__class__)
     self.assertEqual(cell.UKS().__class__, dft.UKS(cell).__class__)
     self.assertEqual(cell.KROHF().__class__, scf.KROHF(cell).__class__)
     self.assertEqual(cell.KKS().__class__, dft.KKS(cell).__class__)
     self.assertEqual(cell.CCSD().__class__, cc.ccsd.RCCSD)
     self.assertEqual(cell.TDA().__class__, tdscf.rhf.TDA)
     self.assertEqual(cell.TDBP86().__class__, tdscf.rks.TDDFTNoHybrid)
     self.assertEqual(cell.TDB3LYP().__class__, tdscf.rks.TDDFT)
     self.assertEqual(cell.KCCSD().__class__, cc.kccsd_rhf.KRCCSD)
     self.assertEqual(cell.KTDA().__class__, tdscf.krhf.TDA)
     self.assertEqual(cell.KTDBP86().__class__, tdscf.krks.TDDFTNoHybrid)
     self.assertRaises(AttributeError, lambda: cell.xyz)
     self.assertRaises(AttributeError, lambda: cell.TDxyz)
Пример #9
0
def UKS(cell, *args):
    from pyscf.pbc import dft
    return dft.UKS(cell, *args)
Пример #10
0
 def test_rsh_df(self):
     mf = pbcdft.UKS(cell).density_fit()
     mf.xc = 'camb3lyp'
     mf.omega = .15
     mf.kernel()
     self.assertAlmostEqual(mf.e_tot, -2.399571378419408, 7)
Пример #11
0
 def test_rsh_df(self):
     mf = pbcdft.UKS(cell).density_fit()
     mf.xc = 'camb3lyp'
     mf.omega = .15
     mf.kernel()
     self.assertAlmostEqual(mf.e_tot, -2.4766238116030683, 7)
Пример #12
0
 def test_rsh_fft(self):
     mf = pbcdft.UKS(cell)
     mf.xc = 'camb3lyp'
     mf.kernel()
     self.assertAlmostEqual(mf.e_tot, -2.4745140703871877, 7)
Пример #13
0
    def test_convert_to_scf(self):
        from pyscf.pbc import dft
        from pyscf.pbc import df
        from pyscf.soscf import newton_ah
        cell1 = cell.copy()
        cell1.verbose = 0
        pscf.addons.convert_to_rhf(dft.RKS(cell1))
        pscf.addons.convert_to_uhf(dft.RKS(cell1))
        #pscf.addons.convert_to_ghf(dft.RKS(cell1))
        pscf.addons.convert_to_rhf(dft.UKS(cell1))
        pscf.addons.convert_to_uhf(dft.UKS(cell1))
        #pscf.addons.convert_to_ghf(dft.UKS(cell1))
        #pscf.addons.convert_to_rhf(dft.GKS(cell1))
        #pscf.addons.convert_to_uhf(dft.GKS(cell1))
        #pscf.addons.convert_to_ghf(dft.GKS(cell1))

        pscf.addons.convert_to_rhf(pscf.RHF(cell1).density_fit())
        pscf.addons.convert_to_uhf(pscf.RHF(cell1).density_fit())
        pscf.addons.convert_to_ghf(pscf.RHF(cell1).density_fit())
        pscf.addons.convert_to_rhf(pscf.ROHF(cell1).density_fit())
        pscf.addons.convert_to_uhf(pscf.ROHF(cell1).density_fit())
        pscf.addons.convert_to_ghf(pscf.ROHF(cell1).density_fit())
        pscf.addons.convert_to_rhf(pscf.UHF(cell1).density_fit())
        pscf.addons.convert_to_uhf(pscf.UHF(cell1).density_fit())
        pscf.addons.convert_to_ghf(pscf.UHF(cell1).density_fit())
        #pscf.addons.convert_to_rhf(pscf.GHF(cell1).density_fit())
        #pscf.addons.convert_to_uhf(pscf.GHF(cell1).density_fit())
        pscf.addons.convert_to_ghf(pscf.GHF(cell1).density_fit())

        pscf.addons.convert_to_rhf(pscf.RHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_uhf(pscf.RHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_ghf(pscf.RHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_rhf(pscf.ROHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_uhf(pscf.ROHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_ghf(pscf.ROHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_rhf(pscf.UHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_uhf(pscf.UHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_ghf(pscf.UHF(cell1).x2c().density_fit())
        #pscf.addons.convert_to_rhf(pscf.GHF(cell1).x2c().density_fit())
        #pscf.addons.convert_to_uhf(pscf.GHF(cell1).x2c().density_fit())
        pscf.addons.convert_to_ghf(pscf.GHF(cell1).x2c().density_fit())

        self.assertTrue(
            isinstance(
                pscf.addons.convert_to_rhf(
                    pscf.RHF(cell1).newton().density_fit().x2c()),
                newton_ah._CIAH_SOSCF))
        self.assertFalse(
            isinstance(
                pscf.addons.convert_to_uhf(
                    pscf.RHF(cell1).newton().density_fit().x2c()),
                newton_ah._CIAH_SOSCF))
        self.assertFalse(
            isinstance(
                pscf.addons.convert_to_ghf(
                    pscf.RHF(cell1).newton().density_fit().x2c()),
                newton_ah._CIAH_SOSCF))
        self.assertFalse(
            isinstance(
                pscf.addons.convert_to_rhf(
                    pscf.UHF(cell1).newton().density_fit().x2c()),
                newton_ah._CIAH_SOSCF))
        self.assertTrue(
            isinstance(
                pscf.addons.convert_to_uhf(
                    pscf.UHF(cell1).newton().density_fit().x2c()),
                newton_ah._CIAH_SOSCF))
        self.assertFalse(
            isinstance(
                pscf.addons.convert_to_ghf(
                    pscf.UHF(cell1).newton().density_fit().x2c()),
                newton_ah._CIAH_SOSCF))
        #self.assertFalse(isinstance(pscf.addons.convert_to_rhf(pscf.GHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
        #self.assertFalse(isinstance(pscf.addons.convert_to_uhf(pscf.GHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
        self.assertTrue(
            isinstance(
                pscf.addons.convert_to_ghf(
                    pscf.GHF(cell1).newton().density_fit().x2c()),
                newton_ah._CIAH_SOSCF))

        mf1 = pscf.rhf.RHF(cell1)
        cell2 = cell1.copy()
        cell2.spin = 2
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.UHF(cell1)), pscf.hf.RHF))
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.UHF(cell2)), pscf.hf.RHF))
        self.assertFalse(
            isinstance(mf1.convert_from_(pscf.UHF(cell2)), pscf.rohf.ROHF))
        self.assertFalse(
            isinstance(mf1.convert_from_(pscf.UHF(cell1).newton()),
                       newton_ah._CIAH_SOSCF))
        self.assertTrue(
            isinstance(
                mf1.convert_from_(pscf.UHF(cell2).density_fit()).with_df,
                df.df.GDF))
        self.assertTrue(
            isinstance(
                mf1.convert_from_(pscf.UHF(cell2).mix_density_fit()).with_df,
                df.mdf.MDF))
        self.assertFalse(
            isinstance(mf1.convert_from_(pscf.ROHF(cell2)), pscf.rohf.ROHF))
        self.assertRaises(AssertionError, mf1.convert_from_, kmf_u)

        mf1 = pscf.rohf.ROHF(cell1)
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.UHF(cell1)), pscf.rohf.ROHF))
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.UHF(cell2)), pscf.rohf.ROHF))
        self.assertFalse(
            isinstance(mf1.convert_from_(pscf.UHF(cell1).newton()),
                       newton_ah._CIAH_SOSCF))
        self.assertTrue(
            isinstance(
                mf1.convert_from_(pscf.UHF(cell2).density_fit()).with_df,
                df.df.GDF))
        self.assertTrue(
            isinstance(
                mf1.convert_from_(pscf.UHF(cell2).mix_density_fit()).with_df,
                df.mdf.MDF))
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.RHF(cell1)), pscf.rohf.ROHF))
        self.assertRaises(AssertionError, mf1.convert_from_, kmf_u)

        mf1 = pscf.uhf.UHF(cell1)
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.RHF(cell1)), pscf.uhf.UHF))
        self.assertFalse(
            isinstance(mf1.convert_from_(pscf.RHF(cell1).newton()),
                       newton_ah._CIAH_SOSCF))
        self.assertTrue(
            isinstance(
                mf1.convert_from_(pscf.RHF(cell1).density_fit()).with_df,
                df.df.GDF))
        self.assertTrue(
            isinstance(
                mf1.convert_from_(pscf.RHF(cell1).mix_density_fit()).with_df,
                df.mdf.MDF))
        self.assertRaises(AssertionError, mf1.convert_from_, kmf_u)

        mf1 = pscf.ghf.GHF(cell1)
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.RHF(cell1)), pscf.ghf.GHF))
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.UHF(cell1)), pscf.ghf.GHF))
        self.assertTrue(
            isinstance(mf1.convert_from_(pscf.ROHF(cell1)), pscf.ghf.GHF))
        self.assertRaises(AssertionError, mf1.convert_from_, kmf_u)