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_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_overlap_derivative(H2_ccecp_uhf, epsilon=1e-8):
mol, mf = H2_ccecp_uhf
mf = copy.copy(mf)
wf0 = slater.Slater(mol, mf)
mf.mo_coeff[0][:, 0] = np.mean(mf.mo_coeff[0][:, :2], axis=1)
wf1, to_opt = wftools.generate_slater(mol, mf, optimize_orbitals=True)
pgrad = pyq.gradient_generator(mol, wf1, to_opt)
configs = pyq.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])
assert np.all(error[k] < epsilon)
def test_transform_wf_change(H2_casci):
mol, mf, mc = H2_casci
mc = copy.copy(mc)
mc.ci = mc.ci[0]
wf, to_opt = pyq.generate_slater(mol,
mf,
mc=mc,
optimize_determinants=True)
pgrad = pyq.gradient_generator(mol, wf, to_opt)
parameters = pgrad.transform.serialize_parameters(wf.parameters)
deserialize = pgrad.transform.deserialize(wf, parameters)
wf.parameters['det_coeff'] *= 100
parameters100 = pgrad.transform.serialize_parameters(wf.parameters)
print("reserialize100", parameters100)
deserialize100 = pgrad.transform.deserialize(wf, parameters100)
print(deserialize100['det_coeff'])
print(deserialize['det_coeff'])
assert abs(deserialize100['det_coeff'][0] -
100 * deserialize['det_coeff'][0]) < 1e-10
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)
