def test_wfs():
"""
Ensure that the wave function objects are consistent in several situations.
"""
from pyscf import lib, gto, scf
from pyqmc.slater import PySCFSlater
from pyqmc.jastrowspin import JastrowSpin
from pyqmc.multiplywf import MultiplyWF
from pyqmc.manybody_jastrow import J3
import pyqmc
mol = gto.M(atom="Li 0. 0. 0.; H 0. 0. 1.5", basis="sto-3g", unit="bohr")
mf = scf.RHF(mol).run()
mf_rohf = scf.ROHF(mol).run()
mf_uhf = scf.UHF(mol).run()
epsilon = 1e-5
nconf = 10
epos = pyqmc.initial_guess(mol, nconf)
for wf in [
JastrowSpin(mol),
J3(mol),
MultiplyWF(PySCFSlater(mol, mf), JastrowSpin(mol)),
MultiplyWF(PySCFSlater(mol, mf), JastrowSpin(mol), J3(mol)),
PySCFSlater(mol, mf_uhf),
PySCFSlater(mol, mf),
PySCFSlater(mol, mf_rohf),
]:
for k in wf.parameters:
if k != "mo_coeff":
wf.parameters[k] = np.random.rand(*wf.parameters[k].shape)
for k, item in testwf.test_updateinternals(wf, epos).items():
print(k, item)
assert item < epsilon
testwf.test_mask(wf, 0, epos)
_, epos = pyqmc.vmc(wf, epos, nblocks=1, nsteps=2,
tstep=1) # move off node
for fname, func in zip(
["gradient", "laplacian", "pgradient"],
[
testwf.test_wf_gradient,
testwf.test_wf_laplacian,
testwf.test_wf_pgradient,
],
):
err = []
for delta in [1e-4, 1e-5, 1e-6, 1e-7, 1e-8]:
err.append(func(wf, epos, delta)[0])
print(type(wf), fname, min(err))
assert min(err) < epsilon, "epsilon {0}".format(epsilon)
def test_single_opt():
from pyqmc.accumulators import EnergyAccumulator
from pyscf import lib, gto, scf
import pandas as pd
from pyqmc.multiplywf import MultiplyWF
from pyqmc.jastrow import Jastrow2B
from pyqmc.func3d import GaussianFunction
from pyqmc.slater import PySCFSlaterRHF
from pyqmc.multiplywf import MultiplyWF
from pyqmc.jastrow import Jastrow2B
from pyqmc.mc import initial_guess,vmc
mol = gto.M(atom='Li 0. 0. 0.; Li 0. 0. 1.5', basis='bfd_vtz',ecp='bfd',unit='bohr',verbose=5)
mf = scf.RHF(mol).run()
nconf=1000
nsteps=10
coords = initial_guess(mol,nconf)
wf=MultiplyWF(PySCFSlaterRHF(mol,mf),Jastrow2B(mol,
basis=[GaussianFunction(1.0),GaussianFunction(2.0)]))
vmc(wf,coords,nsteps=nsteps)
opt_var,wf=optvariance(EnergyAccumulator(mol),wf,coords,['wf2coeff'])
print('Final variance:',opt_var)
def test_wfs():
"""
Ensure that the wave function objects are consistent in several situations.
"""
from pyscf import lib, gto, scf
from pyqmc.slateruhf import PySCFSlaterUHF
from pyqmc.jastrowspin import JastrowSpin
from pyqmc.multiplywf import MultiplyWF
mol = gto.M(atom='Li 0. 0. 0.; H 0. 0. 1.5', basis='cc-pvtz', unit='bohr')
mf = scf.RHF(mol).run()
mf_rohf = scf.ROHF(mol).run()
mf_uhf = scf.UHF(mol).run()
epsilon = 1e-5
nconf = 10
epos = np.random.randn(nconf, 4, 3)
for wf in [
JastrowSpin(mol),
MultiplyWF(PySCFSlaterUHF(mol, mf), JastrowSpin(mol)),
PySCFSlaterUHF(mol, mf_uhf),
PySCFSlaterUHF(mol, mf),
PySCFSlaterUHF(mol, mf_rohf)
]:
for k in wf.parameters:
wf.parameters[k] = np.random.rand(*wf.parameters[k].shape)
assert testwf.test_wf_gradient(wf, epos, delta=1e-5)[0] < epsilon
assert testwf.test_wf_laplacian(wf, epos, delta=1e-5)[0] < epsilon
assert testwf.test_wf_pgradient(wf, epos, delta=1e-5)[0] < epsilon
for k, item in testwf.test_updateinternals(wf, epos).items():
assert item < epsilon
def test_pbc_wfs():
"""
Ensure that the wave function objects are consistent in several situations.
"""
from pyscf.pbc import lib, gto, scf
from pyqmc.supercell import get_supercell
from pyqmc.slater import Slater
from pyqmc.multiplywf import MultiplyWF
from pyqmc import default_jastrow
import pyqmc
mol = gto.M(
atom="H 0. 0. 0.; H 1. 1. 1.",
basis="sto-3g",
unit="bohr",
a=(np.ones((3, 3)) - np.eye(3)) * 4,
)
mf = scf.KRKS(mol, mol.make_kpts((2, 2, 2))).run()
# mf_rohf = scf.KROKS(mol).run()
# mf_uhf = scf.KUKS(mol).run()
epsilon = 1e-5
nconf = 10
supercell = get_supercell(mol, S=(np.ones((3, 3)) - 2 * np.eye(3)))
epos = pyqmc.initial_guess(supercell, nconf)
# For multislaterpbc
# kinds = 0, 3, 5, 6 # G, X, Y, Z
# d1 = {kind: [0] for kind in kinds}
# d2 = d1.copy()
# d2.update({0: [], 3: [0, 1]})
# detwt = [2 ** 0.5, 2 ** 0.5]
# occup = [[d1, d2], [d1]]
# map_dets = [[0, 1], [0, 0]]
for wf in [
MultiplyWF(Slater(supercell, mf), default_jastrow(supercell)[0]),
Slater(supercell, mf),
]:
for k in wf.parameters:
if "mo_coeff" not in k and k != "det_coeff":
wf.parameters[k] = np.random.rand(*wf.parameters[k].shape)
_, epos = pyqmc.vmc(wf, epos, nblocks=1, nsteps=2, tstep=1) # move off node
for fname, func in zip(
["gradient", "laplacian", "pgradient"],
[
testwf.test_wf_gradient,
testwf.test_wf_laplacian,
testwf.test_wf_pgradient,
],
):
err = []
for delta in [1e-4, 1e-5, 1e-6, 1e-7, 1e-8]:
err.append(func(wf, epos, delta))
print(type(wf), fname, min(err))
assert min(err) < epsilon
for k, item in testwf.test_updateinternals(wf, epos).items():
print(k, item)
assert item < epsilon
def default_msj(mol, mf, mc, tol=None, freeze_orb=None, ion_cusp=False):
wf1, to_opt1 = default_multislater(mol, mf, mc, tol, freeze_orb)
wf2, to_opt2 = default_jastrow(mol, ion_cusp)
wf = MultiplyWF(wf1, wf2)
to_opt = {"wf1" + x: opt for x, opt in to_opt1.items()}
to_opt.update({"wf2" + x: opt for x, opt in to_opt2.items()})
return wf, to_opt
def default_sj(mol, mf, optimize_orbitals=False, twist=None, **jastrow_kws):
wf1, to_opt1 = default_slater(mol, mf, optimize_orbitals, twist)
wf2, to_opt2 = default_jastrow(mol, **jastrow_kws)
wf = MultiplyWF(wf1, wf2)
to_opt = {"wf1" + x: opt for x, opt in to_opt1.items()}
to_opt.update({"wf2" + x: opt for x, opt in to_opt2.items()})
return wf, to_opt
def test():
""" Ensure that DMC obtains the exact result for a hydrogen atom """
from pyscf import lib, gto, scf
from pyqmc.slater import PySCFSlater
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
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 = PySCFSlater(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))
def test():
""" Ensure that DMC obtains the exact result for a hydrogen atom """
from pyscf import lib, gto, scf
from pyqmc.slateruhf import PySCFSlaterUHF
from pyqmc.jastrowspin import JastrowSpin
from pyqmc.dmc import limdrift, dmc
from pyqmc.mc import vmc
from pyqmc.accumulators import EnergyAccumulator
from pyqmc.func3d import ExpCuspFunction
from pyqmc.multiplywf import MultiplyWF
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 = np.random.randn(nconf, 1, 3)
wf1 = PySCFSlaterUHF(mol, mf)
wf = wf1
wf2 = JastrowSpin(mol, a_basis=[ExpCuspFunction(5, .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)))
dfdmc, configs_, weights_ = dmc(
wf,
configs,
nsteps=5000,
branchtime=5,
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)
warmup = 200
dfprod = dfdmc[dfdmc.step > warmup]
reblock = pyblock.reblock(dfprod[['energytotal', 'energyei']])
print(reblock[1])
dfoptimal = reblock[1][reblock[1][('energytotal', 'optimal block')] != '']
energy = dfoptimal[('energytotal', 'mean')].values[0]
err = dfoptimal[('energytotal', 'standard error')].values[0]
print("energy", energy, "+/-", err)
assert np.abs(
energy +
0.5) < 5 * err, "energy not within {0} of -0.5: energy {1}".format(
5 * err, np.mean(energy))
def test():
from pyscf import lib, gto, scf
from pyqmc.accumulators import EnergyAccumulator, PGradTransform, LinearTransform
from pyqmc.multiplywf import MultiplyWF
from pyqmc.jastrow import Jastrow2B
from pyqmc.func3d import GaussianFunction
from pyqmc.slater import PySCFSlaterRHF
from pyqmc.mc import initial_guess
mol = gto.M(atom='H 0. 0. 0.; H 0. 0. 1.5',
basis='cc-pvtz',
unit='bohr',
verbose=5)
mf = scf.RHF(mol).run()
nconf = 2500
nsteps = 70
warmup = 20
coords = initial_guess(mol, nconf)
basis = {
'wf2coeff':
[GaussianFunction(0.2),
GaussianFunction(0.4),
GaussianFunction(0.6)]
}
wf = MultiplyWF(PySCFSlaterRHF(mol, mf), Jastrow2B(mol, basis['wf2coeff']))
params0 = {'wf2coeff': np.array([-0.8, -0.2, 0.4])}
for k, p in wf.parameters.items():
if k in params0:
wf.parameters[k] = params0[k]
energy_acc = EnergyAccumulator(mol)
pgrad_acc = PGradTransform(energy_acc, LinearTransform(wf.parameters))
# Gradient descent
wf, data = gradient_descent(wf,
coords,
pgrad_acc,
vmcoptions={'nsteps': nsteps},
warmup=warmup,
step=0.5,
eps=0.1,
maxiters=50,
datafile='sropt.json')
def default_sj(mol, mf, ion_cusp=False):
wf1, to_opt1, freeze1 = default_slater(mol, mf)
wf2, to_opt2, freeze2 = default_jastrow(mol, ion_cusp)
wf = MultiplyWF(wf1, wf2)
to_opt = ["wf1" + x for x in to_opt1] + ["wf2" + x for x in to_opt2]
freeze = {}
for k in to_opt1:
freeze["wf1" + k] = freeze1[k]
for k in to_opt2:
freeze["wf2" + k] = freeze2[k]
return wf, to_opt, freeze
def default_msj(mol, mf, mc):
wf1, to_opt1, freeze1 = default_multislater(mol, mf, mc)
wf2, to_opt2, freeze2 = default_jastrow(mol)
wf = MultiplyWF(wf1, wf2)
to_opt = ["wf1" + x for x in to_opt1] + ["wf2" + x for x in to_opt2]
freeze = {}
for k in to_opt1:
freeze["wf1" + k] = freeze1[k]
for k in to_opt2:
freeze["wf2" + k] = freeze2[k]
return wf, to_opt, freeze
def default_msj(mol, mf, mc, tol=None, rcut=7.5, freeze_orb=None):
wf1, to_opt1, freeze1 = default_multislater(mol, mf, mc, tol, freeze_orb)
wf2, to_opt2, freeze2 = default_jastrow(mol, rcut = rcut)
wf = MultiplyWF(wf1, wf2)
to_opt = ["wf1" + x for x in to_opt1] + ["wf2" + x for x in to_opt2]
freeze = {}
for k in to_opt1:
freeze["wf1" + k] = freeze1[k]
for k in to_opt2:
freeze["wf2" + k] = freeze2[k]
return wf, to_opt, freeze
def test_obc_wfs(LiH_sto3g_rhf, epsilon=1e-5, nconf=10):
"""
Ensure that the wave function objects are consistent in several situations.
"""
mol, mf = LiH_sto3g_rhf
for wf in [
generate_jastrow(mol)[0],
J3(mol),
MultiplyWF(Slater(mol, mf),
generate_jastrow(mol)[0]),
MultiplyWF(Slater(mol, mf),
generate_jastrow(mol)[0], J3(mol)),
Slater(mol, mf),
]:
for k in wf.parameters:
if k != "mo_coeff":
wf.parameters[k] = cp.asarray(
np.random.rand(*wf.parameters[k].shape))
epos = pyq.initial_guess(mol, nconf)
run_tests(wf, epos, epsilon)
def test_ecp_sj(C2_ccecp_rhf, nconf=10000):
"""test whether the cutoff saves us time without changing the energy too much.
Because it's a stochastic evaluation, random choices can make a big difference, so we only require 10% agreement between these two."""
mol, mf = C2_ccecp_rhf
THRESHOLDS = [1e15, 10]
np.random.seed(1234)
coords = initial_guess(mol, nconf)
wf = MultiplyWF(Slater(mol, mf), generate_jastrow(mol)[0])
wf.recompute(coords)
times = []
energies = []
for threshold in THRESHOLDS:
np.random.seed(1234)
eacc = EnergyAccumulator(mol, threshold)
start = time.time()
energy = eacc(coords, wf)
end = time.time()
times.append(end - start)
energies.append(np.mean(energy["total"]))
# print(times, energies)
assert times[1] < times[0]
assert (energies[1] - energies[0]) / energies[0] < 0.1
def test_pbc_wfs():
"""
Ensure that the wave function objects are consistent in several situations.
"""
from pyscf.pbc import lib, gto, scf
from pyqmc.slaterpbc import PySCFSlaterPBC, get_supercell
from pyqmc.jastrowspin import JastrowSpin
from pyqmc.multiplywf import MultiplyWF
from pyqmc.coord import OpenConfigs
import pyqmc
mol = gto.M(atom="H 0. 0. 0.; H 1. 1. 1.",
basis="sto-3g",
unit="bohr",
a=np.eye(3) * 4)
mf = scf.KRKS(mol).run()
# mf_rohf = scf.KROKS(mol).run()
# mf_uhf = scf.KUKS(mol).run()
epsilon = 1e-5
nconf = 10
supercell = get_supercell(mol, S=np.eye(3))
epos = pyqmc.initial_guess(supercell, nconf)
for wf in [
MultiplyWF(PySCFSlaterPBC(supercell, mf), JastrowSpin(mol)),
PySCFSlaterPBC(supercell, mf),
# PySCFSlaterPBC(supercell, mf_uhf),
# PySCFSlaterPBC(supercell, mf_rohf),
]:
for k in wf.parameters:
if k != "mo_coeff":
wf.parameters[k] = np.random.rand(*wf.parameters[k].shape)
for fname, func in zip(
["gradient", "laplacian", "pgradient"],
[
testwf.test_wf_gradient,
testwf.test_wf_laplacian,
testwf.test_wf_pgradient,
],
):
err = []
for delta in [1e-4, 1e-5, 1e-6, 1e-7, 1e-8]:
err.append(func(wf, epos, delta)[0])
print(fname, min(err))
assert min(err) < epsilon
for k, item in testwf.test_updateinternals(wf, epos).items():
print(k, item)
assert item < epsilon
def slater_jastrow(mol, mf, abasis=None, bbasis=None):
if abasis is None:
abasis = [GaussianFunction(0.8), GaussianFunction(1.6), GaussianFunction(3.2)]
if bbasis is None:
bbasis = [
CutoffCuspFunction(2.0, 1.5),
GaussianFunction(0.8),
GaussianFunction(1.6),
GaussianFunction(3.2),
]
wf = MultiplyWF(
PySCFSlaterUHF(mol, mf), JastrowSpin(mol, a_basis=abasis, b_basis=bbasis)
)
return wf
def generate_wf(mol,
mf,
jastrow=default_jastrow,
jastrow_kws=None,
slater_kws=None,
mc=None):
"""
Generate a wave function from pyscf objects.
:param mol: The molecule or cell
:type mol: pyscf Mole or Cell
:param mf: a pyscf mean-field object
:type mf: Any mean-field object that PySCFSlater can read
:param jastrow: a function that returns wf, to_opt, or a list of such functions.
:param jastrow_kws: a dictionary of keyword arguments for the jastrow function, or a list of those functions.
:param slater_kws: a dictionary of keyword arguments for the default_slater function
:param mc: A CAS object (optional) for multideterminant wave functions.
:return: wf
:rtype: A (multi) Slater-Jastrow wave function object
:return: to_opt
:rtype: A dictionary of parameters to optimize, given the settings.
"""
if jastrow_kws is None:
jastrow_kws = {}
if slater_kws is None:
slater_kws = {}
if not isinstance(jastrow, list):
jastrow = [jastrow]
jastrow_kws = [jastrow_kws]
if mc is None:
wf1, to_opt1 = default_slater(mol, mf, **slater_kws)
elif hasattr(mol, "a"):
raise NotImplementedError("No defaults for multislater with PBCs")
else:
wf1, to_opt1 = default_multislater(mol, mf, mc, **slater_kws)
pack = [jast(mol, **kw) for jast, kw in zip(jastrow, jastrow_kws)]
wfs = [p[0] for p in pack]
to_opts = [p[1] for p in pack]
wf = MultiplyWF(wf1, *wfs)
to_opt = {"wf1" + k: v for k, v in to_opt1.items()}
for i, to_opt2 in enumerate(to_opts):
to_opt.update({f"wf{i+2}" + k: v for k, v in to_opt2.items()})
return wf, to_opt
def test_wfs():
"""
Ensure that the wave function objects are consistent in several situations.
"""
from pyscf import lib, gto, scf
from pyqmc.slateruhf import PySCFSlaterUHF
from pyqmc.jastrowspin import JastrowSpin
from pyqmc.multiplywf import MultiplyWF
from pyqmc.coord import OpenConfigs
import pyqmc
mol = gto.M(atom="Li 0. 0. 0.; H 0. 0. 1.5", basis="cc-pvtz", unit="bohr")
mf = scf.RHF(mol).run()
mf_rohf = scf.ROHF(mol).run()
mf_uhf = scf.UHF(mol).run()
epsilon = 1e-5
nconf = 10
epos = pyqmc.initial_guess(mol, nconf)
for wf in [
JastrowSpin(mol),
MultiplyWF(PySCFSlaterUHF(mol, mf), JastrowSpin(mol)),
PySCFSlaterUHF(mol, mf_uhf),
PySCFSlaterUHF(mol, mf),
PySCFSlaterUHF(mol, mf_rohf),
]:
for k in wf.parameters:
if k != "mo_coeff":
wf.parameters[k] = np.random.rand(*wf.parameters[k].shape)
for fname, func in zip(
["gradient", "laplacian", "pgradient"],
[
testwf.test_wf_gradient,
testwf.test_wf_laplacian,
testwf.test_wf_pgradient,
],
):
err = []
for delta in [1e-4, 1e-5, 1e-6, 1e-7, 1e-8]:
err.append(func(wf, epos, delta)[0])
print(fname, min(err))
assert min(err) < epsilon
for k, item in testwf.test_updateinternals(wf, epos).items():
print(k, item)
assert item < epsilon
def test_ecp():
mol = gto.M(
atom="""C 0 0 0
C 1 0 0
""",
ecp="bfd",
basis="bfd_vtz",
)
mf = scf.RHF(mol).run()
nconf = 1000
coords = initial_guess(mol, nconf)
thresholds = [1e15, 100, 50, 20, 10, 5, 1]
label = ["S", "J", "SJ"]
ind = 0
for wf in [
Slater(mol, mf),
default_jastrow(mol)[0],
MultiplyWF(Slater(mol, mf),
default_jastrow(mol)[0]),
]:
wf.recompute(coords)
print(label[ind])
ind += 1
for threshold in thresholds:
eacc = EnergyAccumulator(mol, threshold)
start = time.time()
eacc(coords, wf)
end = time.time()
print("Threshold=", threshold, np.around(end - start, 2), "s")
mc = mcscf.CASCI(mf, ncas=4, nelecas=(2, 2))
mc.kernel()
label = ["MS"]
ind = 0
for wf in [Slater(mol, mf, mc)]:
wf.recompute(coords)
print(label[ind])
ind += 1
for threshold in thresholds:
eacc = EnergyAccumulator(mol, threshold)
start = time.time()
eacc(coords, wf)
end = time.time()
print("Threshold=", threshold, np.around(end - start, 2), "s")
def test_ecp():
mol = gto.M(atom='''C 0 0 0
C 1 0 0
''',
ecp="bfd",
basis="bfd_vtz")
mf = scf.RHF(mol).run()
nconf = 1000
coords = initial_guess(mol, nconf)
thresholds = [1e15, 100, 50, 20, 10, 5, 1]
label = ['S', 'J', 'SJ']
ind = 0
for wf in [
PySCFSlaterUHF(mol, mf),
JastrowSpin(mol),
MultiplyWF(PySCFSlaterUHF(mol, mf), JastrowSpin(mol))
]:
wf.recompute(coords)
print(label[ind])
ind += 1
for threshold in thresholds:
eacc = EnergyAccumulator(mol, threshold)
start = time.time()
eacc(coords, wf)
end = time.time()
print('Threshold=', threshold, np.around(end - start, 2), 's')
mc = mcscf.CASCI(mf, ncas=4, nelecas=(2, 2))
mc.kernel()
label = ['MS']
ind = 0
for wf in [MultiSlater(mol, mf, mc)]:
wf.recompute(coords)
print(label[ind])
ind += 1
for threshold in thresholds:
eacc = EnergyAccumulator(mol, threshold)
start = time.time()
eacc(coords, wf)
end = time.time()
print('Threshold=', threshold, np.around(end - start, 2), 's')
def test_pbc_wfs(H_pbc_sto3g_krks, epsilon=1e-5, nconf=10):
"""
Ensure that the wave function objects are consistent in several situations.
"""
mol, mf = H_pbc_sto3g_krks
supercell = pyq.get_supercell(mol, S=(np.ones((3, 3)) - 2 * np.eye(3)))
epos = pyq.initial_guess(supercell, nconf)
for wf in [
MultiplyWF(Slater(supercell, mf),
generate_jastrow(supercell)[0]),
Slater(supercell, mf),
]:
for k in wf.parameters:
if "mo_coeff" not in k and k != "det_coeff":
wf.parameters[k] = cp.asarray(
np.random.rand(*wf.parameters[k].shape))
_, epos = pyq.vmc(wf, epos, nblocks=1, nsteps=2,
tstep=1) # move off node
run_tests(wf, epos, epsilon)
import numpy as np from pyscf import lib, gto, scf import pyqmc from pyqmc.slateruhf import PySCFSlaterUHF from pyqmc.jastrowspin import JastrowSpin # from pyqmc.jastrow import Jastrow2B from pyqmc.coord import OpenConfigs import time from pyqmc.manybody_jastrow import J3 import pyqmc.testwf as test from pyqmc.wf import WaveFunction from pyqmc.multiplywf import MultiplyWF # import pandas as pd mol = gto.M(atom="Li 0. 0. 0.; Li 0. 0. 1.5", basis="sto-3g", unit="bohr") mf = scf.UHF(mol).run() wf1 = PySCFSlaterUHF(mol, mf) wf2 = JastrowSpin(mol) # wf3 = J3(mol) wf = WaveFunction([wf1, wf2]) wfmultiply = MultiplyWF(wf1, wf2) configs = OpenConfigs(np.random.randn(10, np.sum(mol.nelec), 3)) wf.recompute(configs) # res = test.test_wf_gradient(wf, configs) e = 2 epos = configs.electron(e) test.test_mask(wf, 3, epos)
