MADNESS  0.10.1
Public Member Functions | Public Attributes | List of all members
madness::F12Potentials Class Reference

Class that provides all necessary F12 Potentials and Integrals. More...

#include <PNOF12Potentials.h>

Collaboration diagram for madness::F12Potentials:
Collaboration graph
[legend]

Public Member Functions

 F12Potentials (World &world, const Nemo &nemo, const BasisFunctions &basis, const F12Parameters &pp)
 
vector_real_function_3d apply_regularized_potential (const real_function_3d &moi, const real_function_3d &moj, const real_function_3d Ki, const real_function_3d &Kj, const vector_real_function_3d &bra, const vector_real_function_3d &Kpno) const
 
Tensor< double > compute_cijab_integrals (const size_t &i, const size_t &j, const real_function_3d &Ki, const real_function_3d &Kj, const vector_real_function_3d &functions) const
 
std::valarray< Tensor< double > > compute_cijab_integrals (const std::valarray< vector_real_function_3d > &functions) const
 Compute the <ab|[f,K]|ij> integrals. More...
 
PairEnergies compute_cispd_f12_energies (const vector_real_function_3d xcis) const
 
PairEnergies compute_f12_correction (const std::valarray< vector_real_function_3d > &pnos, const std::valarray< vector_real_function_3d > &abs) const
 
PairEnergies compute_f12_energies () const
 
PairEnergies compute_f12_energies (const std::valarray< vector_real_function_3d > &pnos) const
 
PairEnergies compute_f12_pair_energies (const std::valarray< vector_real_function_3d > &abs) const
 
PairEnergies compute_f12_pair_energy (const std::valarray< vector_real_function_3d > &pnos, const std::valarray< vector_real_function_3d > &abs) const
 
Tensor< double > compute_fijab_integrals (const size_t &i, const size_t &j, const vector_real_function_3d &functions) const
 
std::valarray< Tensor< double > > compute_fijab_integrals (const std::valarray< vector_real_function_3d > &functions) const
 Compute the <ij|f|ab> integrals. More...
 
std::valarray< double > compute_fQc_integrals (const vector_real_function_3d &Kmos, const std::valarray< vector_real_function_3d > &functions) const
 
std::pair< double, double > compute_fQc_integrals_ij (const vector_real_function_3d &Kmos, const vector_real_function_3d &functions, const ElectronPairIterator &it, const bool &use_no_intermediates=false) const
 
double compute_fQg_integral (const real_function_3d bra1, const real_function_3d &bra2, const real_function_3d &ket1, const real_function_3d &ket2, const bool &diagonal=false) const
 
std::valarray< double > compute_fQg_integrals () const
 Compute the <ij|fQg|ij> and |ij|fQg|ji> integrals. More...
 
std::valarray< double > compute_fQU_integrals () const
 Compute the <ij|fQU|ij> and |ij|fQU|ji> integrals. More...
 
std::valarray< Tensor< double > > compute_gijab_integrals (const std::valarray< vector_real_function_3d > &functions) const
 Compute the <ij|g|ab> integrals. More...
 
PairEnergies compute_hylleraas_f12_energies (const std::valarray< vector_real_function_3d > &pnos) const
 
std::valarray< Tensor< double > > compute_ijab_integrals (const std::valarray< vector_real_function_3d > &functions, const std::shared_ptr< real_convolution_3d > &op) const
 Compute the <ij|op|ab> integrals. More...
 
PairEnergies compute_projected_f12_energies () const
 return 2.0 <ij|fQg|ij> - <ji|fQg|ij> as well as singlet and triplets More...
 
Tensor< double > compute_regularized_fluctuation_matrix (const ElectronPairIterator &it, const vector_real_function_3d &pnos, const vector_real_function_3d &Kpnos) const
 compute <ab|g|ij> with the regularized coulomb operator g More...
 
Tensor< double > compute_regularized_fluctuation_matrix (const std::pair< vector_real_function_3d, vector_real_function_3d > &KPNOA, const std::pair< vector_real_function_3d, vector_real_function_3d > &KPNOB, const std::pair< real_function_3d, real_function_3d > &MKI, const std::pair< real_function_3d, real_function_3d > MKJ) const
 
