def setUp(self):
# optimal parameters
self.opt_r = 0.69 # the two h are at +0.69 and -0.69
self.opt_sigma = 1.24
# molecule
self.mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
unit='bohr',
calculator='pyscf',
basis='sto-3g')
# wave function
self.wf = Orbital(self.mol,
kinetic='auto',
configs='single(2,2)',
use_jastrow=True)
# sampler
self.sampler = Metropolis(nwalkers=1000,
nstep=2000,
step_size=0.5,
ndim=self.wf.ndim,
nelec=self.wf.nelec,
init=self.mol.domain('normal'),
move={
'type': 'all-elec',
'proba': 'normal'
})
self.hmc_sampler = Hamiltonian(nwalkers=100,
nstep=200,
step_size=0.1,
ndim=self.wf.ndim,
nelec=self.wf.nelec,
init=self.mol.domain('normal'))
# optimizer
self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
# solver
self.solver = SolverOrbital(wf=self.wf,
sampler=self.sampler,
optimizer=self.opt)
# ground state energy
self.ground_state_energy = -1.16
# ground state pos
self.ground_state_pos = 0.69
class TestAOvalues(unittest.TestCase):
def setUp(self):
# define the molecule
at = 'H 0 0 0; H 0 0 1'
self.mol = Molecule(atom=at,
calculator='pyscf',
basis='sto-3g',
unit='bohr')
self.m = gto.M(atom=at, basis='sto-3g', unit='bohr')
# define the wave function
self.wf = Orbital(self.mol)
self.pos = torch.zeros(100, self.mol.nelec * 3)
self.pos[:, 2] = torch.linspace(-5, 5, 100)
self.pos = Variable(self.pos)
self.pos.requires_grad = True
self.iorb = 0
self.x = self.pos[:, 2].detach().numpy()
def test_ao(self):
aovals = self.wf.ao(self.pos).detach().numpy()
aovals_ref = self.m.eval_gto('GTOval_cart',
self.pos.detach().numpy()[:, :3])
assert np.allclose(aovals[:, 0, self.iorb], aovals_ref[:, self.iorb])
def test_ao_deriv(self):
ip_aovals = self.wf.ao(self.pos, derivative=1).detach().numpy()
ip_aovals_ref = self.m.eval_gto('GTOval_ip_cart',
self.pos.detach().numpy()[:, :3])
ip_aovals_ref = ip_aovals_ref.sum(0)
assert np.allclose(ip_aovals[:, 0, self.iorb],
ip_aovals_ref[:, self.iorb])
def test_ao_hess(self):
i2p_aovals = self.wf.ao(self.pos, derivative=2).detach().numpy()
ip_aovals_ref = self.m.eval_gto('GTOval_ip_cart',
self.pos.detach().numpy()[:, :3])
ip_aovals_ref = ip_aovals_ref.sum(0)
i2p_aovals_ref = np.gradient(ip_aovals_ref[:, self.iorb], self.x)
def setUp(self):
# define the molecule
at = 'H 0 0 0; H 0 0 1'
self.mol = Molecule(atom=at,
calculator='pyscf',
basis='sto-3g',
unit='bohr')
self.m = gto.M(atom=at, basis='sto-3g', unit='bohr')
# define the wave function
self.wf = Orbital(self.mol)
self.pos = torch.zeros(100, self.mol.nelec * 3)
self.pos[:, 2] = torch.linspace(-5, 5, 100)
self.pos = Variable(self.pos)
self.pos.requires_grad = True
self.iorb = 0
self.x = self.pos[:, 2].detach().numpy()
from deepqmc.sampler.metropolis import Metropolis
from deepqmc.sampler.hamiltonian import Hamiltonian
from deepqmc.wavefunction.molecule import Molecule
from deepqmc.utils.plot_data import (load_observable, save_observalbe,
plot_block, plot_walkers_traj,
plot_energy, plot_data)
set_torch_double_precision()
# define the molecule
mol = Molecule(atom='He 0 0 0', basis_type='sto', basis='dzp', unit='bohr')
# define the wave function
wf = Orbital(mol, kinetic='jacobi', configs='cas(2,2)', use_jastrow=True)
wf.jastrow.weight.data[0] = 1.
# sampler
sampler = Metropolis(nwalkers=500,
nstep=2000,
step_size=0.05,
nelec=wf.nelec,
ndim=wf.ndim,
init=mol.domain('normal'),
move={
'type': 'all-elec',
'proba': 'normal'
},
wf=wf)
class TestH2(unittest.TestCase):
def setUp(self):
# optimal parameters
self.opt_r = 0.69 # the two h are at +0.69 and -0.69
self.opt_sigma = 1.24
# molecule
self.mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
unit='bohr',
calculator='pyscf',
basis='sto-3g')
# wave function
self.wf = Orbital(self.mol,
kinetic='auto',
configs='single(2,2)',
use_jastrow=True)
# sampler
self.sampler = Metropolis(nwalkers=1000,
nstep=2000,
step_size=0.5,
ndim=self.wf.ndim,
nelec=self.wf.nelec,
init=self.mol.domain('normal'),
move={
'type': 'all-elec',
'proba': 'normal'
})
self.hmc_sampler = Hamiltonian(nwalkers=100,
nstep=200,
step_size=0.1,
ndim=self.wf.ndim,
nelec=self.wf.nelec,
init=self.mol.domain('normal'))
# optimizer
self.opt = optim.Adam(self.wf.parameters(), lr=0.01)
# solver
self.solver = SolverOrbital(wf=self.wf,
sampler=self.sampler,
optimizer=self.opt)
# ground state energy
self.ground_state_energy = -1.16
# ground state pos
self.ground_state_pos = 0.69
def test_single_point(self):
self.solver.wf.ao.atom_coords[0, 2] = -self.ground_state_pos
self.solver.wf.ao.atom_coords[1, 2] = self.ground_state_pos
self.solver.sampler = self.sampler
# sample and compute observables
_, e, v = self.solver.single_point()
print('Energy :', e)
print('Variance :', v)
# assert(e>self.ground_state_energy and e<-1.)
assert (e > 2 * self.ground_state_energy and e < 0.)
assert (v > 0 and v < 5.)
def test_single_point_hmc(self):
self.solver.wf.ao.atom_coords[0, 2] = -self.ground_state_pos
self.solver.wf.ao.atom_coords[1, 2] = self.ground_state_pos
self.solver.sampler = self.hmc_sampler
# sample and compute observables
_, e, v = self.solver.single_point()
print('Energy :', e)
print('Variance :', v)
# assert(e>self.ground_state_energy and e<-1.)
assert (e > 2 * self.ground_state_energy and e < 0.)
assert (v > 0 and v < 5.)
def test_geo_opt(self):
self.solver.wf.ao.atom_coords[0, 2].data = torch.tensor(-0.37)
self.solver.wf.ao.atom_coords[1, 2].data = torch.tensor(0.37)
self.solver.configure(task='geo_opt')
self.solver.observable(['local_energy', 'atomic_distances'])
self.solver.run(50, loss='energy')
# load the best model
best_model = torch.load('model.pth')
self.solver.wf.load_state_dict(best_model['model_state_dict'])
self.solver.wf.eval()
# sample and compute variables
_, e, v = self.solver.single_point()
e = e.data.numpy()
v = v.data.numpy()
# it might be too much to assert with the ground state energy
assert (e > 2 * self.ground_state_energy and e < 0.)
assert (v > 0 and v < 2.)
from deepqmc.wavefunction.wf_orbital import Orbital
from deepqmc.solver.solver_orbital import SolverOrbital
#from deepqmc.solver.solver_orbital_distributed import DistSolverOrbital as SolverOrbital
from deepqmc.sampler.metropolis import Metropolis
from deepqmc.wavefunction.molecule import Molecule
from deepqmc.solver.plot_orbital import plot_molecule
from deepqmc.solver.plot_orbital import plot_molecule_mayavi as plot_molecule
from deepqmc.solver.plot_data import plot_observable
# define the molecule
mol = Molecule(atom='water.xyz', basis_type='sto', basis='sz')
# define the wave function
wf = Orbital(mol)
#sampler
sampler = Metropolis(nwalkers=100,
nstep=1000,
step_size=0.5,
ndim=wf.ndim,
nelec=wf.nelec,
move='one')
# optimizer
opt = Adam(wf.parameters(), lr=0.01)
# solver
solver = SolverOrbital(wf=wf, sampler=sampler, optimizer=opt)
pos = Variable(torch.rand(100, mol.nelec * 3))
def bend_molecule(mol, r, index=1):
mol.atom_coords[index] = (
r @ np.array(mol.atom_coords[index])).astype('float32')
return mol
# define the molecule
mol = Molecule(atom='water_line.xyz',
unit='angs',
basis_type='gto',
basis='sto-3g')
# define the wave function
wf = Orbital(mol, kinetic_jacobi=True)
# sampler
sampler = Metropolis(nwalkers=1000,
nstep=5000,
step_size=0.5,
ndim=wf.ndim,
nelec=wf.nelec,
move='one')
# solver
solver = SolverOrbital(wf=wf, sampler=sampler)
pos, e, v = solver.single_point()
sampler.nstep = 500
angles = np.linspace(0, 90, 10)
from deepqmc.sampler.metropolis import Metropolis
from deepqmc.wavefunction.molecule import Molecule
from deepqmc.solver.plot_data import plot_energy
set_torch_double_precision()
# define the molecule
mol = Molecule(atom='C 0 0 0; O 0 0 2.173',
calculator='pyscf',
basis='sto-3g',
unit='bohr')
# define the wave function
wf = Orbital(mol, kinetic='jacobi', configs='cas(4,4)', use_jastrow=True)
# sampler
sampler = Metropolis(nwalkers=1000,
nstep=1000,
step_size=0.1,
nelec=wf.nelec,
ndim=wf.ndim,
init=mol.domain('normal'),
move={
'type': 'one-elec',
'proba': 'normal'
})
# optimizer
opt = Adam(wf.parameters(), lr=0.005)
# optimal H positions +0.69 and -0.69
# ground state energy : -31.688 eV -> -1.16 hartree
# bond dissociation energy 4.478 eV -> 0.16 hartree
# set_torch_double_precision()
# define the molecule
mol = Molecule(atom='H 0 0 -0.69; H 0 0 0.69',
basis_type='gto',
basis='sto-6g',
unit='bohr')
# define the wave function
wf = Orbital(mol,
kinetic='jacobi',
configs='singlet(1,1)',
use_jastrow=True,
cuda=True)
# sampler
sampler = Metropolis(nwalkers=100,
nstep=200,
step_size=0.5,
ndim=wf.ndim,
nelec=wf.nelec,
init=mol.domain('normal'),
move={
'type': 'all-elec',
'proba': 'normal'
})
from deepqmc.wavefunction.molecule import Molecule
from deepqmc.utils.plot_data import (load_observable, save_observalbe,
plot_block, plot_walkers_traj,
plot_energy, plot_data)
set_torch_double_precision()
# define the molecule
mol = Molecule(atom='Li 0 0 0; H 0 0 3.015',
calculator='pyscf',
basis='dzp',
unit='bohr')
# define the wave function
wf = Orbital(mol, kinetic='jacobi', configs='ground_state', use_jastrow=True)
wf.jastrow.weight.data[0] = 1.
# sampler
sampler = Metropolis(nwalkers=500,
nstep=2000,
step_size=0.05,
nelec=wf.nelec,
ndim=wf.ndim,
init=mol.domain('atomic'),
move={
'type': 'all-elec',
'proba': 'normal'
},
wf=wf)