qmctorch.wavefunction.slater_jastrow module
- class qmctorch.wavefunction.slater_jastrow.SlaterJastrow(*args: Any, **kwargs: Any)[source]
Bases:
WaveFunctionSlater Jastrow wave function with electron-electron Jastrow factor
\[\Psi(R_{at}, r) = J(r)\sum_n c_n D^\uparrow_n(r^\uparrow)D^\downarrow_n(r^\downarrow)\]with
\[J(r) = \exp\left( K_{ee}(r) \right)\]with K, a kernel function depending only on the electron-eletron distances
- Parameters:
mol (Molecule) – a QMCTorch molecule object
jastrow (JastrowKernelBase, optional) – Class that computes the jastrow kernels
backflow (BackFlowKernelBase, optional) – kernel function of the backflow transformation
configs (str, optional) – defines the CI configurations to be used. Defaults to ‘ground_state’. - ground_state : only the ground state determinant in the wave function - single(n,m) : only single excitation with n electrons and m orbitals - single_double(n,m) : single and double excitation with n electrons and m orbitals - cas(n, m) : all possible configuration using n eletrons and m orbitals
kinetic (str, optional) – method to compute the kinetic energy. Defaults to ‘jacobi’. - jacobi : use the Jacobi formula to compute the kinetic energy - auto : use automatic differentiation to compute the kinetic energy
cuda (bool, optional) – turns GPU ON/OFF Defaults to False..
include_all_mo (bool, optional) – include either all molecular orbitals or only the ones that are popualted in the configs. Defaults to False
- Examples::
>>> from qmctorch.scf import Molecule >>> from qmctorch.wavefunction import SlaterJastrow >>> mol = Molecule('h2o.xyz', calculator='adf', basis = 'dzp') >>> wf = SlaterJastrow(mol, configs='cas(2,2)')
- init_config(configs)[source]
Initialize the electronic configurations desired in the wave function.
- forward(x, ao=None)[source]
computes the value of the wave function for the sampling points
\[\Psi(R) = J(R) \sum_{n} c_n D^{u}_n(r^u) \times D^{d}_n(r^d)\]- Parameters:
x (torch.tensor) – sampling points (Nbatch, 3*Nelec)
ao (torch.tensor, optional) – values of the atomic orbitals (Nbatch, Nelec, Nao)
- Returns:
values of the wave functions at each sampling point (Nbatch, 1)
- Return type:
torch.tensor
- Examples::
>>> mol = Molecule('h2.xyz', calculator='adf', basis = 'dzp') >>> wf = SlaterJastrow(mol, configs='cas(2,2)') >>> pos = torch.rand(500,6) >>> vals = wf(pos)
- kinetic_energy_jacobi(x, **kwargs)[source]
Compute the value of the kinetic enery using the Jacobi Formula. C. Filippi, Simple Formalism for Efficient Derivatives .
\[\frac{\Delta \Psi(R)}{\Psi(R)} = \Psi(R)^{-1} \sum_n c_n (\frac{\Delta D_n^u}{D_n^u} + \frac{\Delta D_n^d}{D_n^d}) D_n^u D_n^d\]We compute the laplacian of the determinants through the Jacobi formula
\[\frac{\Delta \det(A)}{\det(A)} = Tr(A^{-1} \Delta A)\]Here \(A = J(R) \phi\) and therefore :
\[\Delta A = (\Delta J) D + 2 \nabla J \nabla D + (\Delta D) J\]- Parameters:
x (torch.tensor) – sampling points (Nbatch, 3*Nelec)
- Returns:
values of the kinetic energy at each sampling points
- Return type:
torch.tensor
- gradients_jacobi(x, sum_grad=False, pdf=False)[source]
Compute the gradients of the wave function (or density) using the Jacobi Formula C. Filippi, Simple Formalism for Efficient Derivatives.
\[\frac{K(R)}{\Psi(R)} = Tr(A^{-1} B_{grad})\]The gradients of the wave function
\[\Psi(R) = J(R) \sum_n c_n D^{u}_n D^{d}_n = J(R) \Sigma\]are computed following
\[\nabla \Psi(R) = \left( \nabla J(R) \right) \Sigma + J(R) \left(\nabla \Sigma \right)\]with
\[\nabla \Sigma = \sum_n c_n (\frac{\nabla D^u_n}{D^u_n} + \frac{\nabla D^d_n}{D^d_n}) D^u_n D^d_n\]that we compute with the Jacobi formula as:
\[\nabla \Sigma = \sum_n c_n (Tr( (D^u_n)^{-1} \nabla D^u_n) + Tr( (D^d_n)^{-1} \nabla D^d_n)) D^u_n D^d_n\]- Parameters:
x (torch.tensor) – sampling points (Nbatch, 3*Nelec)
pdf (bool, optional) – if true compute the grads of the density
- Returns:
values of the gradients wrt the walker pos at each sampling points
- Return type:
torch.tensor
- get_kinetic_operator(x, ao, dao, d2ao, mo)[source]
Compute the Bkin matrix
- Parameters:
x (torch.tensor) – sampling points (Nbatch, 3*Nelec)
mo (torch.tensor, optional) – precomputed values of the MOs
- Returns:
matrix of the kinetic operator
- Return type:
torch.tensor
- kinetic_energy_jacobi_backflow(x, **kwargs)[source]
Compute the value of the kinetic enery using the Jacobi Formula.
\[\begin{split}\\frac{\Delta (J(R) \Psi(R))}{ J(R) \Psi(R)} = \\frac{\\Delta J(R)}{J(R} + 2 \\frac{\\nabla J(R)}{J(R)} \\frac{\\nabla \\Psi(R)}{\\Psi(R)} + \\frac{\\Delta \\Psi(R)}{\\Psi(R)}\end{split}\]The lapacian of the determinental part is computed via
\[\begin{split}\\Delta_i \\Psi(R) \\sum_n c_n ( \\frac{\\Delta_i D_n^{u}}{D_n^{u}} + \\frac{\\Delta_i D_n^{d}}{D_n^{d}} + 2 \\frac{\\nabla_i D_n^{u}}{D_n^{u}} \\frac{\\nabla_i D_n^{d}}{D_n^{d}} ) D_n^{u} D_n^{d}\end{split}\]Since the backflow orbitals are multi-electronic the laplacian of the determinants are obtained
\[\begin{split}\\frac{\\Delta det(A)}{det(A)} = Tr(A^{-1} \\Delta A) + Tr(A^{-1} \\nabla A) Tr(A^{-1} \\nabla A) + Tr( (A^{-1} \\nabla A) (A^{-1} \\nabla A ))\end{split}\]- Parameters:
x (torch.tensor) – sampling points (Nbatch, 3*Nelec)
- Returns:
values of the kinetic energy at each sampling points
- Return type:
torch.tensor
- gradients_jacobi_backflow(x, sum_grad=True, pdf=False)[source]
Computes the gradients of the wf using Jacobi’s Formula
- Parameters:
x ([type]) – [description]