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 test_noncubic(kind=0, nk=(1, 1, 1)):
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.KUKS(mol, kpts)
mf.xc = "pbe"
# mf = mf.density_fit()
mf = mf.run()
runtest(mol, mf, kind=kind)
def setUpModule():
global cell, mf, kpts
cell = gto.Cell()
cell.a = '''
1.755000 1.755000 -1.755000
1.755000 -1.755000 1.755000
-1.755000 1.755000 1.755000'''
cell.atom = '''Li 0.00000 0.00000 0.00000'''
#same type of basis for different elements
cell.basis = 'gth-szv'
cell.pseudo = {'Li': 'GTH-PBE-q3'}
cell.mesh = [20] * 3
cell.verbose = 6
cell.output = '/dev/null'
cell.build()
kpts = cell.make_kpts([2, 2, 2])
mf = scf.KUKS(cell, kpts)
mf.xc = 'lda,vwn'
mf.kernel()
def cubic_with_ecp(kind=0, nk=(1, 1, 1)):
from pyscf.pbc.dft.multigrid import multigrid
start = time.time()
L = 6.63
mol = gto.Cell(
atom='''Li {0} {0} {0}
Li {1} {1} {1}'''.format(0.0, L / 2),
basis='bfd-vdz',
ecp='bfd',
spin=0,
unit='bohr',
)
mol.exp_to_discard = 0.1
mol.build(a=np.eye(3) * L)
kpts = mol.make_kpts(nk)
mf = scf.KUKS(mol, kpts)
mf.xc = "pbe"
#mf = mf.density_fit()
mf = multigrid(mf)
mf = mf.run()
runtest(mol, mf, kind)
def cubic_with_ecp(kind=0, nk=(1, 1, 1)):
from pyscf.pbc.dft.multigrid import multigrid
start = time.time()
L = 6.63
mol = gto.Cell(
atom="""Li {0} {0} {0}
Li {1} {1} {1}""".format(0.0, L / 2),
basis="bfd-vdz",
ecp="bfd",
spin=0,
unit="bohr",
)
mol.exp_to_discard = 0.1
mol.build(a=np.eye(3) * L)
kpts = mol.make_kpts(nk)
mf = scf.KUKS(mol, kpts)
mf.xc = "pbe"
# mf = mf.density_fit()
mf = multigrid(mf)
mf = mf.run()
supercell = get_supercell(mol, np.diag(nk))
runtest(supercell, mf, kind=kind)
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
cell.a = '''
1.755000 1.755000 -1.755000
1.755000 -1.755000 1.755000
-1.755000 1.755000 1.755000'''
cell.atom = '''Li 0.00000 0.00000 0.00000'''
#same type of basis for different elements
cell.basis = 'gth-szv'
cell.pseudo = {'Li': 'GTH-PBE-q3'}
cell.mesh = [20] * 3
cell.verbose = 6
cell.output = '/dev/null'
cell.build()
kpts = cell.make_kpts([2, 2, 2])
mf = scf.KUKS(cell, kpts)
mf.xc = 'lda,vwn'
mf.kernel()
def tearDownModule():
global cell, mf
del cell, mf
class KnownValues(unittest.TestCase):
def test_k2gamma(self):
popa, popb = mf.mulliken_meta()[0]
self.assertAlmostEqual(lib.finger(popa).sum(), 1.5403023058, 7)
self.assertAlmostEqual(lib.finger(popb).sum(), 1.5403023058, 7)
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
