def test():
mol = gto.M(atom="Li 0. 0. 0.; Li 0. 0. 1.5",
basis="sto-3g",
unit="bohr",
verbose=0)
mf = scf.RHF(mol).run()
# Lowdin orthogonalized AO basis.
lowdin = lo.orth_ao(mol, "lowdin")
# MOs in the Lowdin basis.
mo = solve(lowdin, mf.mo_coeff)
# make AO to localized orbital coefficients.
mfobdm = mf.make_rdm1(mo, mf.mo_occ)
### Test OBDM calculation.
nconf = 500
nsteps = 400
obdm_steps = 4
warmup = 15
wf = PySCFSlaterUHF(mol, mf)
configs = initial_guess(mol, nconf)
energy = EnergyAccumulator(mol)
obdm = OBDMAccumulator(mol=mol, orb_coeff=lowdin, nsweeps=1)
obdm_up = OBDMAccumulator(mol=mol, orb_coeff=lowdin, nsweeps=1, spin=0)
obdm_down = OBDMAccumulator(mol=mol, orb_coeff=lowdin, nsweeps=1, spin=1)
df, coords = vmc(
wf,
configs,
nsteps=nsteps,
accumulators={
"energy": energy,
"obdm": obdm,
"obdm_up": obdm_up,
"obdm_down": obdm_down,
},
)
df = DataFrame(df)
obdm_est = {}
for k in ["obdm", "obdm_up", "obdm_down"]:
avg_norm = np.array(df.loc[warmup:,
k + "norm"].values.tolist()).mean(axis=0)
avg_obdm = np.array(df.loc[warmup:,
k + "value"].values.tolist()).mean(axis=0)
obdm_est[k] = normalize_obdm(avg_obdm, avg_norm)
print("Average OBDM(orb,orb)", obdm_est["obdm"].diagonal().round(3))
print("mf obdm", mfobdm.diagonal().round(3))
assert np.max(np.abs(obdm_est["obdm"] - mfobdm)) < 0.05
print(obdm_est["obdm_up"].diagonal().round(3))
print(obdm_est["obdm_down"].diagonal().round(3))
assert np.mean(
np.abs(obdm_est["obdm_up"] + obdm_est["obdm_down"] - mfobdm)) < 0.05
def test_pbc(li_cubic_ccecp):
from pyqmc import supercell
import scipy
mol, mf = li_cubic_ccecp
# S = np.ones((3, 3)) - np.eye(3)
S = np.identity(3)
mol = supercell.get_supercell(mol, S)
kpts = supercell.get_supercell_kpts(mol)[:2]
kdiffs = mf.kpts[np.newaxis] - kpts[:, np.newaxis]
kinds = np.nonzero(np.linalg.norm(kdiffs, axis=-1) < 1e-12)[1]
# Lowdin orthogonalized AO basis.
# lowdin = lo.orth_ao(mol, "lowdin")
loiao = lo.iao.iao(mol.original_cell, mf.mo_coeff, kpts=kpts)
occs = [mf.mo_occ[k] for k in kinds]
coefs = [mf.mo_coeff[k] for k in kinds]
ovlp = mf.get_ovlp()[kinds]
lowdin = [lo.vec_lowdin(l, o) for l, o in zip(loiao, ovlp)]
lreps = [np.linalg.multi_dot([l.T, o, c]) for l, o, c in zip(lowdin, ovlp, coefs)]
# make AO to localized orbital coefficients.
mfobdm = [np.einsum("ij,j,kj->ik", l.conj(), o, l) for l, o in zip(lreps, occs)]
### Test OBDM calculation.
nconf = 500
nsteps = 100
warmup = 6
wf = Slater(mol, mf)
configs = initial_guess(mol, nconf)
obdm_dict = dict(mol=mol, orb_coeff=lowdin, kpts=kpts, nsweeps=4, warmup=10)
obdm = OBDMAccumulator(**obdm_dict)
df, coords = vmc(
wf,
configs,
nsteps=nsteps,
accumulators={"obdm": obdm}, # , "obdm_up": obdm_up, "obdm_down": obdm_down},
verbose=True,
)
obdm_est = {}
for k in ["obdm"]: # , "obdm_up", "obdm_down"]:
avg_norm = np.mean(df[k + "norm"][warmup:], axis=0)
avg_obdm = np.mean(df[k + "value"][warmup:], axis=0)
obdm_est[k] = normalize_obdm(avg_obdm, avg_norm)
mfobdm = scipy.linalg.block_diag(*mfobdm)
mae = np.mean(np.abs(obdm_est["obdm"] - mfobdm))
assert mae < 0.05, f"mae {mae}"
def test():
mol = gto.M(atom="Li 0. 0. 0.; Li 0. 0. 1.5",
basis="sto-3g",
unit="bohr",
verbose=0)
mf = scf.RHF(mol).run()
# Lowdin orthogonalized AO basis.
lowdin = lo.orth_ao(mol, "lowdin")
# MOs in the Lowdin basis.
mo = solve(lowdin, mf.mo_coeff)
# make AO to localized orbital coefficients.
mfobdm = mf.make_rdm1(mo, mf.mo_occ)
### Test OBDM calculation.
nconf = 500
nsteps = 400
warmup = 15
wf = Slater(mol, mf)
configs = initial_guess(mol, nconf)
obdm_dict = dict(mol=mol, orb_coeff=lowdin, nsweeps=5, warmup=15)
obdm = OBDMAccumulator(**obdm_dict)
obdm_up = OBDMAccumulator(**obdm_dict, spin=0)
obdm_down = OBDMAccumulator(**obdm_dict, spin=1)
df, coords = vmc(
wf,
configs,
nsteps=nsteps,
accumulators={
"obdm": obdm,
"obdm_up": obdm_up,
"obdm_down": obdm_down
},
)
obdm_est = {}
for k in ["obdm", "obdm_up", "obdm_down"]:
avg_norm = np.mean(df[k + "norm"][warmup:], axis=0)
avg_obdm = np.mean(df[k + "value"][warmup:], axis=0)
obdm_est[k] = normalize_obdm(avg_obdm, avg_norm)
assert np.mean(
np.abs(obdm_est["obdm_up"] + obdm_est["obdm_down"] - mfobdm)) < 0.05
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 test_pbc():
from pyscf.pbc import gto, scf
from pyqmc import PySCFSlaterUHF, PySCFSlaterPBC
from pyqmc import slaterpbc
import scipy
lvecs = (np.ones((3, 3)) - np.eye(3)) * 2.0
mol = gto.M(
atom="H 0. 0. -{0}; H 0. 0. {0}".format(0.7),
basis="sto-3g",
unit="bohr",
verbose=0,
a=lvecs,
)
mf = scf.KRHF(mol, kpts=mol.make_kpts((2, 2, 2)))
mf = mf.run()
S = np.ones((3, 3)) - 2 * np.eye(3)
mol = slaterpbc.get_supercell(mol, S)
kpts = slaterpbc.get_supercell_kpts(mol)[:2]
kdiffs = mf.kpts[np.newaxis] - kpts[:, np.newaxis]
kinds = np.nonzero(np.linalg.norm(kdiffs, axis=-1) < 1e-12)[1]
# Lowdin orthogonalized AO basis.
# lowdin = lo.orth_ao(mol, "lowdin")
loiao = lo.iao.iao(mol.original_cell, mf.mo_coeff, kpts=kpts)
occs = [mf.mo_occ[k] for k in kinds]
coefs = [mf.mo_coeff[k] for k in kinds]
ovlp = mf.get_ovlp()[kinds]
lowdin = [lo.vec_lowdin(l, o) for l, o in zip(loiao, ovlp)]
lreps = [np.linalg.multi_dot([l.T, o, c]) for l, o, c in zip(lowdin, ovlp, coefs)]
# make AO to localized orbital coefficients.
mfobdm = [np.einsum("ij,j,kj->ik", l.conj(), o, l) for l, o in zip(lreps, occs)]
### Test OBDM calculation.
nconf = 800
nsteps = 50
warmup = 6
wf = PySCFSlaterPBC(mol, mf)
configs = initial_guess(mol, nconf)
obdm_dict = dict(mol=mol, orb_coeff=lowdin, kpts=kpts, nsweeps=4, warmup=10)
obdm = OBDMAccumulator(**obdm_dict)
obdm_up = OBDMAccumulator(**obdm_dict, spin=0)
obdm_down = OBDMAccumulator(**obdm_dict, spin=1)
df, coords = vmc(
wf,
configs,
nsteps=nsteps,
accumulators={"obdm": obdm, "obdm_up": obdm_up, "obdm_down": obdm_down},
verbose=True,
)
df = DataFrame(df)
obdm_est = {}
for k in ["obdm", "obdm_up", "obdm_down"]:
avg_norm = np.array(df.loc[warmup:, k + "norm"].values.tolist()).mean(axis=0)
avg_obdm = np.array(df.loc[warmup:, k + "value"].values.tolist()).mean(axis=0)
obdm_est[k] = normalize_obdm(avg_obdm, avg_norm)
print("Average OBDM(orb,orb)", obdm_est["obdm"].round(3))
mfobdm = scipy.linalg.block_diag(*mfobdm)
print("mf obdm", mfobdm.round(3))
max_abs_err = np.max(np.abs(obdm_est["obdm"] - mfobdm))
assert max_abs_err < 0.05, "max abs err {0}".format(max_abs_err)
print(obdm_est["obdm_up"].diagonal().round(3))
print(obdm_est["obdm_down"].diagonal().round(3))
mae = np.mean(np.abs(obdm_est["obdm_up"] + obdm_est["obdm_down"] - mfobdm))
maup = np.mean(np.abs(obdm_est["obdm_up"]))
madn = np.mean(np.abs(obdm_est["obdm_down"]))
mamf = np.mean(np.abs(mfobdm))
assert mae < 0.05, "mae {0}\n maup {1}\n madn {2}\n mamf {3}".format(
mae, maup, madn, mamf
)
