def test_transform():
""" Just prints things out;
TODO: figure out a thing to test.
"""
from pyscf import gto, scf
r = 1.54 / 0.529177
mol = gto.M(
atom="H 0. 0. 0.; H 0. 0. %g" % r,
ecp="bfd",
basis="bfd_vtz",
unit="bohr",
verbose=1,
)
mf = scf.RHF(mol).run()
wf, to_opt = pyqmc.default_sj(mol, mf)
enacc = pyqmc.EnergyAccumulator(mol)
print(list(wf.parameters.keys()))
transform = LinearTransform(wf.parameters)
x = transform.serialize_parameters(wf.parameters)
nconfig = 10
configs = pyqmc.initial_guess(mol, nconfig)
wf.recompute(configs)
pgrad = wf.pgradient()
gradtrans = transform.serialize_gradients(pgrad)
assert gradtrans.shape[1] == len(x)
assert gradtrans.shape[0] == nconfig
def test():
""" Optimize a Helium atom's wave function and check that it's
better than Hartree-Fock"""
mol = gto.M(atom="He 0. 0. 0.", basis="bfd_vdz", ecp="bfd", unit="bohr")
mf = scf.RHF(mol).run()
wf, to_opt = default_sj(mol, mf)
print(to_opt)
nconf = 500
wf, dfgrad = line_minimization(
wf, initial_guess(mol, nconf), gradient_generator(mol, wf, to_opt)
)
dfgrad = pd.DataFrame(dfgrad)
print(dfgrad)
mfen = mf.energy_tot()
enfinal = dfgrad["energy"].values[-1]
enfinal_err = dfgrad["energy_error"].values[-1]
assert mfen > enfinal
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_info_functions_pbc():
from pyscf.pbc import gto, scf
from pyqmc.supercell import get_supercell
mol = gto.Cell(atom="He 0.00 0.00 0.00", basis="ccpvdz", unit="B")
mol.a = 5.61 * np.eye(3)
mol.build()
mf = scf.KRHF(mol, kpts=mol.make_kpts([2, 2, 2])).density_fit()
ehf = mf.kernel()
supercell = get_supercell(mol, 2 * np.eye(3))
kinds = [0, 1]
dm_orbs = [mf.mo_coeff[i][:, :2] for i in kinds]
wf, to_opt = pyqmc.default_sj(mol, mf)
accumulators = {
"pgrad": pyqmc.gradient_generator(mol, wf, to_opt, ewald_gmax=10),
"obdm": OBDMAccumulator(mol, dm_orbs, kpts=mf.kpts[kinds]),
"Sq": pyqmc.accumulators.SqAccumulator(mol.lattice_vectors()),
}
info_functions(mol, wf, accumulators)
kmf = scf.KRHF(cell, exxdiv=None).density_fit()
kmf.kpts = cell.make_kpts([nk, nk, nk])
ehf = kmf.kernel()
print("EHF", ehf)
return cell, kmf
if __name__ == "__main__":
# Run SCF
cell, kmf = run_scf(nk=2)
# Set up wf and configs
nconfig = 100
S = np.eye(3) * 2 # 2x2x2 supercell
supercell = get_supercell(cell, S)
wf, to_opt = pyqmc.default_sj(supercell, kmf)
configs = pyqmc.initial_guess(supercell, nconfig)
# Initialize energy accumulator (and Ewald)
pgrad = pyqmc.gradient_generator(supercell, wf, to_opt=to_opt)
# Optimize jastrow
wf, lm_df = pyqmc.line_minimization(wf,
configs,
pgrad,
hdf_file="pbc_he_linemin.hdf",
verbose=True)
# Run VMC
df, configs = pyqmc.vmc(
wf,
from pyscf import gto, scf
mol = gto.M(
atom="O 0 0 0; H 0 -2.757 2.587; H 0 2.757 2.587", basis="bfd_vtz", ecp="bfd"
)
mf = scf.RHF(mol).run()
return mol, mf
if __name__ == "__main__":
cluster = LocalCluster(n_workers=ncore, threads_per_worker=1)
client = Client(cluster)
mol, mf = run_scf()
from pyqmc import vmc, line_minimization, rundmc
wf, to_opt = pyqmc.default_sj(mol, mf)
pgrad_acc = pyqmc.gradient_generator(mol, wf, to_opt)
configs = pyqmc.initial_guess(mol, nconfig)
line_minimization(
wf,
configs,
pgrad_acc,
hdf_file="h2o_opt.hdf",
client=client,
npartitions=ncore,
verbose=True,
)
df, configs = vmc(
wf,
configs,
hdf_file="h2o_vmc.hdf",