Tensor< double > compute_uijab_integrals (const size_t &i, const size_t &j, const vector_real_function_3d &functions) const
 Compute the <ab|Ue|ij> Integrals. More...
 
Tensor< double > compute_xyab_integrals (const real_function_3d &x, const real_function_3d &y, const vector_real_function_3d &a, const vector_real_function_3d &b, const std::shared_ptr< real_convolution_3d > &op, const bool diagonal=false) const
 Compute the <xy|op|ab> integrals, op==NULL pointer means overlap: <xy|ab> More...
 
real_function_3d convolve_with_fg (const real_function_3d &function) const
 
vector_real_function_3d convolve_with_fg (const vector_real_function_3d &functions) const
 
real_function_3d convolve_with_fU (const real_function_3d &bra, const real_function_3d &ket1, const real_function_3d &ket2, const bool symmetric=false) const
 
vector_real_function_3d convolve_with_fU (const vector_real_function_3d &bra, const real_function_3d &ket1, const real_function_3d &ket2, const bool symmetric=false) const
 
vector_real_function_3d convolve_with_gradslater (const vector_real_function_3d functions, const size_t axis, const bool &squared=false) const
 convolve with the gradient of the slater potential or the squared slater potential More...
 
real_function_3d convolve_with_local_U (const real_function_3d &function) const
 
vector_real_function_3d convolve_with_local_U (const vector_real_function_3d &functions) const
 
real_function_3d convolve_with_nonlocal_U (const real_function_3d &bra, const real_function_3d &ket1, const real_function_3d &ket2, const bool symmetric=false, const bool &squared=false) const
 
vector_real_function_3d convolve_with_nonlocal_U (const vector_real_function_3d &bra, const real_function_3d &ket1, const real_function_3d &ket2, const bool symmetric=false, const bool &squared=false) const
 
vector_real_function_3d convolve_with_slater_potential (const vector_real_function_3d &functions) const
 
real_function_3d convolve_with_U (const real_function_3d &bra, const real_function_3d &ket1, const real_function_3d &ket2, const bool symmetric=false) const
 
vector_real_function_3d convolve_with_U (const vector_real_function_3d &bra, const real_function_3d &ket1, const real_function_3d &ket2, const bool symmetric=false) const
 
vector_real_function_3d initialize_active_mos (const madness::Nemo &nemo) const
 
double inner (const Tensor< double > &A, const Tensor< double > &B) const
 Inner product for X_ab Tensors. Convenience. More...
 
size_t npairs () const
 Convenience: Get number of pairs. More...
 
ElectronPairIterator pit () const
 Convenience: Get electron pair iterator. More...
 
void print_f12_energies (const PairEnergies &pe, const std::string &msg="") const
 print_f12_energies with PairEnergies POD More...
 
void print_pair_energies (const PNOPairs &pairs, const std::string &msg="") const
 
void print_pair_energies (const std::valarray< double > &es, const std::valarray< double > &et, const std::string &msg="", const PairType &type=UNKNOWN_PAIRTYPE) const
 
std::vector< real_function_3dread_cabs_from_file (const std::string &filename) const
 

Public Attributes

