def test_info_functions_mol(LiH_sto3g_rhf):
mol, mf = LiH_sto3g_rhf
wf, to_opt = pyq.generate_wf(mol, mf)
accumulators = {
"pgrad": pyq.gradient_generator(mol, wf, to_opt),
"obdm": OBDMAccumulator(mol, orb_coeff=mf.mo_coeff),
"tbdm_updown": TBDMAccumulator(mol, np.asarray([mf.mo_coeff] * 2), (0, 1)),
}
info_functions(mol, wf, accumulators)
def find_basis_evaluate(mfchk, hdf_opt, hdf_vmc, hdf_final):
"""Given a wave function in hdf_opt, compute the 1-RDM (stored in hdf_vmc) , generate a minimal atomic basis and compute the energy/OBDM/TBDM and store in hdf_final """
from pyqmc.obdm import OBDMAccumulator
from pyqmc.tbdm import TBDMAccumulator
from pyqmc import EnergyAccumulator
sys = pyqmc_from_hdf(mfchk)
mol = sys["mol"]
a = lo.orth_ao(mol, "lowdin")
obdm_up = OBDMAccumulator(mol=mol, orb_coeff=a, spin=0)
obdm_down = OBDMAccumulator(mol=mol, orb_coeff=a, spin=1)
with h5py.File(hdf_opt, "r") as hdf_in:
if f"wf" in hdf_in.keys():
print("reading in wave function")
grp = hdf_in[f"wf"]
for k in grp.keys():
sys["wf"].parameters[k] = np.array(grp[k])
configs = pyqmc.initial_guess(sys["mol"], 1000)
pyqmc.vmc(
sys["wf"],
configs,
nsteps=500,
hdf_file=hdf_vmc,
accumulators={
"obdm_up": obdm_up,
"obdm_down": obdm_down
},
)
with h5py.File(hdf_vmc, "r") as vmc_hdf:
obdm_up = np.mean(np.array(vmc_hdf["obdm_upvalue"]), axis=0)
obdm_down = np.mean(np.array(vmc_hdf["obdm_downvalue"]), axis=0)
basis_up = gen_basis(mol, sys["mf"], obdm_up)
basis_down = gen_basis(mol, sys["mf"], obdm_down)
obdm_up_acc = OBDMAccumulator(mol=mol, orb_coeff=basis_up, spin=0)
obdm_down_acc = OBDMAccumulator(mol=mol, orb_coeff=basis_down, spin=1)
tbdm = TBDMAccumulator(mol, np.array([basis_up, basis_down]), spin=(0, 1))
acc = {
"energy": EnergyAccumulator(mol),
"obdm_up": obdm_up_acc,
"obdm_down": obdm_down_acc,
"tbdm": tbdm,
}
configs = pyqmc.initial_guess(sys["mol"], 1000)
pyqmc.vmc(sys["wf"],
configs,
nsteps=500,
hdf_file=hdf_final,
accumulators=acc)
def test_info_functions_mol():
from pyscf import gto, scf
from pyqmc.tbdm import TBDMAccumulator
mol = gto.Mole()
mol.atom = """He 0.00 0.00 0.00 """
mol.basis = "ccpvdz"
mol.build()
mf = scf.RHF(mol)
ehf = mf.kernel()
wf, to_opt = pyqmc.default_sj(mol, mf)
accumulators = {
"pgrad": pyqmc.gradient_generator(mol, wf, to_opt),
"obdm": OBDMAccumulator(mol, orb_coeff=mf.mo_coeff),
"tbdm_updown": TBDMAccumulator(mol, np.asarray([mf.mo_coeff] * 2),
(0, 1)),
}
info_functions(mol, wf, accumulators)
def test(atom="He", total_spin=0, total_charge=0, scf_basis="sto-3g"):
mol = gto.M(
atom="%s 0. 0. 0.; %s 0. 0. 1.5" % (atom, atom),
basis=scf_basis,
unit="bohr",
verbose=4,
spin=total_spin,
charge=total_charge,
)
mf = scf.UHF(mol).run()
# Intrinsic Atomic Orbitals
iaos = make_separate_spin_iaos(
mol, mf, np.array([i for i in range(mol.natm)]), iao_basis="minao"
)
# iaos=make_combined_spin_iaos(mol,mf,np.array([i for i in range(mol.natm)]),iao_basis='minao')
# MOs in the IAO basis
mo = reps_combined_spin_iaos(
iaos,
mf,
np.einsum("i,j->ji", np.arange(mf.mo_coeff[0].shape[1]), np.array([1, 1])),
)
# Mean-field obdm in IAO basis
mfobdm = mf.make_rdm1(mo, mf.mo_occ)
# Mean-field tbdm in IAO basis
mftbdm = singledet_tbdm(mf, mfobdm)
### Test TBDM calculation.
# VMC params
nconf = 500
n_vmc_steps = 400
vmc_tstep = 0.3
vmc_warmup = 30
# TBDM params
tbdm_sweeps = 4
tbdm_tstep = 0.5
wf = PySCFSlater(mol, mf) # Single-Slater (no jastrow) wf
configs = initial_guess(mol, nconf)
energy = EnergyAccumulator(mol)
obdm_up = OBDMAccumulator(mol=mol, orb_coeff=iaos[0], nsweeps=tbdm_sweeps, spin=0)
obdm_down = OBDMAccumulator(mol=mol, orb_coeff=iaos[1], nsweeps=tbdm_sweeps, spin=1)
tbdm_upup = TBDMAccumulator(
mol=mol, orb_coeff=iaos, nsweeps=tbdm_sweeps, tstep=tbdm_tstep, spin=(0, 0)
)
tbdm_updown = TBDMAccumulator(
mol=mol, orb_coeff=iaos, nsweeps=tbdm_sweeps, tstep=tbdm_tstep, spin=(0, 1)
)
tbdm_downup = TBDMAccumulator(
mol=mol, orb_coeff=iaos, nsweeps=tbdm_sweeps, tstep=tbdm_tstep, spin=(1, 0)
)
tbdm_downdown = TBDMAccumulator(
mol=mol, orb_coeff=iaos, nsweeps=tbdm_sweeps, tstep=tbdm_tstep, spin=(1, 1)
)
print("VMC...")
df, coords = vmc(
wf,
configs,
nsteps=n_vmc_steps,
tstep=vmc_tstep,
accumulators={
"energy": energy,
"obdm_up": obdm_up,
"obdm_down": obdm_down,
"tbdm_upup": tbdm_upup,
"tbdm_updown": tbdm_updown,
"tbdm_downup": tbdm_downup,
"tbdm_downdown": tbdm_downdown,
},
verbose=True,
)
# Compares obdm from QMC and MF
obdm_est = {}
for k in ["obdm_up", "obdm_down"]:
avg_norm = np.mean(df[k + "norm"][vmc_warmup:], axis=0)
avg_obdm = np.mean(df[k + "value"][vmc_warmup:], axis=0)
obdm_est[k] = normalize_obdm(avg_obdm, avg_norm)
qmcobdm = np.array([obdm_est["obdm_up"], obdm_est["obdm_down"]])
print("\nComparing QMC and MF obdm:")
for s in [0, 1]:
# print('QMC obdm[%d]:\n'%s,qmcobdm[s])
# print('MF obdm[%d]:\n'%s,mfobdm[s])
print("diff[%d]:\n" % s, qmcobdm[s] - mfobdm[s])
# Compares tbdm from QMC and MF
avg_norm = {}
avg_tbdm = {}
tbdm_est = {}
for t in ["tbdm_upup", "tbdm_updown", "tbdm_downup", "tbdm_downdown"]:
for k in df.keys():
if k.startswith(t + "norm_"):
avg_norm[k.split("_")[-1]] = np.mean(df[k][vmc_warmup:], axis=0)
if k.startswith(t + "value"):
avg_tbdm[k.split("_")[-1]] = np.mean(df[k][vmc_warmup:], axis=0)
for k in avg_tbdm:
tbdm_est[k] = normalize_tbdm(
avg_tbdm[k].reshape(2, 2, 2, 2), avg_norm["a"], avg_norm["b"]
)
qmctbdm = np.array(
[
[tbdm_est["upupvalue"], tbdm_est["updownvalue"]],
[tbdm_est["downupvalue"], tbdm_est["downdownvalue"]],
]
)
print("\nComparing QMC and MF tbdm:")
for sa, sb in [[0, 0], [0, 1], [1, 0], [1, 1]]:
# print('QMC tbdm[%d,%d]:\n'%(sa,sb),qmctbdm[sa,sb])
# print('MF tbdm[%d,%d]:\n'%(sa,sb),mftbdm[sa,sb])
diff = qmctbdm[sa, sb] - mftbdm[sa, sb]
print("diff[%d,%d]:\n" % (sa, sb), diff)
assert np.max(np.abs(diff)) < 0.05
def setuph2(r):
from pyscf import gto, scf, lo
from pyqmc.accumulators import LinearTransform, EnergyAccumulator
from pyqmc.obdm import OBDMAccumulator
from pyqmc.tbdm import TBDMAccumulator
from pyqmc.cvmc import DescriptorFromOBDM, DescriptorFromTBDM, PGradDescriptor
import itertools
# ccECP from A. Annaberdiyev et al. Journal of Chemical Physics 149, 134108 (2018)
basis = {
"H": gto.basis.parse(
"""
H S
23.843185 0.00411490
10.212443 0.01046440
4.374164 0.02801110
1.873529 0.07588620
0.802465 0.18210620
0.343709 0.34852140
0.147217 0.37823130
0.063055 0.11642410
"""
)
}
"""
H S
0.040680 1.00000000
H S
0.139013 1.00000000
H P
0.166430 1.00000000
H P
0.740212 1.00000000
"""
ecp = {
"H": gto.basis.parse_ecp(
"""
H nelec 0
H ul
1 21.24359508259891 1.00000000000000
3 21.24359508259891 21.24359508259891
2 21.77696655044365 -10.85192405303825
"""
)
}
mol = gto.M(
atom=f"H 0. 0. 0.; H 0. 0. {r}", unit="bohr", basis=basis, ecp=ecp, verbose=5
)
mf = scf.RHF(mol).run()
wf = pyqmc.slater_jastrow(mol, mf)
freeze = {}
for k in wf.parameters:
freeze[k] = np.zeros(wf.parameters[k].shape,dtype='bool')
print(freeze.keys())
print(wf.parameters['wf1mo_coeff_alpha'])
#this freezing allows us to easily go between bonding and
# AFM configurations.
freeze['wf1mo_coeff_alpha'][0,0]=True
freeze['wf1mo_coeff_beta'][1,0]=True
mo_occ = mf.mo_coeff[:, mf.mo_occ > 0]
a = lo.iao.iao(mol, mo_occ)
a = lo.vec_lowdin(a, mf.get_ovlp())
obdm_up = OBDMAccumulator(mol=mol, orb_coeff=a, spin=0)
obdm_down = OBDMAccumulator(mol=mol, orb_coeff=a, spin=1)
descriptors = {
"t": [[(1.0, (0, 1)), (1.0, (1, 0))], [(1.0, (0, 1)), (1.0, (1, 0))]],
"trace": [[(1.0, (0, 0)), (1.0, (1, 1))], [(1.0, (0, 0)), (1.0, (1, 1))]],
}
for i in [0, 1]:
descriptors[f"nup{i}"] = [[(1.0, (i, i))], []]
descriptors[f"ndown{i}"] = [[], [(1.0, (i, i))]]
tbdm_up_down = TBDMAccumulator(mol=mol, orb_coeff=np.array([a,a]), spin=(0,1), ijkl=[[0,0,0,0]])
tbdm_down_up = TBDMAccumulator(mol=mol, orb_coeff=np.array([a,a]), spin=(1,0), ijkl=[[0,0,0,0]])
descriptors_tbdm = {
"U": [[(1.0,(0))],[(1.0,(0))]]
}
acc = PGradDescriptor(
EnergyAccumulator(mol),
LinearTransform(wf.parameters, freeze=freeze),
{
'obdm': [obdm_up, obdm_down],
'tbdm': [tbdm_up_down, tbdm_down_up],
},
{
'obdm': DescriptorFromOBDM(descriptors, norm=2.0),
'tbdm': DescriptorFromTBDM(descriptors_tbdm, norm=2.0*(2.0-1.0)),
},
)
return {"wf": wf, "acc": acc, "mol": mol, "mf": mf, "descriptors": descriptors, "descriptors_tbdm": descriptors_tbdm}