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
