def test_constraints(H2_ccecp_casci_s0): mol, mf, mc = H2_ccecp_casci_s0 wf, to_opt = pyq.generate_wf(mol, mf, mc=mc) old_parms = copy.deepcopy(wf.parameters) lt = LinearTransform(wf.parameters, to_opt) # Test serialize parameters x0 = lt.serialize_parameters(wf.parameters) x0 += np.random.normal(size=x0.shape) for k, it in lt.deserialize(wf, x0).items(): assert wf.parameters[k].shape == it.shape wf.parameters[k] = it # to_opt is supposed to be false for both of these. assert wf.parameters["wf1det_coeff"][0] == old_parms["wf1det_coeff"][0] assert np.sum(wf.parameters["wf2bcoeff"][0] - old_parms["wf2bcoeff"][0]) == 0 # While this one is supposed to change. assert np.sum(wf.parameters["wf2bcoeff"][1] - old_parms["wf2bcoeff"][1]) != 0 # Test serialize gradients configs = pyq.initial_guess(mol, 10) wf.recompute(configs) pgrad = wf.pgradient() pgrad_serial = lt.serialize_gradients(pgrad) # Pgrad should be walkers, configs assert pgrad_serial.shape[1] == x0.shape[0]
def test_info_functions_mol(LiH_sto3g_rhf): mol, mf = LiH_sto3g_rhf wf, to_opt = pyq.generate_wf(mol, mf) accumulators = { "pgrad": pyq.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 run_optimization_best_practice_2states(**kwargs): """ First optimize the ground state and then optimize the excited states while fixing the """ mol, mf, mc = H2_casci() import copy mf.output = None mol.output = None mc.output = None mc.stdout = None mol.stdout = None mc.stdout = None nstates = 2 mcs = [copy.copy(mc) for i in range(nstates)] for i in range(nstates): mcs[i].ci = mc.ci[i] wfs = [] to_opts = [] for i in range(nstates): wf, to_opt = pyq.generate_wf( mol, mf, mc=mcs[i], slater_kws=dict(optimize_determinants=True)) wfs.append(wf) to_opts.append(to_opt) configs = pyq.initial_guess(mol, 1000) pgrad1 = pyq.gradient_generator(mol, wfs[0], to_opt=to_opts[0]) wfs[0], _ = pyq.line_minimization(wfs[0], configs, pgrad1, verbose=True, max_iterations=10) for k in to_opts[0]: to_opts[0][k] = np.zeros_like(to_opts[0][k]) to_opts[0]['wf1det_coeff'][0] = True #Bug workaround for linear transform for to_opt in to_opts[1:]: to_opt['wf1det_coeff'] = np.ones_like(to_opt['wf1det_coeff']) transforms = [ pyqmc.accumulators.LinearTransform(wf.parameters, to_opt) for wf, to_opt in zip(wfs, to_opts) ] for wf in wfs[1:]: for k in wf.parameters.keys(): if 'wf2' in k: wf.parameters[k] = wfs[0].parameters[k].copy() _, configs = pyq.vmc(wfs[0], configs) energy = pyq.EnergyAccumulator(mol) return optimize(wfs, configs, energy, transforms, **kwargs)
def test_transform(LiH_sto3g_rhf): """Tests that the shapes are ok""" mol, mf = LiH_sto3g_rhf wf, to_opt = pyq.generate_wf(mol, mf) transform = LinearTransform(wf.parameters) x = transform.serialize_parameters(wf.parameters) nconfig = 10 configs = pyq.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_info_functions_pbc(H_pbc_sto3g_krks): from pyqmc.supercell import get_supercell mol, mf = H_pbc_sto3g_krks kinds = [0, 1] dm_orbs = [mf.mo_coeff[i][:, :2] for i in kinds] wf, to_opt = pyq.generate_wf(mol, mf) accumulators = { "pgrad": pyq.gradient_generator(mol, wf, to_opt, ewald_gmax=10), "obdm": OBDMAccumulator(mol, dm_orbs, kpts=mf.kpts[kinds]), "Sq": SqAccumulator(mol.lattice_vectors()), } info_functions(mol, wf, accumulators)
def test_linemin(H2_ccecp_uhf): """Optimize a Slater-Jastrow wave function and check that it's better than Hartree-Fock""" mol, mf = H2_ccecp_uhf wf, to_opt = generate_wf(mol, mf) nconf = 100 wf, dfgrad = line_minimization( wf, initial_guess(mol, nconf), gradient_generator(mol, wf, to_opt) ) dfgrad = pd.DataFrame(dfgrad) mfen = mf.energy_tot() enfinal = dfgrad["energy"].values[-1] enfinal_err = dfgrad["energy_error"].values[-1] assert mfen > enfinal
def test_dmc_restarts(H_pbc_sto3g_krks, nconf=10): """For PBCs, check to make sure there are no errors on restart.""" mol, mf = H_pbc_sto3g_krks nconf = 10 fname = "test_dmc_restart_" + str(uuid.uuid4()) configs = pyq.initial_guess(mol, nconf) wf, _ = pyq.generate_wf(mol, mf, jastrow_kws=dict(na=0, nb=0)) enacc = pyq.EnergyAccumulator(mol) pyq.rundmc(wf, configs, nsteps=20, hdf_file=fname, accumulators={"energy": enacc}) pyq.rundmc(wf, configs, nsteps=20, hdf_file=fname, accumulators={"energy": enacc}) os.remove(fname)
def test(): """ Ensure that DMC obtains the exact result for a hydrogen atom """ from pyscf import gto, scf from pyqmc.dmc import limdrift 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 = pyq.initial_guess(mol, nconf) wf, _ = pyq.generate_wf(mol, mf, jastrow_kws=dict(na=0, nb=0)) enacc = pyq.EnergyAccumulator(mol) warmup = 200 branchtime = 5 dfdmc, configs_, weights_ = pyq.rundmc( wf, configs, nsteps=4000 + warmup * branchtime, branchtime=branchtime, accumulators={"energy": enacc}, ekey=("energy", "total"), tstep=0.01, 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, weights=dfprod["weight"]) 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_complex_linemin(H2_ccecp_rhf, optfile="linemin.hdf5"): """Test linemin for the case of complex orbital coefficients. We check whether it completes successfully and whether the energy has decreased. """ mol, mf = H2_ccecp_rhf mf = copy.copy(mf) 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 = pyq.generate_wf(mol, mf, slater_kws=slater_kws) configs = pyq.initial_guess(mol, 100) acc = pyq.gradient_generator(mol, wf, to_opt) pyq.line_minimization( wf, configs, acc, verbose=True, hdf_file=optfile, max_iterations=5 ) assert os.path.isfile(optfile) with h5py.File(optfile, "r") as f: en = f["energy"][()] assert en[0] > en[-1] os.remove(optfile)