def test_convert_to_kscf(self):
from pyscf.pbc import df
from pyscf.soscf import newton_ah
cell1 = cell.copy()
cell1.verbose = 0
pscf.addons.convert_to_rhf(pscf.KRHF(cell1))
pscf.addons.convert_to_uhf(pscf.KRHF(cell1))
pscf.addons.convert_to_ghf(pscf.KRHF(cell1))
pscf.addons.convert_to_rhf(pscf.KROHF(cell1))
pscf.addons.convert_to_uhf(pscf.KROHF(cell1))
pscf.addons.convert_to_ghf(pscf.KROHF(cell1))
pscf.addons.convert_to_rhf(pscf.KUHF(cell1))
pscf.addons.convert_to_uhf(pscf.KUHF(cell1))
pscf.addons.convert_to_ghf(pscf.KUHF(cell1))
#pscf.addons.convert_to_rhf(pscf.KGHF(cell1))
#pscf.addons.convert_to_uhf(pscf.KGHF(cell1))
pscf.addons.convert_to_ghf(pscf.KGHF(cell1))
self.assertTrue (isinstance(pscf.addons.convert_to_rhf(pscf.KRHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
self.assertFalse(isinstance(pscf.addons.convert_to_uhf(pscf.KRHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
self.assertFalse(isinstance(pscf.addons.convert_to_ghf(pscf.KRHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
self.assertFalse(isinstance(pscf.addons.convert_to_rhf(pscf.KUHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
self.assertTrue (isinstance(pscf.addons.convert_to_uhf(pscf.KUHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
self.assertFalse(isinstance(pscf.addons.convert_to_ghf(pscf.KUHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
#self.assertFalse(isinstance(pscf.addons.convert_to_rhf(pscf.KGHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
#self.assertFalse(isinstance(pscf.addons.convert_to_uhf(pscf.KGHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
#self.assertTrue (isinstance(pscf.addons.convert_to_ghf(pscf.KGHF(cell1).newton().density_fit().x2c()), newton_ah._CIAH_SOSCF))
mf1 = pscf.khf.KRHF(cell1)
cell2 = cell1.copy()
cell2.spin = 2
mf2 = mf1.convert_from_(kmf_u)
self.assertEqual(kmf_u.kpts.shape, (2, 3))
self.assertEqual(mf2.kpts.shape, (2, 3))
self.assertTrue (isinstance(mf2, pscf.khf.KRHF))
self.assertTrue (isinstance(mf1.convert_from_(pscf.KUHF(cell2)), pscf.khf.KRHF))
self.assertFalse(isinstance(mf1.convert_from_(pscf.KUHF(cell2)), pscf.krohf.KROHF))
self.assertFalse(isinstance(mf1.convert_from_(kmf_u.newton()), newton_ah._CIAH_SOSCF))
self.assertTrue (isinstance(mf1.convert_from_(pscf.KUHF(cell2).density_fit()).with_df, df.df.GDF))
self.assertTrue (isinstance(mf1.convert_from_(pscf.KUHF(cell2).mix_density_fit()).with_df, df.mdf.MDF))
self.assertFalse(isinstance(mf1.convert_from_(pscf.KROHF(cell2)), pscf.krohf.KROHF))
self.assertRaises(AssertionError, mf1.convert_from_, pscf.UHF(cell1))
mf1 = pscf.krohf.KROHF(cell1)
self.assertTrue (isinstance(mf1.convert_from_(kmf_u), pscf.krohf.KROHF))
self.assertTrue (isinstance(mf1.convert_from_(pscf.KUHF(cell2)), pscf.krohf.KROHF))
self.assertFalse(isinstance(mf1.convert_from_(kmf_u.newton()), newton_ah._CIAH_SOSCF))
self.assertTrue (isinstance(mf1.convert_from_(pscf.KUHF(cell2).density_fit()).with_df, df.df.GDF))
self.assertTrue (isinstance(mf1.convert_from_(pscf.KUHF(cell2).mix_density_fit()).with_df, df.mdf.MDF))
self.assertTrue (isinstance(mf1.convert_from_(kmf_r), pscf.krohf.KROHF))
self.assertRaises(AssertionError, mf1.convert_from_, pscf.UHF(cell1))
self.assertTrue(isinstance(pscf.addons.convert_to_rhf(pscf.KROHF(cell2)), pscf.krohf.KROHF))
#self.assertTrue(isinstance(pscf.addons.convert_to_rhf(pscf.KROHF(cell2).newton()), pscf.krohf.KROHF))
mf1 = pscf.kuhf.KUHF(cell1)
self.assertTrue (isinstance(mf1.convert_from_(kmf_r), pscf.kuhf.KUHF))
self.assertFalse(isinstance(mf1.convert_from_(kmf_r.newton()), newton_ah._CIAH_SOSCF))
self.assertTrue (isinstance(mf1.convert_from_(kmf_r.density_fit()).with_df, df.df.GDF))
self.assertTrue (isinstance(mf1.convert_from_(kmf_ro.mix_density_fit()).with_df, df.mdf.MDF))
self.assertRaises(AssertionError, mf1.convert_from_, pscf.UHF(cell1))
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)
def test_uhf_1d(self):
L = 4
cell = pbcgto.Cell()
cell.build(
unit='B',
a=numpy.eye(3) * 4,
mesh=[10, 20, 20],
atom='''He 2 0 0; He 3 0 0''',
dimension=1,
low_dim_ft_type='inf_vacuum',
verbose=0,
basis={
'He': [
[0, (0.8, 1.0)],
#[0, (1.0, 1.0)],
[0, (1.2, 1.0)]
]
})
mf = pscf.UHF(cell)
mf.with_df = pdf.AFTDF(cell)
mf.with_df.eta = 0.3
mf.with_df.mesh = cell.mesh
mf.init_guess = 'hcore'
e1 = mf.kernel()
self.assertAlmostEqual(e1, -3.24497234871167, 5)
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
return mf
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_uhf_exx_ewald(self):
mf = pscf.UHF(cell, exxdiv='ewald')
mf.init_guess = 'hcore'
e1 = mf.kernel()
self.assertAlmostEqual(e1, -4.3511582287379111, 8)
self.assertTrue(mf.mo_coeff[0].dtype == numpy.double)
kmf = pscf.KUHF(cell, [[0,0,0]], exxdiv='ewald')
kmf.init_guess = 'hcore'
e0 = kmf.kernel()
self.assertTrue(numpy.allclose(e0,e1))
# test bands
numpy.random.seed(1)
kpts_band = numpy.random.random((2,3))
e1a, e1b = mf.get_bands(kpts_band)[0]
e0a, e0b = kmf.get_bands(kpts_band)[0]
self.assertAlmostEqual(abs(e0a[0]-e1a[0]).max(), 0, 5)
self.assertAlmostEqual(abs(e0a[1]-e1a[1]).max(), 0, 5)
self.assertAlmostEqual(abs(e0b[0]-e1b[0]).max(), 0, 5)
self.assertAlmostEqual(abs(e0b[1]-e1b[1]).max(), 0, 5)
self.assertAlmostEqual(lib.finger(e1a[0]), -6.2986775452228283, 5)
self.assertAlmostEqual(lib.finger(e1a[1]), -7.6616273746782362, 5)
numpy.random.seed(1)
k = numpy.random.random(3)
mf = pscf.UHF(cell, k, exxdiv='ewald')
e1 = mf.kernel()
self.assertAlmostEqual(e1, -4.2048655827967139, 8)
self.assertTrue(mf.mo_coeff[0].dtype == numpy.complex128)
kmf = pscf.KUHF(cell, k, exxdiv='ewald')
e0 = kmf.kernel()
self.assertTrue(numpy.allclose(e0,e1))
# test bands
numpy.random.seed(1)
kpts_band = numpy.random.random((2,3))
e1a, e1b = mf.get_bands(kpts_band)[0]
e0a, e0b = kmf.get_bands(kpts_band)[0]
self.assertAlmostEqual(abs(e0a[0]-e1a[0]).max(), 0, 5)
self.assertAlmostEqual(abs(e0a[1]-e1a[1]).max(), 0, 5)
self.assertAlmostEqual(abs(e0b[0]-e1b[0]).max(), 0, 5)
self.assertAlmostEqual(abs(e0b[1]-e1b[1]).max(), 0, 5)
self.assertAlmostEqual(lib.finger(e1a[0]), -6.8312867098806249, 5)
self.assertAlmostEqual(lib.finger(e1a[1]), -6.1120214505413086, 5)
def test_uhf_exx_ewald(self):
mf = pscf.UHF(cell, exxdiv=None)
e1 = mf.kernel()
self.assertAlmostEqual(e1, -2.9325094887283196, 9)
self.assertTrue(mf.mo_coeff[0].dtype == numpy.double)
numpy.random.seed(1)
k = numpy.random.random(3)
mf = pbchf.RHF(cell, k, exxdiv=None)
e1 = mf.kernel()
self.assertAlmostEqual(e1, -2.7862168430230341, 9)
self.assertTrue(mf.mo_coeff[0].dtype == numpy.complex128)
mf = pscf.UHF(cell, exxdiv='ewald')
e1 = mf.kernel()
self.assertAlmostEqual(e1, -4.3511582287379111, 9)
self.assertTrue(mf.mo_coeff[0].dtype == numpy.double)
def test_convert_to_khf(self):
mf1 = pscf.GHF(cell)
self.assertTrue(isinstance(pscf.addons.convert_to_khf(mf1), pscf.kghf.KGHF))
mf1 = pscf.RHF(cell)
self.assertTrue(isinstance(pscf.addons.convert_to_khf(mf1), pscf.krhf.KRHF))
mf1 = pscf.UHF(cell)
self.assertTrue(isinstance(pscf.addons.convert_to_khf(mf1), pscf.kuhf.KUHF))
mf1 = pscf.ROHF(cell)
self.assertTrue(isinstance(pscf.addons.convert_to_khf(mf1), pscf.krohf.KROHF))
def test_uhf_smearing(self):
mf = pscf.UHF(cell)
pscf.addons.smearing_(mf, 0.1, 'fermi')
mo_energy = numpy.arange(nao)*.2+numpy.cos(.5)*.1
mo_energy = numpy.array([mo_energy, mo_energy+numpy.cos(mo_energy)*.02])
mf.get_occ(mo_energy)
self.assertAlmostEqual(mf.entropy, 3.1007387905421022, 9)
mf.smearing_method = 'gauss'
occ = mf.get_occ(mo_energy)
self.assertAlmostEqual(mf.entropy, 0.42189309944541731, 9)
def test_convert_to_kghf(self):
from pyscf.pbc import df
from pyscf.soscf import newton_ah
mf1 = pscf.kghf.KGHF(cell)
self.assertTrue (isinstance(mf1.convert_from_(kmf_r), pscf.kghf.KGHF))
self.assertTrue (isinstance(mf1.convert_from_(kmf_u), pscf.kghf.KGHF))
self.assertTrue (isinstance(mf1.convert_from_(kmf_ro), pscf.kghf.KGHF))
self.assertRaises(AssertionError, mf1.convert_from_, pscf.UHF(cell))
self.assertTrue (isinstance(mf1.convert_from_(kmf_u), pscf.kghf.KGHF))
self.assertFalse(isinstance(mf1.convert_from_(kmf_u.newton()), newton_ah._CIAH_SOSCF))
self.assertTrue (isinstance(mf1.convert_from_(kmf_u.density_fit()).with_df, df.df.GDF))
self.assertTrue (isinstance(mf1.convert_from_(kmf_u.mix_density_fit()).with_df, df.mdf.MDF))
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
def test_kuccsd_openshell():
cell = gto.M(
unit='B',
a=[[0., 6.74027466, 6.74027466], [6.74027466, 0., 6.74027466],
[6.74027466, 6.74027466, 0.]],
mesh=[13] * 3,
atom='''H 0 0 0
H 1.68506866 1.68506866 1.68506866
H 3.37013733 3.37013733 3.37013733''',
basis=[[0, (1., 1.)], [0, (.5, 1.)]],
verbose=1,
charge=0,
spin=1,
)
nmp = [3, 1, 1]
# cell spin multiplied by nkpts
cell.spin = cell.spin * 3
# treating 3*1*1 supercell at gamma point
supcell = super_cell(cell, nmp)
umf = scf.UHF(supcell, exxdiv=None)
umf.conv_tol = 1e-11
ehf = umf.kernel()
ucc = cc.UCCSD(umf)
ucc.conv_tol = 1e-12
ecc, t1, t2 = ucc.kernel()
print('UHF energy (supercell) %.9f \n' % (float(ehf) / 3.))
print('UCCSD correlation energy (supercell) %.9f \n' % (float(ecc) / 3.))
assert abs(ehf / 3 - -1.003789445) < 1e-7
assert abs(ecc / 3 - -0.029056542) < 1e-6
# kpts calculations
kpts = cell.make_kpts(nmp)
kpts -= kpts[0]
kmf = scf.KUHF(cell, kpts, exxdiv=None)
kmf.conv_tol = 1e-11
ehf = kmf.kernel()
kcc = cc.KUCCSD(kmf)
kcc.conv_tol = 1e-12
ecc, t1, t2 = kcc.kernel()
print('UHF energy (kpts) %.9f \n' % (float(ehf)))
print('UCCSD correlation energy (kpts) %.9f \n' % (float(ecc)))
assert abs(ehf - -1.003789445) < 1e-7
assert abs(ecc - -0.029056542) < 1e-6
def test_init_guess_by_chkfile(self):
np.random.seed(1)
k = np.random.random(3)
mf = pscf.KUHF(cell, [k], exxdiv='vcut_sph')
mf.max_cycle = 1
mf.diis = None
e1 = mf.kernel()
self.assertAlmostEqual(e1, -3.4070772194665477, 9)
mf1 = pscf.UHF(cell, exxdiv='vcut_sph')
mf1.chkfile = mf.chkfile
mf1.init_guess = 'chkfile'
mf1.diis = None
mf1.max_cycle = 1
e1 = mf1.kernel()
self.assertAlmostEqual(e1, -3.4272925247351256, 9)
self.assertTrue(mf1.mo_coeff[0].dtype == np.double)
def test_kuhf_vs_uhf(self):
np.random.seed(1)
k = np.random.random(3)
mf = pscf.UHF(cell, k, exxdiv='vcut_sph')
dm = mf.get_init_guess(key='1e')
mf.max_cycle = 1
mf.diis = None
e1 = mf.kernel(dm)
nao = cell.nao
kmf = pscf.KUHF(cell, [k], exxdiv='vcut_sph')
kmf.max_cycle = 1
kmf.diis = None
e2 = kmf.kernel(dm.reshape(2, 1, nao, nao))
self.assertAlmostEqual(e1, e2, 9)
self.assertAlmostEqual(e1, -3.498612316383892, 9)
def test_init_guess_by_chkfile(self):
np.random.seed(1)
k = np.random.random(3)
mf = pscf.KUHF(cell, [k], exxdiv='vcut_sph')
mf.max_cycle = 1
mf.diis = None
e1 = mf.kernel()
self.assertAlmostEqual(e1, -3.3058403617753886, 9)
mf1 = pscf.UHF(cell, exxdiv='vcut_sph')
mf1.chkfile = mf.chkfile
mf1.init_guess = 'chkfile'
mf1.diis = None
mf1.max_cycle = 1
e1 = mf1.kernel()
self.assertAlmostEqual(e1, -3.4204798298887615, 9)
self.assertTrue(mf1.mo_coeff[0].dtype == np.double)
def setUpModule():
global cell, mf, kmf, kpts
cell = pgto.Cell()
cell.atom = '''
He 0 0 1
He 1 0 1
'''
cell.basis = '321g'
cell.a = np.eye(3) * 3
cell.mesh = [8] * 3
cell.verbose = 7
cell.output = '/dev/null'
cell.spin = 2
cell.build()
nk = [2, 2, 1]
kpts = cell.make_kpts(nk, wrap_around=True)
kmf = pscf.KUHF(cell, kpts).run()
mf = pscf.UHF(cell).run()
def test_kuccsd_supercell_vs_kpts_high_cost():
cell = gto.M(
unit = 'B',
a = [[ 0., 3.37013733, 3.37013733],
[ 3.37013733, 0., 3.37013733],
[ 3.37013733, 3.37013733, 0. ]],
mesh = [13]*3,
atom = '''He 0 0 0
He 1.68506866 1.68506866 1.68506866''',
basis = [[0, (1., 1.)], [0, (.5, 1.)]],
verbose = 0,
)
nmp = [3,3,1]
# treating supercell at gamma point
supcell = super_cell(cell,nmp)
gmf = scf.UHF(supcell,exxdiv=None)
ehf = gmf.kernel()
gcc = cc.UCCSD(gmf)
ecc, t1, t2 = gcc.kernel()
print('UHF energy (supercell) %f \n' % (float(ehf)/numpy.prod(nmp)))
print('UCCSD correlation energy (supercell) %f \n' % (float(ecc)/numpy.prod(nmp)))
assert abs(ehf / 9 - -4.343308413289) < 1e-7
assert abs(ecc / 9 - -0.009470753047083676) < 1e-6
# treating mesh of k points
kpts = cell.make_kpts(nmp)
kpts -= kpts[0]
kmf = scf.KUHF(cell,kpts,exxdiv=None)
ehf = kmf.kernel()
kcc = cc.KUCCSD(kmf)
ecc, t1, t2 = kcc.kernel()
print('UHF energy (kpts) %f \n' % ehf)
print('UCCSD correlation energy (kpts) %f \n' % ecc)
assert abs(ehf - -4.343308413289) < 1e-7
assert abs(ecc - -0.009470753047083676) < 1e-6
ehf = kmf.kernel(dmk)
kcc = cc.KUCCSD(kmf)
ecc, t1, t2 = kcc.kernel()
print('========================================')
print('UHF energy (kpts) %f \n' % (float(ehf)))
print('UCCSD correlation energy (kpts) %f \n' % (float(ecc)))
print('========================================')
# Gamma point supercell calculation
supcell = super_cell(cell, nmp)
dms = np.zeros([2, supcell.nao_nr(), supcell.nao_nr()])
for i in range(nkpts):
for j in range(2):
dms[0][j + i * nao][j + i * nao] = 0.5
dms[1][j + i * nao + nao_half][j + i * nao + nao_half] = 0.5
gmf = scf.UHF(supcell, exxdiv=None).density_fit()
gmf.chkfile = 'supcell.chk'
ehf = gmf.kernel(dms)
gcc = cc.UCCSD(gmf)
ecc, t1, t2 = gcc.kernel()
print('========================================')
print('UHF energy (supercell) %f' % (float(ehf) / nk))
print('UCCSD correlation energy (supercell) %f' % (float(ecc) / nk))
print('========================================')
unit='B',
a=[[0., 3.37013733, 3.37013733], [3.37013733, 0., 3.37013733],
[3.37013733, 3.37013733, 0.]],
mesh=[13] * 3,
atom='''He 0 0 0
He 1.68506866 1.68506866 1.68506866''',
basis=[[0, (1., 1.)], [0, (.5, 1.)]],
verbose=0,
)
nmp = [3, 3, 1]
# treating supercell at gamma point
supcell = super_cell(cell, nmp)
gmf = scf.UHF(supcell, exxdiv=None)
ehf = gmf.kernel()
gcc = cc.UCCSD(gmf)
ecc, t1, t2 = gcc.kernel()
print('UHF energy (supercell) %f \n' %
(float(ehf) / numpy.prod(nmp) + 4.343308413289))
print('UCCSD correlation energy (supercell) %f \n' %
(float(ecc) / numpy.prod(nmp) + 0.009470753047083676))
# treating mesh of k points
kpts = cell.make_kpts(nmp)
kpts -= kpts[0]
kmf = scf.KUHF(cell, kpts, exxdiv=None)
ehf = kmf.kernel()
kcc = cc.KUCCSD(kmf)
cell = pgto.Cell()
cell.atom = '''
He 0 0 1
He 1 0 1
'''
cell.basis = '321g'
cell.a = np.eye(3) * 3
cell.mesh = [8] * 3
cell.verbose = 7
cell.output = '/dev/null'
cell.spin = 2
cell.build()
nk = [2, 2, 1]
kpts = cell.make_kpts(nk, wrap_around=True)
kmf = pscf.KUHF(cell, kpts).run()
mf = pscf.UHF(cell).run()
def tearDownModule():
global cell, kmf, mf
cell.stdout.close()
del cell, kmf, mf
class KnownValues(unittest.TestCase):
def test_kuhf_kernel(self):
self.assertAlmostEqual(kmf.e_tot, -4.586720023431593, 8)
def test_uhf_kernel(self):
self.assertAlmostEqual(mf.e_tot, -3.3634535013441855, 8)
def test_kuhf_vs_uhf(self):
np.random.seed(1)
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)
def test_nr_uhf(self):
mf = scf.UHF(cell)
mf = scf.newton(mf)
mf.conv_tol_grad = 1e-4
mf.kernel()
self.assertAlmostEqual(mf.e_tot, -10.137043711032916, 8)
'''
cell.basis = 'ccpvdz'
cell.a = numpy.eye(3) * 4
cell.verbose = 4
cell.build()
#
# Use scf.addons.smearing_ function to modify PBC (gamma-point or k-points)
# SCF object
#
nks = [2,1,1]
mf = scf.KRHF(cell, cell.make_kpts(nks))
mf = scf.addons.smearing_(mf, sigma=.1, method='fermi')
mf.kernel()
print('Entropy = %s' % mf.entropy)
#
# The smearing method and parameters can be modified at runtime
#
mf = scf.addons.smearing_(scf.UHF(cell))
mf.sigma = .1
mf.method = 'gauss'
mf.max_cycle = 2
mf.kernel()
mf.sigma = .05
mf.method = 'fermi'
mf.max_cycle = 50
mf.kernel()
def test_uhf_stability(self):
umf = pscf.UHF(cell, exxdiv='ewald').run(conv_tol=1e-12)
mo_i, mo_e = umf.stability(internal=True, external=True)
self.assertAlmostEqual(abs(umf.mo_coeff[0]-mo_i[0]).max(), 0, 9)
self.assertAlmostEqual(abs(umf.mo_coeff[1]-mo_i[1]).max(), 0, 9)
mo = numpy.hstack((mocore, mocas, movir))
return ncas, nelecas, mo
avas = kernel
del(THRESHOLD_OCC, THRESHOLD_VIR, MINAO, WITH_IAO, OPENSHELL_OPTION, CANONICALIZE)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import mcscf
mol = gto.M(
verbose = 0,
atom = '''
H 0.000000, 0.500000, 1.5
O 0.000000, 0.000000, 1.
O 0.000000, 0.000000, -1.
H 0.000000, -0.500000, -1.5''',
basis = 'ccpvdz',
)
mf = scf.UHF(mol)
mf.scf()
ncas, nelecas, mo = avas(mf, 'O 2p', verbose=4, ncore=2)
mc = mcscf.CASSCF(mf, ncas, nelecas).set(verbose=4)
emc = mc.kernel(mo)[0]
print(emc, -150.51496582534054)
float(lattice_vector)
for lattice_vector in results.lattice_vectors.split(",")
]
lattice_vectors = [
flat_lattice_vectors[0:3], flat_lattice_vectors[3:6],
flat_lattice_vectors[6:9]
]
num_frozen_cores = int(
results.frozen_cores) if results.frozen_cores is not None else 0
sys.argv = [sys.argv[0]]
# -----------------------
# PYSCF
# -----------------------
cell = gto.M(atom=atomic_coords,
basis=basis_set,
spin=spin,
charge=charge,
a=lattice_vectors,
pseudo=pseudo_potential,
precision=1e-6,
verbose=5)
mf = scf.UHF(cell)
mf.with_df = getattr(df, density_fit)(cell)
if density_fit == "gdf" or density_fit == "mdf":
mf.with_df.auxbasis = aux_basis_set
mf.kernel()
