def OPTIMIZE(
dft_checkfile,
output,
nconfig=1000,
start_from=None,
S=None,
client=None,
npartitions=None,
jastrow_kws=None,
slater_kws=None,
linemin_kws=None,
):
if linemin_kws is None:
linemin_kws = {}
mol, mf = pyqmc.recover_pyscf(dft_checkfile)
if S is not None:
mol = pyqmc.get_supercell(mol, np.asarray(S))
wf, to_opt = pyqmc.generate_wf(mol,
mf,
jastrow_kws=jastrow_kws,
slater_kws=slater_kws)
if start_from is not None:
pyqmc.read_wf(wf, start_from)
configs = pyqmc.initial_guess(mol, nconfig)
acc = pyqmc.gradient_generator(mol, wf, to_opt)
pyqmc.line_minimization(wf,
configs,
acc,
verbose=True,
hdf_file=output,
client=client,
npartitions=npartitions,
**linemin_kws)
def OPTIMIZE(
dft_checkfile,
output,
anchors=None,
nconfig=1000,
ci_checkfile=None,
start_from=None,
S=None,
client=None,
npartitions=None,
jastrow_kws=None,
slater_kws=None,
linemin_kws=None,
):
if linemin_kws is None:
linemin_kws = {}
target_root = 0
if ci_checkfile is None:
mol, mf = pyqmc.recover_pyscf(dft_checkfile)
mc = None
else:
mol, mf, mc = pyqmc.recover_pyscf(dft_checkfile,
ci_checkfile=ci_checkfile)
mc.ci = mc.ci[target_root]
if S is not None:
mol = pyqmc.get_supercell(mol, np.asarray(S))
wf, to_opt = pyqmc.generate_wf(mol,
mf,
mc=mc,
jastrow_kws=jastrow_kws,
slater_kws=slater_kws)
if start_from is not None:
pyqmc.read_wf(wf, start_from)
configs = pyqmc.initial_guess(mol, nconfig)
acc = pyqmc.gradient_generator(mol, wf, to_opt)
if anchors is None:
pyqmc.line_minimization(wf,
configs,
acc,
verbose=True,
hdf_file=output,
client=client,
npartitions=npartitions,
**linemin_kws)
else:
wfs = [pyqmc.read_wf(copy.deepcopy(wf), a) for a in anchors]
wfs.append(wf)
pyqmc.optimize_orthogonal(
wfs,
configs,
acc,
# verbose=True,
hdf_file=output,
client=client,
npartitions=npartitions,
**linemin_kws)
def optimize(self, nconfig=1000, **kwargs):
configs = pyqmc.initial_guess(self.mol, nconfig)
acc = pyqmc.gradient_generator(self.mol, self.wf, to_opt=self.to_opt)
if self.client is None:
pyqmc.line_minimization(self.wf, configs, acc, **kwargs)
else:
pyqmc.dasktools.line_minimization(
self.wf,
configs,
acc,
**kwargs,
client=self.client,
lmoptions={"npartitions": self.npartitions},
vmcoptions={
"npartitions": self.npartitions,
'nblocks': 5,
'nsteps_per_block': 20
},
)
def line_minimization(*args, client, **kwargs):
import pyqmc
if "vmcoptions" not in kwargs:
kwargs["vmcoptions"] = {}
if "lmoptions" not in kwargs:
kwargs["lmoptions"] = {}
kwargs["vmcoptions"]["client"] = client
kwargs["lmoptions"]["client"] = client
return pyqmc.line_minimization(*args, vmc=distvmc, lm=dist_lm_sampler, **kwargs)
def line_minimization(*args, npartitions, **kwargs):
import pyqmc
if "vmcoptions" in kwargs:
kwargs["vmcoptions"]["npartitions"] = npartitions
else:
kwargs["vmcoptions"] = {"npartitions": npartitions}
if "lmoptions" in kwargs:
kwargs["lmoptions"]["npartitions"] = npartitions
else:
kwargs["lmoptions"] = {"npartitions": npartitions}
return pyqmc.line_minimization(*args, vmc=distvmc, lm=dist_lm_sampler, **kwargs)
def test():
chkfile = "h2.hdf5"
optfile = "linemin.hdf5"
run_scf(chkfile)
mol, mf = pyqmc.recover_pyscf(chkfile)
noise = (np.random.random(mf.mo_coeff.shape) - 0.5) * 0.2
mf.mo_coeff = mf.mo_coeff * 1j + noise
slater_kws = {"optimize_orbitals": True}
wf, to_opt = pyqmc.generate_wf(mol, mf, slater_kws=slater_kws)
configs = pyqmc.initial_guess(mol, 100)
acc = pyqmc.gradient_generator(mol, wf, to_opt)
pyqmc.line_minimization(wf,
configs,
acc,
verbose=True,
hdf_file=optfile,
max_iterations=5)
assert os.path.isfile(optfile)
os.remove(chkfile)
os.remove(optfile)
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 = slater_jastrow(mol, mf)
nconf = 500
wf, dfgrad, dfline = line_minimization(wf, initial_guess(mol, nconf),
gradient_generator(mol, wf))
dfgrad = pd.DataFrame(dfgrad)
mfen = mf.energy_tot()
enfinal = dfgrad["en"].values[-1]
enfinal_err = dfgrad["en_err"].values[-1]
assert mfen > enfinal
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,
configs,
nblocks=100,
accumulators={"energy": pgrad.enacc},
hdf_file="pbc_he_vmc.hdf",
verbose=True,
)
# Run DMC
pyqmc.rundmc(
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",
accumulators={"energy": pgrad_acc.enacc},
client=client,
npartitions=ncore,
verbose=True,
)
dfdmc, configs, weights = rundmc(
wf,
if __name__ == "__main__":
import pyscf
import pyqmc
import pandas as pd
import h5py
import uuid
import itertools
mol = pyscf.gto.M(atom = "He 0. 0. 0.", basis='bfd_vdz', ecp='bfd', unit='bohr')
mf = pyscf.scf.RHF(mol).run()
for nconfig, steprange, npts in itertools.product([250, 500, 1000], [0.1, 0.2], [5, 10] ):
nconfig = nconfig
configs = pyqmc.initial_guess(mol, nconfig)
wf = pyqmc.slater_jastrow(mol, mf)
acc = pyqmc.gradient_generator(mol, wf, ['wf2acoeff','wf2bcoeff'])
identity = str(uuid.uuid4())
fname = f"../static/{identity}.hdf5"
pyqmc.line_minimization(wf, configs, acc, hdf_file = fname, steprange = steprange, npts=npts)
#These are not saved by line minimization, so we save them here.
with h5py.File(fname) as f:
f.attrs['uuid'] = identity
f.attrs['nconfig'] = nconfig
if __name__ == "__main__":
import pyscf
import pyqmc
import pandas as pd
mol = pyscf.gto.M(atom="He 0. 0. 0.",
basis='bfd_vdz',
ecp='bfd',
unit='bohr')
mf = pyscf.scf.RHF(mol).run()
wf = pyqmc.slater_jastrow(mol, mf)
nconfig = 1000
configs = pyqmc.initial_guess(mol, nconfig)
acc = pyqmc.gradient_generator(mol, wf, ['wf2acoeff', 'wf2bcoeff'])
wf, dfgrad, dfline = pyqmc.line_minimization(wf, configs, acc)
pd.DataFrame(dfgrad).to_json("optgrad.json")
pd.DataFrame(dfline).to_json("optline.json")
dfdmc, configs, weights = pyqmc.rundmc(
wf,
configs,
nsteps=5000,
accumulators={'energy': pyqmc.EnergyAccumulator(mol)},
tstep=0.02)
pd.DataFrame(dfdmc).to_json("dmc.json")
setuph2(savefiles["mf"], "test")
sys = pyqmc_from_hdf(savefiles["mf"])
df, coords = vmc(
sys["wf"],
pyqmc.initial_guess(sys["mol"], nconfig),
client=client,
nsteps=10,
npartitions=ncore,
)
line_minimization(
sys["wf"],
coords,
sys["pgrad"],
hdf_file=savefiles["linemin"],
client=client,
npartitions=ncore,
verbose=True,
)
# First excited state
wfs = [sys["wf"], deepcopy(sys["wf"])]
optimize_orthogonal(
wfs,
coords,
sys["pgrad"],
hdf_file=savefiles["excited1"],
forcing=[5.0],
Starget=[0.0],
client=client,
if __name__ == "__main__":
import pyscf
import pyqmc
import pandas as pd
mol = pyscf.gto.M(atom="He 0. 0. 0.",
basis='bfd_vdz',
ecp='bfd',
unit='bohr')
mf = pyscf.scf.RHF(mol).run()
wf = pyqmc.slater_jastrow(mol, mf)
nconfig = 1000
configs = pyqmc.initial_guess(mol, nconfig)
acc = pyqmc.gradient_generator(mol, wf, ['wf2acoeff', 'wf2bcoeff'])
pyqmc.line_minimization(wf, configs, acc, hdf_file="he_opt.hdf5")
pyqmc.rundmc(wf,
configs,
nsteps=5000,
accumulators={'energy': pyqmc.EnergyAccumulator(mol)},
tstep=0.02,
hdf_file="he_dmc.hdf5")
import pyscf
import pyqmc
mol = pyscf.gto.M(atom="He 0. 0. 0.",
basis="bfd_vdz",
ecp="bfd",
unit="bohr")
mf = pyscf.scf.RHF(mol).run()
wf, to_opt = pyqmc.default_sj(mol, mf)
nconfig = 1000
configs = pyqmc.initial_guess(mol, nconfig)
acc = pyqmc.gradient_generator(mol, wf, to_opt)
pyqmc.line_minimization(wf,
configs,
acc,
hdf_file="he_opt.hdf5",
verbose=True)
pyqmc.rundmc(
wf,
configs,
nsteps=5000,
accumulators={"energy": pyqmc.EnergyAccumulator(mol)},
tstep=0.02,
hdf_file="he_dmc.hdf5",
verbose=True,
)
def linear(mc_calc,nconfig=1000,**kwargs):
configs = pyqmc.initial_guess(mc_calc['mol'], nconfig)
acc = pyqmc.gradient_generator(mc_calc['mol'], mc_calc['wf'], to_opt=mc_calc['to_opt'], freeze=mc_calc['freeze'])
pyqmc.line_minimization(mc_calc['wf'], configs, acc, **kwargs)