vector_real_function_3d acKmos
 Intermediate for K(active_mos) (takes approx. as much memory than the mos itself. Since mos<<<#PNOs this should not be a problem. More...
 
vector_real_function_3d acmos
 Active Molecular Orbitals. More...
 
const BasisFunctionsbasis
 all methods to create basis functions More...
 
std::shared_ptr< real_convolution_3dbshop
 operator for convolutions with the bsh operator (parametrized with the exponent of the corrfac: gamma) More...
 
std::shared_ptr< real_convolution_3dbshop_sq
 operator for convolutions with the bsh operator (parametrized with the exponent of the corrfac: 2*gamma) More...
 
std::shared_ptr< real_convolution_3dcoulombop
 operator for convolutions with the coulomb operator More...
 
std::shared_ptr< real_convolution_3dfop
 operator for convolutions with the correlation factor: f12 = 1/(2*\gamma)*(1-exp(-\gamma*r_{12})) More...
 
std::vector< std::shared_ptr< real_derivative_3d > > gradop
 Gradient Operator. More...
 
ParametrizedExchange K
 Exchange Operator. More...
 
vector_real_function_3d mos
 Convolution with the gradient of the squared (\gamma*2) slater operator. More...
 
const Nemonemo
 all SCF data More...
 
F12Parameters param
 parameters More...
 
QProjector< double, 3 > Q
 Projector on virtual space: Q = 1-|k><k|. More...
 
std::vector< std::shared_ptr< real_convolution_3d > > slatergradop
 
std::vector< std::shared_ptr< real_convolution_3d > > slatergradop_sq
 Convolution with the gradient of the slater operator. More...
 
std::shared_ptr< real_convolution_3dslaterop
 operator for convolutions with the slater factor exp(-\gamma*r_{12}) More...
 
std::shared_ptr< real_convolution_3dslaterop_sq
 operator for convolutions with the slater factor exp(-2.0*\gamma*r_{12}) More...
 
Worldworld
 MPI Communicator. More...
 

Detailed Description

Class that provides all necessary F12 Potentials and Integrals.

Constructor & Destructor Documentation

◆ F12Potentials()

madness::F12Potentials::F12Potentials ( World world,
const Nemo nemo,
const BasisFunctions basis,
const F12Parameters pp 
)

Member Function Documentation

◆ apply_regularized_potential()

vector_real_function_3d madness::F12Potentials::apply_regularized_potential ( const real_function_3d moi,
const real_function_3d moj,
const real_function_3d  Ki,
const real_function_3d Kj,
const vector_real_function_3d bra,
const vector_real_function_3d Kpno 
) const

◆ compute_cijab_integrals() [1/2]

Tensor< double > madness::F12Potentials::compute_cijab_integrals ( const size_t &  i,
const size_t &  j,
const real_function_3d Ki,
const real_function_3d Kj,
const vector_real_function_3d functions 
) const

References acmos, compute_xyab_integrals(), fop, and K.

◆ compute_cijab_integrals() [2/2]

std::valarray< Tensor< double > > madness::F12Potentials::compute_cijab_integrals ( const std::valarray< vector_real_function_3d > &  functions) const

Compute the <ab|[f,K]|ij> integrals.

References acKmos, npairs(), and pit().

Referenced by compute_f12_correction().

◆ compute_cispd_f12_energies()

PairEnergies madness::F12Potentials::compute_cispd_f12_energies ( const vector_real_function_3d  xcis) const
inline

◆ compute_f12_correction()

PairEnergies madness::F12Potentials::compute_f12_correction ( const std::valarray< vector_real_function_3d > &  pnos,
const std::valarray< vector_real_function_3d > &  abs 
) const

Compute the f12 pair energy if Ansatz 1 is used This means: Normal MRA-PNO-MP2 calculation + F12 Correction Old Code Currently: Neglect Commutator if no abs is given if abs_u is true then fQU part is also neglected (RI with PNOs as virtuals: fQU ~= fVU => fQU - fVU ~= 0) EF12 = <ij|(fQg-fVg + fUg - fVg)|2ij-ji>

References madness::abs(), madness::F12Parameters::abs_c(), madness::F12Parameters::abs_u(), compute_cijab_integrals(), compute_fijab_integrals(), compute_fQg_integrals(), compute_fQU_integrals(), compute_gijab_integrals(), compute_uijab_integrals(), madness::PairEnergies::eijs_f12, madness::PairEnergies::eijt_f12, madness::PairEnergies::energy_f12, inner(), npairs(), param, pit(), print_pair_energies(), madness::Tensor< T >::reshape(), and madness::transpose().

◆ compute_f12_energies() [1/2]

PairEnergies madness::F12Potentials::compute_f12_energies ( ) const

◆ compute_f12_energies() [2/2]

PairEnergies madness::F12Potentials::compute_f12_energies ( const std::valarray< vector_real_function_3d > &  pnos) const

◆ compute_f12_pair_energies()

PairEnergies madness::F12Potentials::compute_f12_pair_energies ( const std::valarray< vector_real_function_3d > &  abs) const

Compute the f12 pair energy if Ansatz 2 is used This means: Regularized MRA-PNO-MP2-F12 calculation We use RI for the integrals with the exchange commutator in two steps: 1. PNOs as approx for Q, 2. Correction with ABS set (either auto generated or from file) EF12 =<ij|(fQg + fQU - fQ[f,K])(2|ij> - |ji>)

References madness::abs(), acKmos, compute_fQc_integrals(), compute_fQg_integrals(), compute_fQU_integrals(), madness::PairEnergies::eijs_f12, madness::PairEnergies::eijt_f12, energy, madness::PairEnergies::energy_f12, npairs(), pit(), and print_pair_energies().

Referenced by compute_f12_pair_energy().

◆ compute_f12_pair_energy()

PairEnergies madness::F12Potentials::compute_f12_pair_energy ( const std::valarray< vector_real_function_3d > &  pnos,
const std::valarray< vector_real_function_3d > &  abs 
) const

◆ compute_fijab_integrals() [1/2]

Tensor<double> madness::F12Potentials::compute_fijab_integrals ( const size_t &  i,
const size_t &  j,
const vector_real_function_3d functions 
) const
inline

References acmos, compute_xyab_integrals(), and fop.

◆ compute_fijab_integrals() [2/2]

std::valarray<Tensor<double> > madness::F12Potentials::compute_fijab_integrals ( const std::valarray< vector_real_function_3d > &  functions) const
inline

Compute the <ij|f|ab> integrals.

References compute_ijab_integrals(), and fop.

Referenced by compute_f12_correction().

◆ compute_fQc_integrals()

std::valarray< double > madness::F12Potentials::compute_fQc_integrals ( const vector_real_function_3d Kmos,
const std::valarray< vector_real_function_3d > &  functions 
) const

Compute the fQc integrals with ABS used as: Q12 = Q*|a><a| K1f: <i|fja|x>, with fja = <a|f|j> and x=QK(<a|f|j>*i) K2f: <i|fja|y>, with y = Q(<Ka|f|j>*i fK2: <i|fja|z>, with z = Q(<a|f|Kj>*i) (note: actually no abs needed for fK1) fK1: <i|fja|w>, with w = Q(<a|f|j>*Ki)

References compute_fQc_integrals_ij(), npairs(), and pit().

Referenced by compute_f12_pair_energies().

◆ compute_fQc_integrals_ij()

std::pair< double, double > madness::F12Potentials::compute_fQc_integrals_ij ( const vector_real_function_3d Kmos,
const vector_real_function_3d functions,
const ElectronPairIterator it,
const bool &  use_no_intermediates = false 
) const

◆ compute_fQg_integral()

double madness::F12Potentials::compute_fQg_integral ( const real_function_3d  bra1,
const real_function_3d bra2,
const real_function_3d ket1,
const real_function_3d ket2,
const bool &  diagonal = false 
) const

◆ compute_fQg_integrals()

std::valarray< double > madness::F12Potentials::compute_fQg_integrals ( ) const

◆ compute_fQU_integrals()

std::valarray< double > madness::F12Potentials::compute_fQU_integrals ( ) const

◆ compute_gijab_integrals()

std::valarray<Tensor<double> > madness::F12Potentials::compute_gijab_integrals ( const std::valarray< vector_real_function_3d > &  functions) const
inline

Compute the <ij|g|ab> integrals.

References compute_ijab_integrals(), and coulombop.

Referenced by compute_f12_correction().

◆ compute_hylleraas_f12_energies()

PairEnergies madness::F12Potentials::compute_hylleraas_f12_energies ( const std::valarray< vector_real_function_3d > &  pnos) const

◆ compute_ijab_integrals()

std::valarray< Tensor< double > > madness::F12Potentials::compute_ijab_integrals ( const std::valarray< vector_real_function_3d > &  functions,
const std::shared_ptr< real_convolution_3d > &  op 
) const

Compute the <ij|op|ab> integrals.

References acmos, compute_xyab_integrals(), npairs(), op(), and pit().

Referenced by compute_fijab_integrals(), and compute_gijab_integrals().

◆ compute_projected_f12_energies()

PairEnergies madness::F12Potentials::compute_projected_f12_energies ( ) const

◆ compute_regularized_fluctuation_matrix() [1/2]

Tensor< double > madness::F12Potentials::compute_regularized_fluctuation_matrix ( const ElectronPairIterator it,
const vector_real_function_3d pnos,
const vector_real_function_3d Kpnos 
) const

◆ compute_regularized_fluctuation_matrix() [2/2]

Tensor< double > madness::F12Potentials::compute_regularized_fluctuation_matrix ( const std::pair< vector_real_function_3d, vector_real_function_3d > &  KPNOA,
const std::pair< vector_real_function_3d, vector_real_function_3d > &  KPNOB,
const std::pair< real_function_3d, real_function_3d > &  MKI,
const std::pair< real_function_3d, real_function_3d MKJ 
) const

◆ compute_uijab_integrals()

Tensor<double> madness::F12Potentials::compute_uijab_integrals ( const size_t &  i,
const size_t &  j,
const vector_real_function_3d functions 
) const
inline

Compute the <ab|Ue|ij> Integrals.

References acmos, convolve_with_U(), madness::matrix_inner(), and world.

Referenced by compute_f12_correction().

◆ compute_xyab_integrals()

Tensor< double > madness::F12Potentials::compute_xyab_integrals ( const real_function_3d x,
const real_function_3d y,
const vector_real_function_3d a,
const vector_real_function_3d b,
const std::shared_ptr< real_convolution_3d > &  op,
const bool  diagonal = false 
) const

◆ convolve_with_fg() [1/2]

real_function_3d madness::F12Potentials::convolve_with_fg ( const real_function_3d function) const
Returns
$ \int dx2 f12*g12*f(2) $
Parameters
[in]functionfunction on which f*g operator is applied right now we use: fg = 1/(2*gamma)*(g - 4*pi*G(gamma)) todo: implement fg operator directly (may be cheaper)
Returns
$ \int dx2 f12*g12*f(2) $
Parameters
[in]functionfunction on which f*g operator is applied right now we use: fg = 1/(2*gamma)*(g - 4*pi*G(gamma)) todo: implement fg operator (may be cheaper)

References bshop, madness::F12Parameters::gamma(), param, madness::constants::pi, and madness::Function< T, NDIM >::truncate().

Referenced by compute_fQg_integral(), compute_fQg_integrals(), and convolve_with_local_U().

◆ convolve_with_fg() [2/2]

vector_real_function_3d madness::F12Potentials::convolve_with_fg ( const vector_real_function_3d functions) const

◆ convolve_with_fU() [1/2]

real_function_3d madness::F12Potentials::convolve_with_fU ( const real_function_3d bra,
const real_function_3d ket1,
const real_function_3d ket2,
const bool  symmetric = false 
) const
inline

References convolve_with_fU().

◆ convolve_with_fU() [2/2]

vector_real_function_3d madness::F12Potentials::convolve_with_fU ( const vector_real_function_3d bra,
const real_function_3d ket1,
const real_function_3d ket2,
const bool  symmetric = false 
) const

Convolution with f*U This breaks apart into the convolution with: $ f*U = 1/(2\gamma)*(U - e^{-\gamma*r_{12}} $ local part: (could be further simplified by combining the BSH Operators of Ulocal the expression below) $ f*U^{\mbox{loc}} = 1/(2\gamma)*(U^{\mbox{loc}} - 4\pi*G(\gamma) + 4\pi*G(2\gamma) - \gamma/2 (e^{-2\gamma*r_{12}} ) nonlocal part: $ f*U^{\mbox{nloc}} = 1/(2\gamma)*(U^{\mbox{nloc}}(\gamma) - U^{\mbox{nloc}}(2\gamma))

References madness::apply(), bshop, bshop_sq, convolve_with_local_U(), convolve_with_nonlocal_U(), madness::PNOParameters::debug(), madness::F12Parameters::gamma(), madness::mul_sparse(), madness::norm2(), param, madness::constants::pi, madness::World::rank(), madness::scale(), madness::World::size(), slaterop_sq, madness::truncate(), and world.

Referenced by compute_fQU_integrals(), and convolve_with_fU().

◆ convolve_with_gradslater()

vector_real_function_3d madness::F12Potentials::convolve_with_gradslater ( const vector_real_function_3d  functions,
const size_t  axis,
const bool &  squared = false 
) const
inline

convolve with the gradient of the slater potential or the squared slater potential

References madness::apply(), axis, slatergradop, slatergradop_sq, and world.

Referenced by compute_regularized_fluctuation_matrix(), and convolve_with_nonlocal_U().

◆ convolve_with_local_U() [1/2]

real_function_3d madness::F12Potentials::convolve_with_local_U ( const real_function_3d function) const
inline
Returns
$ \int dr2 (1-e^{-gamma*r12})/r12 + gamma/2* e^{-\gamma*r12} *function(r2) $ we use: 1-e^{-gamma*r12})/r12 = 2*gamma*f12*g12

Referenced by compute_regularized_fluctuation_matrix(), convolve_with_fU(), and convolve_with_U().

◆ convolve_with_local_U() [2/2]

vector_real_function_3d madness::F12Potentials::convolve_with_local_U ( const vector_real_function_3d functions) const

◆ convolve_with_nonlocal_U() [1/2]

real_function_3d madness::F12Potentials::convolve_with_nonlocal_U ( const real_function_3d bra,
const real_function_3d ket1,
const real_function_3d ket2,
const bool  symmetric = false,
const bool &  squared = false 
) const
Returns
$ -1.0/2.0*<bra(1)|e^{-gamma*r_{12}}/r_{12}* \vec{r_{12}}\cdot (\nabla_1 - \nabla_2)[axis]|ket1,ket2>_1 $
Parameters
[in]brano derivatives (for nemo-style orbitals this should be multiplied with R^2 beforehand)
[in]ket1this is the part (for electron 1) where the derivative operators will partially act on and over which the integration variable will run
[in]ket2this is the part (for electron 2) where the derivative operators will partially act on, no integration over this variable
[in]symmetricif ket1 and ket2 are the same functions (little speedup because the gradient has to be calculated only once)
[in]squaredfactor for gamma: a*\gamma. Default is just 1.0. if true then a=2 We use the following relations: 1.0/2.0*e^{-\gamma*r_{12}}*\vec{r_{12}}/r_{12} = 1.0/(2.0*\gamma) \nabla_2(e^{-\gamma*r_{12}}) = -1.0/(2.0*\gamma) \nabla_1(e^{-\gamma*r_{12}}) = -1.0/(2.0*\gamma) \nabla_{12}(e^{-\gamma*r_{12}} ) so we can use the gradient of the SlaterOperator Grad(e^{-\gamma*r} with this we have $ -1.0/2.0*<bra|e^{-gamma*r12}/r12* \vec{r12}\cdot (\nabla_1 - \nabla_2)[axis]|ket> = 1.0/(2.0*\gamma)*<bra|Grad(e^{-\gamma*r_{12}})\cdot (\nabla_1 - \nabla_2)[axis]|ket1,ket2>_{particle} $ todo: Partial integration may lead to more efficient scheme without the Gradient of the SlaterOperator

Referenced by convolve_with_fU(), and convolve_with_U().

◆ convolve_with_nonlocal_U() [2/2]

vector_real_function_3d madness::F12Potentials::convolve_with_nonlocal_U ( const vector_real_function_3d bra,
const real_function_3d ket1,
const real_function_3d ket2,
const bool  symmetric = false,
const bool &  squared = false 
) const

◆ convolve_with_slater_potential()

vector_real_function_3d madness::F12Potentials::convolve_with_slater_potential ( const vector_real_function_3d functions) const
inline
Returns
convolution with the slater potential which is $ V_{slater} = \exp{(-\gamma*r_{12})} $
Parameters
[in]function-> operator is applied onto this funciton if nemo-style orbitals are used the bra element has to be multiplied with R^2 beforehand

References madness::apply(), slaterop, and world.

Referenced by convolve_with_local_U().

◆ convolve_with_U() [1/2]

real_function_3d madness::F12Potentials::convolve_with_U ( const real_function_3d bra,
const real_function_3d ket1,
const real_function_3d ket2,
const bool  symmetric = false 
) const

◆ convolve_with_U() [2/2]

vector_real_function_3d madness::F12Potentials::convolve_with_U ( const vector_real_function_3d bra,
const real_function_3d ket1,
const real_function_3d ket2,
const bool  symmetric = false 
) const

◆ initialize_active_mos()

vector_real_function_3d madness::F12Potentials::initialize_active_mos ( const madness::Nemo nemo) const
inline

◆ inner()

double madness::F12Potentials::inner ( const Tensor< double > &  A,
const Tensor< double > &  B 
) const
inline

Inner product for X_ab Tensors. Convenience.

Referenced by compute_f12_correction(), compute_fQg_integrals(), and compute_fQU_integrals().

◆ npairs()

size_t madness::F12Potentials::npairs ( ) const
inline

◆ pit()

ElectronPairIterator madness::F12Potentials::pit ( ) const
inline

◆ print_f12_energies()

void madness::F12Potentials::print_f12_energies ( const PairEnergies pe,
const std::string &  msg = "" 
) const
inline

◆ print_pair_energies() [1/2]

void madness::F12Potentials::print_pair_energies ( const PNOPairs pairs,
const std::string &  msg = "" 
) const

◆ print_pair_energies() [2/2]

void madness::F12Potentials::print_pair_energies ( const std::valarray< double > &  es,
const std::valarray< double > &  et,
const std::string &  msg = "",
const PairType type = UNKNOWN_PAIRTYPE 
) const

◆ read_cabs_from_file()

std::vector< real_function_3d > madness::F12Potentials::read_cabs_from_file ( const std::string &  filename) const

Member Data Documentation

◆ acKmos

vector_real_function_3d madness::F12Potentials::acKmos

Intermediate for K(active_mos) (takes approx. as much memory than the mos itself. Since mos<<<#PNOs this should not be a problem.

Referenced by F12Potentials(), compute_cijab_integrals(), madness::PNO::compute_cispd_fluctuation_matrix(), compute_f12_pair_energies(), compute_fQc_integrals_ij(), compute_regularized_fluctuation_matrix(), and madness::PNO::compute_Vreg_aj_i().

◆ acmos

vector_real_function_3d madness::F12Potentials::acmos

◆ basis

const BasisFunctions& madness::F12Potentials::basis

all methods to create basis functions

Referenced by compute_hylleraas_f12_energies(), and read_cabs_from_file().

◆ bshop

std::shared_ptr<real_convolution_3d> madness::F12Potentials::bshop

operator for convolutions with the bsh operator (parametrized with the exponent of the corrfac: gamma)

Referenced by F12Potentials(), convolve_with_fg(), and convolve_with_fU().

◆ bshop_sq

std::shared_ptr<real_convolution_3d> madness::F12Potentials::bshop_sq

operator for convolutions with the bsh operator (parametrized with the exponent of the corrfac: 2*gamma)

Referenced by F12Potentials(), and convolve_with_fU().

◆ coulombop

std::shared_ptr<real_convolution_3d> madness::F12Potentials::coulombop

◆ fop

std::shared_ptr<real_convolution_3d> madness::F12Potentials::fop

◆ gradop

std::vector< std::shared_ptr< real_derivative_3d > > madness::F12Potentials::gradop

Gradient Operator.

Referenced by F12Potentials(), and convolve_with_nonlocal_U().

◆ K

ParametrizedExchange madness::F12Potentials::K

◆ mos

vector_real_function_3d madness::F12Potentials::mos

Convolution with the gradient of the squared (\gamma*2) slater operator.

all molecular orbitals (needed for Q projection parts)

Referenced by compute_fQg_integral(), compute_fQg_integrals(), compute_fQU_integrals(), and initialize_active_mos().

◆ nemo

const Nemo& madness::F12Potentials::nemo

◆ param

F12Parameters madness::F12Potentials::param

◆ Q

QProjector<double, 3> madness::F12Potentials::Q

◆ slatergradop

std::vector< std::shared_ptr< real_convolution_3d > > madness::F12Potentials::slatergradop

◆ slatergradop_sq

std::vector< std::shared_ptr< real_convolution_3d > > madness::F12Potentials::slatergradop_sq

Convolution with the gradient of the slater operator.

Referenced by F12Potentials(), and convolve_with_gradslater().

◆ slaterop

std::shared_ptr<real_convolution_3d> madness::F12Potentials::slaterop

operator for convolutions with the slater factor exp(-\gamma*r_{12})

Referenced by F12Potentials(), and convolve_with_slater_potential().

◆ slaterop_sq

std::shared_ptr<real_convolution_3d> madness::F12Potentials::slaterop_sq

operator for convolutions with the slater factor exp(-2.0*\gamma*r_{12})

Referenced by F12Potentials(), and convolve_with_fU().

◆ world

World& madness::F12Potentials::world

The documentation for this class was generated from the following files: