def test_init(self): from pyscf.pbc import dft cell_u = cell.copy() cell_u.spin = 2 self.assertTrue(isinstance(pscf.RKS (cell ), dft.rks.RKS )) self.assertTrue(isinstance(pscf.RKS (cell_u), dft.roks.ROKS )) self.assertTrue(isinstance(pscf.UKS (cell ), dft.uks.UKS )) self.assertTrue(isinstance(pscf.ROKS (cell ), dft.roks.ROKS )) self.assertTrue(isinstance(pscf.KS (cell ), dft.rks.RKS )) self.assertTrue(isinstance(pscf.KS (cell_u), dft.uks.UKS )) self.assertTrue(isinstance(pscf.KRKS (cell ), dft.krks.KRKS )) self.assertTrue(isinstance(pscf.KRKS (cell_u), dft.krks.KRKS )) self.assertTrue(isinstance(pscf.KUKS (cell ), dft.kuks.KUKS )) self.assertTrue(isinstance(pscf.KROKS(cell ), dft.kroks.KROKS)) self.assertTrue(isinstance(pscf.KKS (cell ), dft.krks.KRKS )) self.assertTrue(isinstance(pscf.KKS (cell_u), dft.kuks.KUKS )) self.assertTrue(isinstance(pscf.RHF (cell ), pscf.hf.RHF )) self.assertTrue(isinstance(pscf.RHF (cell_u), pscf.rohf.ROHF )) self.assertTrue(isinstance(pscf.KRHF (cell ), pscf.khf.KRHF )) self.assertTrue(isinstance(pscf.KRHF (cell_u), pscf.khf.KRHF )) self.assertTrue(isinstance(pscf.UHF (cell ), pscf.uhf.UHF )) self.assertTrue(isinstance(pscf.KUHF (cell_u), pscf.kuhf.KUHF )) self.assertTrue(isinstance(pscf.GHF (cell ), pscf.ghf.GHF )) self.assertTrue(isinstance(pscf.KGHF (cell_u), pscf.kghf.KGHF )) self.assertTrue(isinstance(pscf.ROHF (cell ), pscf.rohf.ROHF )) self.assertTrue(isinstance(pscf.ROHF (cell_u), pscf.rohf.ROHF )) self.assertTrue(isinstance(pscf.KROHF(cell ), pscf.krohf.KROHF)) self.assertTrue(isinstance(pscf.KROHF(cell_u), pscf.krohf.KROHF)) self.assertTrue(isinstance(pscf.HF (cell ), pscf.hf.RHF )) self.assertTrue(isinstance(pscf.HF (cell_u), pscf.uhf.UHF )) self.assertTrue(isinstance(pscf.KHF (cell ), pscf.khf.KRHF )) self.assertTrue(isinstance(pscf.KHF (cell_u), pscf.kuhf.KUHF ))
def generate_test_inputs(): import pyqmc from pyqmc.coord import PeriodicConfigs from pyscf.pbc import gto, scf from pyscf.pbc.dft.multigrid import multigrid from pyscf.pbc import tools from pyscf import lib from_chkfile = True if from_chkfile: def loadchkfile(chkfile): cell = gto.cell.loads(lib.chkfile.load(chkfile, "mol")) kpts = cell.make_kpts([1, 1, 1]) mf = scf.KRKS(cell, kpts) mf.__dict__.update(lib.chkfile.load(chkfile, "scf")) return cell, mf cell1, mf1 = loadchkfile("mf1.chkfile") cell2, mf2 = loadchkfile("mf2.chkfile") else: L = 4 cell2 = gto.M( atom="""H {0} {0} {0} H {1} {1} {1}""".format(0.0, L * 0.25), basis="sto-3g", a=np.eye(3) * L, spin=0, unit="bohr", ) print("Primitive cell") kpts = cell2.make_kpts((2, 2, 2)) mf2 = scf.KRKS(cell2, kpts) mf2.xc = "pbe" mf2.chkfile = "mf2.chkfile" mf2 = mf2.run() print("Supercell") cell1 = tools.super_cell(cell2, [2, 2, 2]) kpts = [[0, 0, 0]] mf1 = scf.KRKS(cell1, kpts) mf1.xc = "pbe" mf1.chkfile = "mf1.chkfile" mf1 = mf1.run() # wf1 = pyqmc.PySCFSlaterUHF(cell1, mf1) wf1 = PySCFSlaterPBC(cell1, mf1, supercell=1 * np.eye(3)) wf2 = PySCFSlaterPBC(cell2, mf2, supercell=2 * np.eye(3)) configs = pyqmc.initial_guess(cell1, 10, 0.1) return wf1, wf2, configs
def KRKS(cell, XC, OEI, TEI, nelectron, kpts, DMguess, verbose=0, max_cycle=1): '''KRKS wrapper to solve for 1RDM with a certain umat''' from pyscf.pbc import gto, scf import warnings nkpts = kpts.shape[0] def get_veff(dm_kpts=None, *args): '''Function to compute veff from ERI''' delta = np.eye(nkpts) weight = 1 / nkpts vj = weight * lib.einsum('ijkpqrs,ksr,ij->ipq', TEI, dm_kpts, delta) vk = weight * lib.einsum('ijkpqrs,jqr,jk->ips', TEI, dm_kpts, delta) veff = vj - 0.5 * vk return veff nao = OEI.shape[1] cell.atom = [['He', (0.5, 0.5, 0.5)]] cell.incore_anyway = True cell.nelectron = nelectron kmf = scf.KRKS(cell, kpts, exxdiv=None) kmf.xc = XC kmf.get_hcore = lambda *args: OEI kmf.get_ovlp = lambda *args: np.array([np.eye(nao)] * nkpts) kmf.get_veff = get_veff kmf.max_cycle = max_cycle kmf.run(DMguess) dms = kmf.make_rdm1() return kmf.converged, dms
def test_rccsd_t_non_hf_against_so_frozen(self): '''Tests rccsd_t with gccsd_t with frozen orbitals.''' n = 7 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 = pbcscf.KRKS(cell, kpts=kpts) ekks = kks.kernel() khf = pbcscf.KRHF(cell) khf.__dict__.update(kks.__dict__) mycc = pbcc.KGCCSD(khf, frozen=[[], [0, 1]]) eris = mycc.ao2mo() ekgcc, t1, t2 = mycc.kernel(eris=eris) ekgcc_t = mycc.ccsd_t(eris=eris) mycc = pbcc.KRCCSD(khf, frozen=[[], [0]]) eris = mycc.ao2mo() ekrcc, t1, t2 = mycc.kernel(eris=eris) ekrcc_t = mycc.ccsd_t(eris=eris) self.assertAlmostEqual(ekrcc_t, -0.0018712836246782309, 6) self.assertAlmostEqual(ekrcc_t, ekgcc_t, 6)
def test_rccsd_t_non_hf_against_so(self): '''Tests restricted ccsd and ccsd_t for non Hartree-Fock references against the general spin-orbital implementation.''' n = 7 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 = pbcscf.KRKS(cell, kpts=kpts) ekks = kks.kernel() khf = pbcscf.KRHF(cell) khf.__dict__.update(kks.__dict__) mycc = pbcc.KGCCSD(khf, frozen=None) eris = mycc.ao2mo() ekgcc, t1, t2 = mycc.kernel(eris=eris) ekgcc_t = mycc.ccsd_t(eris=eris) mycc = pbcc.KRCCSD(khf, frozen=None) eris = mycc.ao2mo() ekrcc, t1, t2 = mycc.kernel(eris=eris) ekrcc_t = mycc.ccsd_t(eris=eris) self.assertAlmostEqual(ekrcc_t, -0.0021709465899365336, 6) self.assertAlmostEqual(ekrcc_t, ekgcc_t, 6)
def test_RKS(kind=0, nk=(1, 1, 1)): L = 2 mol = gto.M( atom='''He {0} {0} {0}'''.format(0.0), basis='sto-3g', a=np.eye(3) * L, unit='bohr', ) kpts = mol.make_kpts(nk) mf = scf.KRKS(mol, kpts) mf.xc = "pbe" #mf = mf.density_fit() mf = mf.run() runtest(mol, mf, kind)
def test_RKS(kind=1, nk=(2, 2, 2)): L = 2 mol = gto.M( atom="""He {0} {0} {0}""".format(0.0), basis="sto-3g", a=np.eye(3) * L, unit="bohr", ) kpts = mol.make_kpts(nk) mf = scf.KRKS(mol, kpts) mf.xc = "pbe" # mf = mf.density_fit() mf = mf.run() runtest(mol, mf, kind=kind)
def test_RKS(kind=0, nk=(1, 1, 1)): L = 2 mol = gto.M( atom="""He {0} {0} {0}""".format(0.0), basis="sto-3g", a=np.eye(3) * L, unit="bohr", ) kpts = mol.make_kpts(nk) mf = scf.KRKS(mol, kpts) mf.xc = "pbe" # mf = mf.density_fit() mf = mf.run() supercell = get_supercell(mol, np.diag(nk)) runtest(supercell, mf, kind=kind)
def test_noncubic(kind=1, nk=(2, 2, 2)): L = 3 mol = gto.M( atom="""H {0} {0} {0} H {1} {1} {1}""".format(0.0, L / 4), basis="sto-3g", a=(np.ones((3, 3)) - np.eye(3)) * L / 2, spin=0, unit="bohr", ) kpts = mol.make_kpts(nk) mf = scf.KRKS(mol, kpts) mf.xc = "pbe" # mf = mf.density_fit() mf = mf.run() runtest(mol, mf, kind=kind)
def test_cubic_with_ecp(kind=1, nk=(2, 2, 2)): from pyscf.pbc.dft.multigrid import multigrid L = 6.63 * 2 cell = gto.Cell( atom="""Li {0} {0} {0} Li {1} {1} {1}""".format(0.0, L / 4), basis="bfd-vdz", ecp={"Li": "bfd"}, spin=0, unit="bohr", ) cell.exp_to_discard = 0.1 cell.build(a=np.eye(3) * L) kpts = cell.make_kpts(nk) mf = scf.KRKS(cell, kpts) mf.xc = "pbe" mf = mf.density_fit() mf = multigrid(mf) mf = mf.run() runtest(cell, mf, kind=kind)
def test_h2_jonly_k211_shiftedcenter(self): kpts = cell.make_kpts([2, 1, 1], scaled_center=scaled_center) mf = pscf.KRKS(cell, kpts).rs_density_fit() mf.xc = "pbe" mf.kernel() self.assertAlmostEqual(mf.e_tot, -1.0047041613565, 7)
def test_h2_jonly_k211(self): kpts = cell.make_kpts([2, 1, 1]) mf = pscf.KRKS(cell, kpts).rs_density_fit() mf.xc = "pbe" mf.kernel() self.assertAlmostEqual(mf.e_tot, -1.0021023542499443, 7)
def init_scf(self, cell=None, method=None, verbose=None, damp=None, shift=None, kpts=None, grid_level=None, rho_cutoff=None, density_fit=None, auxbasis=None): """ Initializes the supersystem PySCF SCF object using given settings. Parameters ---------- cell : pyscf.pbc.gto.Cell object Concatenated supersystem Cell object fs_method : str Supersystem SCF method verbose : int PySCF verbosity parameter for output damp : float Damping parameter for SCF convergence shift : float Energy level shift parameter for convergence Returns ------- scf_obj : pyscf.pbc.SCF object SCF object for the supersystem """ import pyscf from pyscf.pbc import scf as pbcscf, df as pbcdf, dft as pbcdft if cell is None: cell = self.cell if method is None: method = self.fs_method if verbose is None: verbose = self.verbose if damp is None: damp = self.fs_damp if shift is None: shift = self.fs_shift if kpts is None: kpts = self.kpts if grid_level is None: grid_level = self.grid_level if rho_cutoff is None: rho_cutoff = self.rho_cutoff if density_fit is None: density_fit = self.density_fit if auxbasis is None: auxbasis = self.auxbasis # if self.pmem: # self.cell.max_memory = self.pmem nkpts = len(kpts) if self.unrestricted: if method in ('hf', 'hartree-fock'): scf_obj = pbcscf.KUHF(cell, kpts) else: scf_obj = pbcscf.KUKS(cell, kpts) scf_obj.xc = method elif cell.spin != 0: if method in ('hf', 'hartree-fock'): scf_obj = pbcscf.KROHF(cell, kpts) else: scf_obj = pbcscf.KROKS(cell, kpts) scf_obj.xc = method else: if method in ('hf', 'hartree-fock'): scf_obj = pbcscf.KRHF(cell, kpts) else: scf_obj = pbcscf.KRKS(cell, kpts) scf_obj.xc = method scf_obj.kpts = kpts scf_obj.verbose = verbose # build grids scf_obj.grids = pbcdft.gen_grid.BeckeGrids(cell) scf_obj.grids.level = grid_level scf_obj.grids.build() # density fitting (can be very time consuming) if density_fit == 'fftdf': DensityFit = pbcdf.FFTDF elif density_fit == 'mdf': DensityFit = pbcdf.MDF elif density_fit == 'pwdf': DensityFit = pbcdf.PWDF elif density_fit == 'gdf': DensityFit = pbcdf.GDF elif density_fit == 'aftdf': DensityFit = pbcdf.AFTDF else: DensityFit = pbcdf.DF scf_obj.with_df = DensityFit(cell) scf_obj.with_df.kpts = kpts scf_obj.with_df.auxbasis = auxbasis scf_obj.damp = damp self.smat = scf_obj.get_ovlp() return scf_obj
#! /usr/bin/env python3 from pyscf.pbc import df, scf $system gdf = df.GDF(cell,kpts) gdf.auxbasis = 'weigend' gdf.build() mf = scf.KRKS(cell,kpts).density_fit() mf.xc ='b3lyp' mf.tol = 1e-10 mf.exxdiv = 'ewald' mf.with_df = gdf mf.kernel()
def init_env_scf(self, cell=None, env_method=None, kpts=None, rho_cutoff=None, verbose=None, damp=None, shift=None, grid_level=None, density_fit=None, auxbasis=None): """ Initializes the environment pyscf:pbc:scf object. Paramters --------- cell : pyscf:pbc:Cell object, optional env_method : str, optional Subsystem method for calculation (default is None). kpts : ndarray, optional Kpoints (in inv. bohr) to use (default is None). rho_cutoff : float, optional DFT density/rho cutoff parameter (default is None). verbose : int, optional Verbosity parameter (default is None). damp : float, optional Damping parameter (default is None). shift : float, optional level shift parameter for convergence (default is None). grid_level : int, optional Grid_level for DFT and Coulomb integration (default is None). density_fit : str, optional The default desnity fit method to use (default is None). auxbasis : str, optional Auxillary basis for density fitting (default is None). Returns ------- cSCF : pyscf.pbc.SCF object """ import numpy as np from pyscf.pbc import dft as pbcdft, scf as pbcscf, df as pbcdf if cell is None: cell = self.cell if env_method is None: env_method = self.env_method.lower() if kpts is None: kpts = self.kpts if rho_cutoff is None: rho_cutoff = self.rho_cutoff if verbose is None: verbose = self.verbose if damp is None: damp = self.damp if shift is None: shift = self.shift if grid_level is None: grid_level = self.grid_level if density_fit is None: density_fit = self.density_fit density_fit = density_fit.lower() if auxbasis is None: auxbasis = self.auxbasis if self.unrestricted: if env_method in ('hf', 'hartree-fock'): cSCF = pbcscf.KUHF(cell, kpts) else: cSCF = pbcscf.KUKS(cell, kpts) cSCF.xc = env_method elif cell.spin != 0: if env_method in ('hf', 'hartree-fock'): cSCF = pbcscf.KROHF(cell, kpts) else: cSCF = pbcscf.KROKS(cell, kpts) cSCF.xc = env_method else: if env_method in ('hf', 'hartree-fock'): cSCF = pbcscf.KRHF(cell, kpts) else: cSCF = pbcscf.KRKS(cell, kpts) cSCF.xc = env_method cSCF.kpts = kpts cSCF.verbose = verbose # grids should probably be for the supersystem # Keep this for now, although its probably expensive # to calculate the grids for each subsystem cSCF.grids = pbcdft.gen_grid.BeckeGrids(cell) cSCF.grids.level = grid_level cSCF.grids.build() # density fitting (can be very time consuming) if density_fit == 'fftdf': DensityFit = pbcdf.FFTDF elif density_fit == 'mdf': DensityFit = pbcdf.MDF elif density_fit == 'pwdf': DensityFit = pbcdf.PWDF elif density_fit == 'gdf': DensityFit = pbcdf.GDF elif density_fit == 'aftdf': DensityFit = pbcdf.AFTDF else: DensityFit = pbcdf.DF cSCF.with_df = DensityFit(cell) cSCF.with_df.kpts = kpts cSCF.with_df.auxbasis = auxbasis # # only for local and semi-local functional for now # cSCF.with_df.build(j_only=True) return cSCF
def loadchkfile(chkfile): cell = gto.cell.loads(lib.chkfile.load(chkfile, "mol")) kpts = cell.make_kpts([1, 1, 1]) mf = scf.KRKS(cell, kpts) mf.__dict__.update(lib.chkfile.load(chkfile, "scf")) return cell, mf