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_excited(mc_anchors, mc_calc, nconfig = 1000, **kwargs):
acc = pyqmc.gradient_generator(mc_calc['mol'], mc_calc['wf'], to_opt=mc_calc['to_opt'])
wfs = [x['wf'] for x in mc_anchors]
wfs.append(mc_calc['wf'])
configs = pyqmc.initial_guess(mc_calc['mol'], nconfig)
pyqmc.optimize_orthogonal.optimize_orthogonal(wfs,configs, acc, **kwargs)
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 pyqmc_from_hdf(chkfile):
""" Loads pyqmc objects from a pyscf checkfile """
mol = lib.chkfile.load_mol(chkfile)
mol.output = None
mol.stdout = None
mf = scf.RHF(mol)
mf.__dict__.update(scf.chkfile.load(chkfile, "scf"))
with h5py.File(chkfile, "r") as f:
mc = mcscf.CASCI(mf,
ncas=int(f["mc/ncas"][...]),
nelecas=f["mc/nelecas"][...])
mc.ci = f["mc/ci"][...]
wf, to_opt, freeze = pyqmc.default_msj(mol, mf, mc)
freeze["wf1det_coeff"][...] = False
pgrad = pyqmc.gradient_generator(mol, wf, to_opt, freeze)
return {
"mol": mol,
"mf": mf,
"to_opt": to_opt,
"freeze": freeze,
"wf": wf,
"pgrad": pgrad,
}
def setup(self):
self.mol = pyscf.gto.M(atom="O 0 0 0; H 0 -2.757 2.587; H 0 2.757 2.587", basis=f'ccecpccpvdz', ecp='ccecp')
self.mf = pyscf.scf.RHF(self.mol).run()
self.configs = pyqmc.initial_guess(self.mol, 500)
self.slater, self.slater_to_opt = pyqmc.default_slater(self.mol, self.mf, optimize_orbitals=True)
self.jastrow, self.jastrow_to_opt = pyqmc.default_jastrow(self.mol)
self.pgrad_acc = pyqmc.gradient_generator(self.mol, self.slater, self.slater_to_opt)
self.slater.recompute(self.configs)
self.jastrow.recompute(self.configs)
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
def test():
print("running scf", flush=True)
mol = gto.M(atom="H 0. 0. 0.; H 0. 0. 1.6", basis="ccpvdz", unit="bohr")
mf = scf.UHF(mol).run()
mf.stdout = None
print("setting up wfs", flush=True)
wf0 = pyqmc.Slater(mol, mf)
mf.mo_coeff[0][:, 0] = np.mean(mf.mo_coeff[0][:, :2], axis=1)
wf1, to_opt = pyqmc.default_slater(mol, mf, optimize_orbitals=True)
pgrad = pyqmc.gradient_generator(mol, wf1, to_opt)
configs = pyqmc.initial_guess(mol, 2000)
wf0.recompute(configs)
wf1.recompute(configs)
wfs = [wf0, wf1]
print("warming up", flush=True)
block_avg, configs = oo.sample_overlap_worker(wfs,
configs,
pgrad,
20,
tstep=1.5)
print("computing gradients and normalization", flush=True)
data = get_data(wfs, configs, pgrad)
parameters = pgrad.transform.serialize_parameters(wfs[-1].parameters)
N = compute_normalization(wfs, [parameters], pgrad.transform, configs)
print(np.stack([data["N"], N]))
print("computing numerical gradients", flush=True)
error = {"N": [], "S": []}
deltas = [1e-4, 1e-5, 1e-6]
numgrad = numerical_gradient(wfs, configs, pgrad, deltas)
for k, ng in numgrad.items():
pgerr = data[k + "_derivative"].T[:, np.newaxis] - ng
error[k] = pgerr
print("computing errors", flush=True)
for k, er in error.items():
error[k] = np.amin(er, axis=1)
print(k)
print(error[k])
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 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)
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)
wf=pyqmc.slater_jastrow(mol,mf)
return mol,mf,wf
if __name__=="__main__":
cluster = LocalCluster(n_workers=ncore, threads_per_worker=1)
client = Client(cluster)
mol,mf,wf=generate_wfs()
from pyqmc.mc import vmc
from pyqmc.dasktools import distvmc,line_minimization
from pyqmc.dmc import rundmc
from pyqmc import EnergyAccumulator
df,coords=distvmc(wf,pyqmc.initial_guess(mol,nconfig),client=client,nsteps_per=10,nsteps=10)
line_minimization(wf,coords,pyqmc.gradient_generator(mol,wf,["wf2acoeff", "wf2bcoeff"]),client=client)
dfdmc, configs, weights = rundmc(
wf,
coords,
nsteps=5000,
branchtime=5,
accumulators={"energy": EnergyAccumulator(mol)},
ekey=("energy", "total"),
tstep=0.02,
verbose=True,
propagate=pyqmc.dasktools.distdmc_propagate,
client=client,
)
dfdmc = pd.DataFrame(dfdmc).to_json("dmc.json")
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,
configs,
nblocks=100,
accumulators={"energy": pgrad.enacc},
hdf_file="pbc_he_vmc.hdf",
basis="bfd_vtz",
ecp="bfd")
mf = scf.RHF(mol).run()
# clean_pyscf_objects gets rid of the TextIO objects that can't
# be sent using parsl.
mol, mf = clean_pyscf_objects(mol, mf)
# It's better to load parsl after pyscf has run. Some of the
# executors have timeouts and will kill the job while pyscf is running!
parsl.load(config)
parsl.set_stream_logger(level=logging.WARNING)
# We make a Slater-Jastrow wave function and
# only optimize the Jastrow coefficients.
wf = pyqmc.slater_jastrow(mol, mf)
acc = pyqmc.gradient_generator(mol, wf, ["wf2acoeff", "wf2bcoeff"])
# Generate the initial configurations.
# Here we run VMC for a few steps with no accumulators to equilibrate the
# walkers.
configs = pyqmc.initial_guess(mol, nconf)
df, configs = distvmc(wf,
configs,
accumulators={},
nsteps=10,
npartitions=ncore)
# This uses a stochastic reconfiguration step to generate parameter changes along a line,
# then minimizes the energy along that line.
wf, dfgrad, dfline = line_minimization(
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
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",
accumulators={"energy": pgrad_acc.enacc},
from dask.distributed import Client, LocalCluster
r = 1.1
ncore = 2
sys = setuph2(r)
cluster = LocalCluster(n_workers=ncore, threads_per_worker=1)
client = Client(cluster)
# Set up calculation
nconf = 800
configs = pyqmc.initial_guess(sys["mol"], nconf)
wf, dfgrad, dfline = line_minimization(
sys["wf"],
configs,
pyqmc.gradient_generator(sys["mol"], sys["wf"]),
client=client,
maxiters=5,
)
forcing = {}
obj = {}
for k in sys["descriptors"]:
forcing[k] = 0.0
obj[k] = 0.0
forcing["t"] = 0.5
forcing["trace"] = 1.0
obj["t"] = 0.0
obj["trace"] = 2.0
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)
