def kernel(mf, conv_tol=1e-9, dump_chk=True, dm0=None, callback=None):
'''the modified SCF kernel for Dirac-Hartree-Fock. In this kernel, the
SCF is carried out in three steps. First the 2-electron part is
approximated by large component integrals (LL|LL); Next, (SS|LL) the
interaction between large and small components are added; Finally,
converge the SCF with the small component contributions (SS|SS)
'''
if dm0 is None:
dm = mf.get_init_guess()
else:
dm = dm0
if dm0 is None and mf._coulomb_now.upper() == 'LLLL':
scf_conv, hf_energy, mo_energy, mo_coeff, mo_occ \
= hf.kernel(mf, 4e-3, dump_chk, dm0=dm, callback=callback)
dm = mf.make_rdm1(mo_coeff, mo_occ)
mf._coulomb_now = 'SSLL'
if dm0 is None and (mf._coulomb_now.upper() == 'SSLL' \
or mf._coulomb_now.upper() == 'LLSS'):
scf_conv, hf_energy, mo_energy, mo_coeff, mo_occ \
= hf.kernel(mf, 4e-4, dump_chk, dm0=dm, callback=callback)
dm = mf.make_rdm1(mo_coeff, mo_occ)
mf._coulomb_now = 'SSSS'
if mf.with_ssss:
mf._coulomb_now = 'SSSS'
else:
mf._coulomb_now = 'SSLL'
if mf.with_gaunt:
mf.get_veff = mf.get_vhf_with_gaunt
return hf.kernel(mf, conv_tol, dump_chk, dm0=dm, callback=callback)
def kernel(mf,
conv_tol=1e-9,
conv_tol_grad=None,
dump_chk=True,
dm0=None,
callback=None,
conv_check=True):
'''the modified SCF kernel for Dirac-Hartree-Fock. In this kernel, the
SCF is carried out in three steps. First the 2-electron part is
approximated by large component integrals (LL|LL); Next, (SS|LL) the
interaction between large and small components are added; Finally,
converge the SCF with the small component contributions (SS|SS)
'''
if conv_tol_grad is None:
conv_tol_grad = numpy.sqrt(conv_tol)
logger.info(mf, 'Set gradient conv threshold to %g', conv_tol_grad)
if dm0 is None:
dm = mf.get_init_guess()
else:
dm = dm0
mf._coulomb_now = 'LLLL'
if dm0 is None and mf._coulomb_now.upper() == 'LLLL':
scf_conv, e_tot, mo_energy, mo_coeff, mo_occ \
= hf.kernel(mf, 1e-2, 1e-1,
dump_chk, dm0=dm, callback=callback,
conv_check=False)
dm = mf.make_rdm1(mo_coeff, mo_occ)
mf._coulomb_now = 'SSLL'
if dm0 is None and (mf._coulomb_now.upper() == 'SSLL'
or mf._coulomb_now.upper() == 'LLSS'):
scf_conv, e_tot, mo_energy, mo_coeff, mo_occ \
= hf.kernel(mf, 1e-3, 1e-1,
dump_chk, dm0=dm, callback=callback,
conv_check=False)
dm = mf.make_rdm1(mo_coeff, mo_occ)
mf._coulomb_now = 'SSSS'
if mf.with_ssss:
mf._coulomb_now = 'SSSS'
else:
mf._coulomb_now = 'SSLL'
return hf.kernel(mf,
conv_tol,
conv_tol_grad,
dump_chk,
dm0=dm,
callback=callback,
conv_check=conv_check)
def scf(self, dm0=None):
cput0 = (time.clock(), time.time())
mol = self.mol
self.build(mol)
self.dump_flags()
self.converged, self.hf_energy, \
self.mo_energy, self.mo_coeff, self.mo_occ \
= hf.kernel(self, self.conv_tol, dm0=dm0,
callback=self.callback)
logger.timer(self, 'SCF', *cput0)
self.dump_energy(self.hf_energy, self.converged)
# sort MOs wrt orbital energies, it should be done last.
o_sort = numpy.argsort(self.mo_energy[self.mo_occ>0])
v_sort = numpy.argsort(self.mo_energy[self.mo_occ==0])
self.mo_energy = numpy.hstack((self.mo_energy[self.mo_occ>0][o_sort], \
self.mo_energy[self.mo_occ==0][v_sort]))
self.mo_coeff = numpy.hstack((self.mo_coeff[:,self.mo_occ>0][:,o_sort], \
self.mo_coeff[:,self.mo_occ==0][:,v_sort]))
nocc = len(o_sort)
self.mo_occ[:nocc] = self.mo_occ[self.mo_occ>0][o_sort]
self.mo_occ[nocc:] = 0
#if self.verbose >= logger.INFO:
# self.analyze(self.verbose)
return self.hf_energy
def kernel(mf, conv_tol=1e-9, conv_tol_grad=None,
dump_chk=True, dm0=None, callback=None, conv_check=True):
'''the modified SCF kernel for Dirac-Hartree-Fock. In this kernel, the
SCF is carried out in three steps. First the 2-electron part is
approximated by large component integrals (LL|LL); Next, (SS|LL) the
interaction between large and small components are added; Finally,
converge the SCF with the small component contributions (SS|SS)
'''
if conv_tol_grad is None:
conv_tol_grad = numpy.sqrt(conv_tol)
logger.info(mf, 'Set gradient conv threshold to %g', conv_tol_grad)
if dm0 is None:
dm = mf.get_init_guess()
else:
dm = dm0
mf._coulomb_now = 'LLLL'
if dm0 is None and mf._coulomb_now.upper() == 'LLLL':
scf_conv, e_tot, mo_energy, mo_coeff, mo_occ \
= hf.kernel(mf, 1e-2, 1e-1,
dump_chk, dm0=dm, callback=callback,
conv_check=False)
dm = mf.make_rdm1(mo_coeff, mo_occ)
mf._coulomb_now = 'SSLL'
if dm0 is None and (mf._coulomb_now.upper() == 'SSLL' or
mf._coulomb_now.upper() == 'LLSS'):
scf_conv, e_tot, mo_energy, mo_coeff, mo_occ \
= hf.kernel(mf, 1e-3, 1e-1,
dump_chk, dm0=dm, callback=callback,
conv_check=False)
dm = mf.make_rdm1(mo_coeff, mo_occ)
mf._coulomb_now = 'SSSS'
if mf.with_ssss:
mf._coulomb_now = 'SSSS'
else:
mf._coulomb_now = 'SSLL'
return hf.kernel(mf, conv_tol, conv_tol_grad, dump_chk, dm0=dm,
callback=callback, conv_check=conv_check)
def kernel(mf, dm0=None, **kwargs):
if dm0 is None:
dm0 = mf.dm_guess
mf.converged, mf.e_tot, \
mf.mo_energy, mf.mo_coeff, mf.mo_occ = \
hf.kernel(mf, mf.conv_tol, mf.conv_tol_grad,
dm0=dm0, callback=mf.callback,
conv_check=mf.conv_check, **kwargs)
if (mf.converged == False ):
print ("scf did not converge")
#raise RuntimeError("scf did not converge")
mf.rdm1 = mf.make_rdm1()
mf.elec_energy = mf.energy_elec(mf.rdm1)[0]
def scf(self, dm0=None):
cput0 = (time.clock(), time.time())
self.build()
self.dump_flags()
self.converged, self.hf_energy, \
self.mo_energy, self.mo_coeff, self.mo_occ \
= hf.kernel(self, self.conv_tol, dm0=dm0,
callback=self.callback)
# if self.nelectron_alpha * 2 < self.mol.nelectron:
# self.mo_coeff = (self.mo_coeff[1], self.mo_coeff[0])
# self.mo_occ = (self.mo_occ[1], self.mo_occ[0])
# self.mo_energy = (self.mo_energy[1], self.mo_energy[0])
logger.timer(self, 'SCF', *cput0)
self.dump_energy(self.hf_energy, self.converged)
#if self.verbose >= logger.INFO:
# self.analyze(self.verbose)
return self.hf_energy
def scf(self, dm0=None):
cput0 = (time.clock(), time.time())
mol = self.mol
self.build(mol)
self.dump_flags()
self.converged, self.hf_energy, \
self.mo_energy, self.mo_coeff, self.mo_occ \
= hf.kernel(self, self.conv_tol, dm0=dm0,
callback=self.callback)
logger.timer(self, 'SCF', *cput0)
self.dump_energy(self.hf_energy, self.converged)
ea = numpy.hstack(self.mo_energy[0])
eb = numpy.hstack(self.mo_energy[0])
oa_sort = numpy.argsort(ea[self.mo_occ[0]>0])
va_sort = numpy.argsort(ea[self.mo_occ[0]==0])
ob_sort = numpy.argsort(eb[self.mo_occ[1]>0])
vb_sort = numpy.argsort(eb[self.mo_occ[1]==0])
self.mo_energy = (numpy.hstack((ea[self.mo_occ[0]>0 ][oa_sort], \
ea[self.mo_occ[0]==0][va_sort])), \
numpy.hstack((eb[self.mo_occ[1]>0 ][ob_sort], \
eb[self.mo_occ[1]==0][vb_sort])))
ca = self.mo_coeff[0]
cb = self.mo_coeff[1]
self.mo_coeff = (numpy.hstack((ca[:,self.mo_occ[0]>0 ][:,oa_sort], \
ca[:,self.mo_occ[0]==0][:,va_sort])), \
numpy.hstack((cb[:,self.mo_occ[1]>0 ][:,ob_sort], \
cb[:,self.mo_occ[1]==0][:,vb_sort])))
nocc_a = int(self.mo_occ[0].sum())
nocc_b = int(self.mo_occ[1].sum())
self.mo_occ[0][:nocc_a] = 1
self.mo_occ[0][nocc_a:] = 0
self.mo_occ[1][:nocc_b] = 1
self.mo_occ[1][nocc_b:] = 0
#if self.verbose >= logger.INFO:
# self.analyze(self.verbose)
return self.hf_energy
def scf(self, *args, **kwargs):
self.build()
return hf.kernel(self, *args, dump_chk=False, **kwargs)