['H', (0., -0.5, -1.)],
['H', (0., -0.5, -0.)],
['H', (0., -0., -1.)],
['H', (1., -0.5, 0.)],
['H', (0., 1., 1.)],
]
mol.basis = {
'H': 'sto-3g',
'O': '6-31g',
}
mol.charge = 1
mol.spin = 1
mol.build()
m = scf.UHF(mol)
ehf = m.scf()
emc = kernel(umc1step.CASSCF(m, 4, (2, 1)), m.mo_coeff, verbose=4)[1]
print(ehf, emc, emc - ehf)
print(emc - -2.9782774463926618)
mol.atom = [
['O', (0., 0., 0.)],
['H', (0., -0.757, 0.587)],
['H', (0., 0.757, 0.587)],
]
mol.basis = {
'H': 'cc-pvdz',
'O': 'cc-pvdz',
}
mol.charge = 1
self.made_ee_imds = True
logger.timer(self, 'EOM-CCSD EE intermediates', *cput0)
return self
if __name__ == '__main__':
from pyscf import scf
from pyscf import gto
from pyscf.cc import gccsd
mol = gto.Mole()
mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = 'cc-pvdz'
mol.spin = 0
mol.build()
mf = scf.UHF(mol).run()
mf = scf.addons.convert_to_ghf(mf)
mycc = gccsd.GCCSD(mf)
ecc, t1, t2 = mycc.kernel()
print(ecc - -0.2133432712431435)
e, v = mycc.ipccsd(nroots=8)
print(e[0] - 0.4335604332073799)
print(e[2] - 0.5187659896045407)
print(e[4] - 0.6782876002229172)
#mycc.verbose = 5
e, v = mycc.eaccsd(nroots=8)
print(e[0] - 0.16737886338859731)
print(e[2] - 0.24027613852009164)
print(e[4] - 0.51006797826488071)
def _calculate_integrals(mol, hf_method="rhf", conv_tol=1e-9, max_cycle=50, init_guess="minao"):
"""Function to calculate the one and two electron terms. Perform a Hartree-Fock calculation in
the given basis.
Args:
mol (gto.Mole) : A PySCF gto.Mole object.
hf_method (str): rhf, uhf, rohf
conv_tol (float): Convergence tolerance
max_cycle (int): Max convergence cycles
init_guess (str): Initial guess for SCF
Returns:
QMolecule: QMolecule populated with driver integrals etc
Raises:
QiskitNatureError: Invalid hf method type
"""
enuke = gto.mole.energy_nuc(mol)
if hf_method == "rhf":
m_f = scf.RHF(mol)
elif hf_method == "rohf":
m_f = scf.ROHF(mol)
elif hf_method == "uhf":
m_f = scf.UHF(mol)
else:
raise QiskitNatureError("Invalid hf_method type: {}".format(hf_method))
m_f.conv_tol = conv_tol
m_f.max_cycle = max_cycle
m_f.init_guess = init_guess
ehf = m_f.kernel()
logger.info("PySCF kernel() converged: %s, e(hf): %s", m_f.converged, m_f.e_tot)
if isinstance(m_f.mo_coeff, tuple):
mo_coeff = m_f.mo_coeff[0]
mo_coeff_b = m_f.mo_coeff[1]
mo_occ = m_f.mo_occ[0]
mo_occ_b = m_f.mo_occ[1]
else:
# With PySCF 1.6.2, instead of a tuple of 2 dimensional arrays, its a 3 dimensional
# array with the first dimension indexing to the coeff arrays for alpha and beta
if len(m_f.mo_coeff.shape) > 2:
mo_coeff = m_f.mo_coeff[0]
mo_coeff_b = m_f.mo_coeff[1]
mo_occ = m_f.mo_occ[0]
mo_occ_b = m_f.mo_occ[1]
else:
mo_coeff = m_f.mo_coeff
mo_coeff_b = None
mo_occ = m_f.mo_occ
mo_occ_b = None
norbs = mo_coeff.shape[0]
if isinstance(m_f.mo_energy, tuple):
orbs_energy = m_f.mo_energy[0]
orbs_energy_b = m_f.mo_energy[1]
else:
# See PYSCF 1.6.2 comment above - this was similarly changed
if len(m_f.mo_energy.shape) > 1:
orbs_energy = m_f.mo_energy[0]
orbs_energy_b = m_f.mo_energy[1]
else:
orbs_energy = m_f.mo_energy
orbs_energy_b = None
if logger.isEnabledFor(logging.DEBUG):
# Add some more to PySCF output...
# First analyze() which prints extra information about MO energy and occupation
mol.stdout.write("\n")
m_f.analyze()
# Now labelled orbitals for contributions to the MOs for s,p,d etc of each atom
mol.stdout.write("\n\n--- Alpha Molecular Orbitals ---\n\n")
dump_mat.dump_mo(mol, mo_coeff, digits=7, start=1)
if mo_coeff_b is not None:
mol.stdout.write("\n--- Beta Molecular Orbitals ---\n\n")
dump_mat.dump_mo(mol, mo_coeff_b, digits=7, start=1)
mol.stdout.flush()
hij = m_f.get_hcore()
mohij = np.dot(np.dot(mo_coeff.T, hij), mo_coeff)
mohij_b = None
if mo_coeff_b is not None:
mohij_b = np.dot(np.dot(mo_coeff_b.T, hij), mo_coeff_b)
eri = mol.intor("int2e", aosym=1)
mo_eri = ao2mo.incore.full(m_f._eri, mo_coeff, compact=False)
mohijkl = mo_eri.reshape(norbs, norbs, norbs, norbs)
mohijkl_bb = None
mohijkl_ba = None
if mo_coeff_b is not None:
mo_eri_b = ao2mo.incore.full(m_f._eri, mo_coeff_b, compact=False)
mohijkl_bb = mo_eri_b.reshape(norbs, norbs, norbs, norbs)
mo_eri_ba = ao2mo.incore.general(
m_f._eri, (mo_coeff_b, mo_coeff_b, mo_coeff, mo_coeff), compact=False
)
mohijkl_ba = mo_eri_ba.reshape(norbs, norbs, norbs, norbs)
# dipole integrals
mol.set_common_orig((0, 0, 0))
ao_dip = mol.intor_symmetric("int1e_r", comp=3)
x_dip_ints = ao_dip[0]
y_dip_ints = ao_dip[1]
z_dip_ints = ao_dip[2]
d_m = m_f.make_rdm1(m_f.mo_coeff, m_f.mo_occ)
if not (isinstance(d_m, np.ndarray) and d_m.ndim == 2):
d_m = d_m[0] + d_m[1]
elec_dip = np.negative(np.einsum("xij,ji->x", ao_dip, d_m).real)
elec_dip = np.round(elec_dip, decimals=8)
nucl_dip = np.einsum("i,ix->x", mol.atom_charges(), mol.atom_coords())
nucl_dip = np.round(nucl_dip, decimals=8)
logger.info("HF Electronic dipole moment: %s", elec_dip)
logger.info("Nuclear dipole moment: %s", nucl_dip)
logger.info("Total dipole moment: %s", nucl_dip + elec_dip)
# Create driver level molecule object and populate
_q_ = QMolecule()
_q_.origin_driver_version = pyscf_version
# Energies and orbits
_q_.hf_energy = ehf
_q_.nuclear_repulsion_energy = enuke
_q_.num_molecular_orbitals = norbs
_q_.num_alpha = mol.nelec[0]
_q_.num_beta = mol.nelec[1]
_q_.mo_coeff = mo_coeff
_q_.mo_coeff_b = mo_coeff_b
_q_.orbital_energies = orbs_energy
_q_.orbital_energies_b = orbs_energy_b
_q_.mo_occ = mo_occ
_q_.mo_occ_b = mo_occ_b
# Molecule geometry
_q_.molecular_charge = mol.charge
_q_.multiplicity = mol.spin + 1
_q_.num_atoms = mol.natm
_q_.atom_symbol = []
_q_.atom_xyz = np.empty([mol.natm, 3])
_ = mol.atom_coords()
for n_i in range(0, _q_.num_atoms):
xyz = mol.atom_coord(n_i)
_q_.atom_symbol.append(mol.atom_pure_symbol(n_i))
_q_.atom_xyz[n_i][0] = xyz[0]
_q_.atom_xyz[n_i][1] = xyz[1]
_q_.atom_xyz[n_i][2] = xyz[2]
# 1 and 2 electron integrals AO and MO
_q_.hcore = hij
_q_.hcore_b = None
_q_.kinetic = mol.intor_symmetric("int1e_kin")
_q_.overlap = m_f.get_ovlp()
_q_.eri = eri
_q_.mo_onee_ints = mohij
_q_.mo_onee_ints_b = mohij_b
_q_.mo_eri_ints = mohijkl
_q_.mo_eri_ints_bb = mohijkl_bb
_q_.mo_eri_ints_ba = mohijkl_ba
# dipole integrals AO and MO
_q_.x_dip_ints = x_dip_ints
_q_.y_dip_ints = y_dip_ints
_q_.z_dip_ints = z_dip_ints
_q_.x_dip_mo_ints = QMolecule.oneeints2mo(x_dip_ints, mo_coeff)
_q_.x_dip_mo_ints_b = None
_q_.y_dip_mo_ints = QMolecule.oneeints2mo(y_dip_ints, mo_coeff)
_q_.y_dip_mo_ints_b = None
_q_.z_dip_mo_ints = QMolecule.oneeints2mo(z_dip_ints, mo_coeff)
_q_.z_dip_mo_ints_b = None
if mo_coeff_b is not None:
_q_.x_dip_mo_ints_b = QMolecule.oneeints2mo(x_dip_ints, mo_coeff_b)
_q_.y_dip_mo_ints_b = QMolecule.oneeints2mo(y_dip_ints, mo_coeff_b)
_q_.z_dip_mo_ints_b = QMolecule.oneeints2mo(z_dip_ints, mo_coeff_b)
# dipole moment
_q_.nuclear_dipole_moment = nucl_dip
_q_.reverse_dipole_sign = True
return _q_
mo[:,nocca:nmo], mo[:,nmo+noccb:]])
else:
log.note('UHF/UKS wavefunction is stable in the UHF/UKS -> GHF/GKS stability analysis')
return mo
if __name__ == '__main__':
from pyscf import gto, scf, dft
mol = gto.M(atom='O 0 0 0; O 0 0 1.2222', basis='631g*')
mf = scf.RHF(mol).run()
rhf_stability(mf, True, True, verbose=4)
mf = dft.RKS(mol).run(level_shift=.2)
rhf_stability(mf, True, True, verbose=4)
mf = scf.UHF(mol).run()
mo1 = uhf_stability(mf, True, True, verbose=4)[0]
mf = scf.newton(mf).run(mo1, mf.mo_occ)
uhf_stability(mf, True, False, verbose=4)
mf = scf.newton(scf.UHF(mol)).run()
uhf_stability(mf, True, False, verbose=4)
mol.spin = 2
mf = scf.UHF(mol).run()
uhf_stability(mf, True, True, verbose=4)
mf = dft.UKS(mol).run()
uhf_stability(mf, True, True, verbose=4)
mol = gto.M(atom='''
def test_nr_uhf(self):
mf = scf.UHF(h2o_n)
mf.conv_tol = 1e-14
mf.kernel()
g = grad.UHF(mf)
self.assertAlmostEqual(lib.finger(g.grad_elec()), 4.2250348208172541, 6)
from pyscf import scf
from pyscf import ao2mo
mol = gto.Mole()
mol.verbose = 0
mol.atom = [
['O', (0., 0., 0.)],
['H', (0., -0.757, 0.587)],
['H', (0., 0.757, 0.587)],
]
mol.basis = {
'H': 'sto-3g',
'O': 'sto-3g',
}
mol.build()
mf = scf.UHF(mol).run(conv_tol=1e-14)
gmf = scf.addons.convert_to_ghf(mf)
myci = GCISD(gmf)
eris = myci.ao2mo()
ecisd, civec = myci.kernel(eris=eris)
print(ecisd - -0.048878084082066106)
nmo = eris.mo_coeff.shape[1]
rdm1 = myci.make_rdm1(civec, nmo, mol.nelectron)
rdm2 = myci.make_rdm2(civec, nmo, mol.nelectron)
mo = eris.mo_coeff[:7] + eris.mo_coeff[7:]
eri = ao2mo.kernel(mf._eri, mo, compact=False).reshape([nmo] * 4)
eri[eris.orbspin[:, None] != eris.orbspin, :, :] = 0
eri[:, :, eris.orbspin[:, None] != eris.orbspin] = 0
h1a = reduce(numpy.dot, (mf.mo_coeff[0].T, mf.get_hcore(), mf.mo_coeff[0]))
make_h1 = make_h1
#TODO: Insert into DF class
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [[1, (1., 0., 0.000)], [1, (0., 1., 0.000)],
[1, (0., -1.517, 1.177)], [1, (0., 1.517, 1.177)]]
mol.basis = '631g'
mol.spin = 2
mol.unit = 'B'
mol.build()
mf = scf.UHF(mol).density_fit()
mf.conv_tol = 1e-14
mf.scf()
n3 = mol.natm * 3
hobj = Hessian(mf)
e2 = hobj.kernel()
ref = scf.UHF(mol).run().Hessian().kernel()
print(abs(e2 - ref).max())
print(lib.finger(e2) - -0.23856667321975722)
e2 = hobj.set(auxbasis_response=2).kernel()
print(abs(e2 - ref).max())
print(lib.finger(e2), -0.72321237584876141)
# symmetry.
#
mf1 = scf.RHF(mol).newton()
dm = mf1.from_chk('cr_atom.chk')
mf1.kernel(dm)
#
# UHF is another way to produce initial guess
#
charge = 0
spin = 6
mol.basis = 'aug-cc-pvdz'
mol.build(False,False)
mf = scf.UHF(mol)
mf.irrep_nelec = {'Ag': (6,3), 'B1g': (1,0), 'B2g': (1,0), 'B3g': (1,0)}
mf.kernel()
dm1 = mf.make_rdm1()
mf = scf.ROHF(mol)
mf.irrep_nelec = {'Ag': (6,3), 'B1g': (1,0), 'B2g': (1,0), 'B3g': (1,0)}
mf.kernel(dm1)
#
# The third way to force the calculation strictly following the correct
# configurations is the second order SCF optimizaiton. In the following code,
# we call a calculation on cation for a correct HF configuration with spherical
# symmetry. This HF configuration is next pass to second order SCF solver
# (.newton method) to solve X2C-ROHF model of the open shell atom.
nmo = mol.nao_nr()
m = newton(scf.RHF(mol))
e0 = m.kernel()
#####################################
mol.basis = '6-31g'
mol.spin = 2
mol.build(0, 0)
m = scf.RHF(mol)
m.max_cycle = 1
#m.verbose = 5
m.scf()
e1 = kernel(newton(m), m.mo_coeff, m.mo_occ, max_cycle=50, verbose=5)[1]
m = scf.UHF(mol)
m.max_cycle = 1
#m.verbose = 5
m.scf()
e2 = kernel(newton(m), m.mo_coeff, m.mo_occ, max_cycle=50, verbose=5)[1]
m = scf.UHF(mol)
m.max_cycle = 1
#m.verbose = 5
m.scf()
nrmf = scf.density_fit(newton(m), 'weigend')
nrmf.max_cycle = 50
nrmf.conv_tol = 1e-8
nrmf.conv_tol_grad = 1e-5
#nrmf.verbose = 5
e4 = nrmf.kernel()
from pyscf import gto
from pyscf import scf
from pyscf import dft
from pyscf import fci
from pyscf import mcscf
b = 1.4
mol = gto.M(
verbose=7,
output='/dev/null',
atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]],
basis='631g',
spin=2,
)
m = scf.UHF(mol)
m.conv_tol = 1e-10
m.scf()
mc = mcscf.UCASCI(m, 5, (4, 2)).run()
b = 1.4
molsym = gto.M(
verbose=7,
output='/dev/null',
atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]],
basis='631g',
spin=2,
symmetry=True,
)
msym = scf.UHF(molsym)
def automatic_guessing(ase_nuclei,charge,spin,basis,xc,method='FB',ecp=None,newton=True,grid=3,BS=None,calc='UKS',symmetry=False):
# ase_nuclei_atoms ... ase.atoms.object containg only nuclei positions
# charge ... charge of the system
# spin ... spin state of the system
# basis ... basis set
# xc ... exchange-correlation functional
# method ... localization method (FB, ER, PM etc.)
# Note: FB seems to give very reasonable guesses.
# ecp ... effective core potential file
# newton ... second order Newton Raphston scf solver works for LDA and GGA not for SCAN
# grid ... grid level
# BS ... broken symmetry
# calc ,,, UKS or UHF
# Performe a DFT calculation.
ase_atoms = ase_nuclei
if ecp is None:
mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,spin=spin,charge=charge,symmetry=symmetry)
if ecp is not None:
mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,ecp=ecp,spin=spin,charge=charge,symmetry=symmetry)
mol.verbose = 4
if calc == 'UKS':
mf = scf.UKS(mol)
if calc == 'UHF':
mf = scf.UHF(mol)
if calc == 'RHF':
mf = scf.RHF(mol)
mf.grids.level = grid
mf.max_cycle = 3000
mf.xc = xc
# Broken symmetry
if BS != None:
mf.kernel()
idx_flip = mol.search_ao_label(BS)
dma, dmb = mf.make_rdm1()
dma_flip = dma[idx_flip.reshape(-1,1),idx_flip].copy()
dmb_flip= dmb[idx_flip.reshape(-1,1),idx_flip].copy()
dma[idx_flip.reshape(-1,1),idx_flip] = dmb_flip
dmb[idx_flip.reshape(-1,1),idx_flip] = dma_flip
dm = [dma, dmb]
if ecp is None:
mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,spin=0,charge=charge,symmetry=symmetry)
if ecp is not None:
mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,ecp=ecp,spin=0,charge=charge,symmetry=symmetry)
mol.verbose = 4
mf = scf.UKS(mol)
mf.grids.level = grid
mf.max_cycle = 3000
mf.xc = xc
if newton == True:
mf = mf.as_scanner()
mf = mf.newton()
if BS == None:
mf.kernel()
if BS != None:
mf.run(dm)
if calc == 'RHF':
mf = scf.addons.convert_to_uhf(mf)
# Performe a localization calculation.
# Both spin channels are localized separately.
# The orbitals are written out as cube files.
calc_localized_orbitals(mf,mol,method=method)
# Collect all cube files per spin channel.
f1 = glob.glob('*orb*spin1.cube')
f2 = glob.glob('*orb*spin2.cube')
# test for nuclei positions
# for ASE Version: 3.15.1b1
# we neede the file handle and not the string
# new:
f_cube = open(f1[0])
ase_atoms = cube.read_cube(f_cube)
# previous: ase_atoms = cube.read_cube(f1[0])
f_cube.close()
# Calculate the guess.
get_guess(atoms=ase_atoms,spin1_cube=f1,spin2_cube=f2,method=method)
nmo = mol.nao_nr()
m = newton(scf.RHF(mol))
e0 = m.kernel()
#####################################
mol.basis = '6-31g'
mol.spin = 2
mol.build(0, 0)
m = scf.RHF(mol)
m.max_cycle = 1
#m.verbose = 5
m.scf()
e1 = kernel(newton(m), m.mo_coeff, m.mo_occ, max_cycle=50, verbose=5)[1]
m = scf.UHF(mol)
m.max_cycle = 1
#m.verbose = 5
m.scf()
e2 = kernel(newton(m), m.mo_coeff, m.mo_occ, max_cycle=50, verbose=5)[1]
m = scf.UHF(mol)
m.max_cycle = 1
#m.verbose = 5
m.scf()
nrmf = scf.density_fit(newton(m))
nrmf.max_cycle = 50
nrmf.conv_tol = 1e-8
nrmf.conv_tol_grad = 1e-5
#nrmf.verbose = 5
e4 = nrmf.kernel()
def kernel(gw,
mo_energy,
mo_coeff,
Lpq=None,
orbs=None,
nw=None,
vhf_df=False,
verbose=logger.NOTE):
'''
GW-corrected quasiparticle orbital energies
Returns:
A list : converged, mo_energy, mo_coeff
'''
mf = gw._scf
mol = gw.mol
if gw.frozen is None:
frozen = 0
else:
frozen = gw.frozen
# only support frozen core
assert (isinstance(frozen, int))
nocca, noccb = gw.nocc
nmoa, nmob = gw.nmo
assert (frozen < nocca and frozen < noccb)
if Lpq is None:
Lpq = gw.ao2mo(mo_coeff)
if orbs is None:
orbs = range(nmoa)
else:
orbs = [x - frozen for x in orbs]
if orbs[0] < 0:
logger.warn(gw, 'GW orbs must be larger than frozen core!')
raise RuntimeError
# v_xc
v_mf = mf.get_veff()
vj = mf.get_j()
v_mf[0] = v_mf[0] - (vj[0] + vj[1])
v_mf[1] = v_mf[1] - (vj[0] + vj[1])
v_mf_frz = np.zeros((2, nmoa - frozen, nmob - frozen))
for s in range(2):
v_mf_frz[s] = reduce(numpy.dot, (mo_coeff[s].T, v_mf[s], mo_coeff[s]))
v_mf = v_mf_frz
# v_hf from DFT/HF density
if vhf_df and frozen == 0:
# density fitting vk
vk = np.zeros_like(v_mf)
vk[0] = -einsum('Lni,Lim->nm', Lpq[0, :, :, :nocca],
Lpq[0, :, :nocca, :])
vk[1] = -einsum('Lni,Lim->nm', Lpq[1, :, :, :noccb],
Lpq[1, :, :noccb, :])
else:
# exact vk without density fitting
dm = mf.make_rdm1()
uhf = scf.UHF(mol)
vk = uhf.get_veff(mol, dm)
vj = uhf.get_j(mol, dm)
vk[0] = vk[0] - (vj[0] + vj[1])
vk[1] = vk[1] - (vj[0] + vj[1])
vk_frz = np.zeros((2, nmoa - frozen, nmob - frozen))
for s in range(2):
vk_frz[s] = reduce(numpy.dot, (mo_coeff[s].T, vk[s], mo_coeff[s]))
vk = vk_frz
# Grids for integration on imaginary axis
freqs, wts = _get_scaled_legendre_roots(nw)
# Compute self-energy on imaginary axis i*[0,iw_cutoff]
sigmaI, omega = get_sigma_diag(gw, orbs, Lpq, freqs, wts, iw_cutoff=5.)
# Analytic continuation
if gw.ac == 'twopole':
coeff_a = AC_twopole_diag(sigmaI[0], omega[0], orbs, nocca)
coeff_b = AC_twopole_diag(sigmaI[1], omega[1], orbs, noccb)
elif gw.ac == 'pade':
coeff_a, omega_fit_a = AC_pade_thiele_diag(sigmaI[0], omega[0])
coeff_b, omega_fit_b = AC_pade_thiele_diag(sigmaI[1], omega[1])
omega_fit = np.asarray((omega_fit_a, omega_fit_b))
coeff = np.asarray((coeff_a, coeff_b))
conv = True
h**o = max(mo_energy[0][nocca - 1], mo_energy[1][noccb - 1])
lumo = min(mo_energy[0][nocca], mo_energy[1][noccb])
ef = (h**o + lumo) / 2.
mf_mo_energy = mo_energy.copy()
mo_energy = np.zeros_like(np.asarray(gw._scf.mo_energy))
for s in range(2):
for p in orbs:
if gw.linearized:
# linearized G0W0
de = 1e-6
ep = mf_mo_energy[s][p]
#TODO: analytic sigma derivative
if gw.ac == 'twopole':
sigmaR = two_pole(ep - ef, coeff[s, :, p - orbs[0]]).real
dsigma = two_pole(ep - ef + de,
coeff[s, :,
p - orbs[0]]).real - sigmaR.real
elif gw.ac == 'pade':
sigmaR = pade_thiele(ep - ef, omega_fit[s, p - orbs[0]],
coeff[s, :, p - orbs[0]]).real
dsigma = pade_thiele(
ep - ef + de, omega_fit[s, p - orbs[0]],
coeff[s, :, p - orbs[0]]).real - sigmaR.real
zn = 1.0 / (1.0 - dsigma / de)
e = ep + zn * (sigmaR.real + vk[s, p, p] - v_mf[s, p, p])
mo_energy[s, p + frozen] = e
else:
# self-consistently solve QP equation
def quasiparticle(omega):
if gw.ac == 'twopole':
sigmaR = two_pole(omega - ef, coeff[s, :,
p - orbs[0]]).real
elif gw.ac == 'pade':
sigmaR = pade_thiele(omega - ef,
omega_fit[s, p - orbs[0]],
coeff[s, :, p - orbs[0]]).real
return omega - mf_mo_energy[s][p] - (
sigmaR.real + vk[s, p, p] - v_mf[s, p, p])
try:
e = newton(quasiparticle,
mf_mo_energy[s][p],
tol=1e-6,
maxiter=100)
mo_energy[s, p + frozen] = e
except RuntimeError:
conv = False
mo_coeff = gw._scf.mo_coeff
if gw.verbose >= logger.DEBUG:
numpy.set_printoptions(threshold=nmoa)
logger.debug(gw, ' GW mo_energy spin-up =\n%s', mo_energy[0])
logger.debug(gw, ' GW mo_energy spin-down =\n%s', mo_energy[1])
numpy.set_printoptions(threshold=1000)
return conv, mo_energy, mo_coeff
def test():
""" Ensure that DMC obtains the exact result for a hydrogen atom """
from pyscf import gto, scf
from pyqmc.jastrowspin import JastrowSpin
from pyqmc.dmc import limdrift, rundmc
from pyqmc.mc import vmc
from pyqmc.accumulators import EnergyAccumulator
from pyqmc.func3d import CutoffCuspFunction
from pyqmc.multiplywf import MultiplyWF
from pyqmc.coord import OpenConfigs
from pyqmc import Slater
import pandas as pd
mol = gto.M(atom="H 0. 0. 0.", basis="sto-3g", unit="bohr", spin=1)
mf = scf.UHF(mol).run()
nconf = 1000
configs = OpenConfigs(np.random.randn(nconf, 1, 3))
wf1 = Slater(mol, mf)
wf = wf1
wf2 = JastrowSpin(mol, a_basis=[CutoffCuspFunction(5, 0.2)], b_basis=[])
wf2.parameters["acoeff"] = np.asarray([[[1.0, 0]]])
wf = MultiplyWF(wf1, wf2)
dfvmc, configs_ = vmc(wf,
configs,
nsteps=50,
accumulators={"energy": EnergyAccumulator(mol)})
dfvmc = pd.DataFrame(dfvmc)
print(
"vmc energy",
np.mean(dfvmc["energytotal"]),
np.std(dfvmc["energytotal"]) / np.sqrt(len(dfvmc)),
)
warmup = 200
branchtime = 5
dfdmc, configs_, weights_ = rundmc(
wf,
configs,
nsteps=4000 + warmup * branchtime,
branchtime=branchtime,
accumulators={"energy": EnergyAccumulator(mol)},
ekey=("energy", "total"),
tstep=0.01,
drift_limiter=limdrift,
verbose=True,
)
dfdmc = pd.DataFrame(dfdmc)
dfdmc.sort_values("step", inplace=True)
dfprod = dfdmc[dfdmc.step >= warmup]
rb_summary = reblock.reblock_summary(dfprod[["energytotal", "energyei"]],
20)
print(rb_summary)
energy, err = [
rb_summary[v]["energytotal"] for v in ("mean", "standard error")
]
assert (np.abs(energy + 0.5) <
5 * err), "energy not within {0} of -0.5: energy {1}".format(
5 * err, np.mean(energy))
from pyscf.grad import tduhf as tduhf_grad
mol = gto.Mole()
mol.verbose = 5
mol.output = '/dev/null'
mol.atom = [
['H', (0., 0., 1.804)],
['F', (0., 0., 0.)],
]
mol.unit = 'B'
mol.charge = 2
mol.spin = 2
mol.basis = '631g'
mol.build()
pmol = mol.copy()
mf = scf.UHF(mol).set(conv_tol=1e-12).run()
def tearDownModule():
global mol, pmol, mf
mol.stdout.close()
del mol, pmol, mf
class KnownValues(unittest.TestCase):
def test_tda(self):
td = tdscf.TDA(mf).run(nstates=3)
tdg = td.nuc_grad_method()
g1 = tdg.kernel(state=3)
self.assertAlmostEqual(g1[0, 2], -0.78246882668628404, 7)
