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)