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.
 
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.
 
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.
 
std::valarray< double > compute_fQU_integrals () const
 Compute the <ij|fQU|ij> and |ij|fQU|ji> integrals.
 
std::valarray< Tensor< double > > compute_gijab_integrals (const std::valarray< vector_real_function_3d > &functions) const
 Compute the <ij|g|ab> integrals.
 
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.
 
PairEnergies compute_projected_f12_energies () const
 return 2.0 <ij|fQg|ij> - <ji|fQg|ij> as well as singlet and triplets
 
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
 
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.
 
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>
 
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
 
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.
 
size_t npairs () const
 Convenience: Get number of pairs.
 
ElectronPairIterator pit () const
 Convenience: Get electron pair iterator.
 
void print_f12_energies (const PairEnergies &pe, const std::string &msg="") const
 print_f12_energies with PairEnergies POD
 
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_3d > read_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.
 
vector_real_function_3d acmos
 Active Molecular Orbitals.
 
const BasisFunctions & basis
 all methods to create basis functions
 
std::shared_ptr< real_convolution_3d > bshop
 operator for convolutions with the bsh operator (parametrized with the exponent of the corrfac: gamma)
 
std::shared_ptr< real_convolution_3d > bshop_sq
 operator for convolutions with the bsh operator (parametrized with the exponent of the corrfac: 2*gamma)
 
std::shared_ptr< real_convolution_3d > coulombop
 operator for convolutions with the coulomb operator
 
std::shared_ptr< real_convolution_3d > fop
 operator for convolutions with the correlation factor: f12 = 1/(2*\gamma)*(1-exp(-\gamma*r_{12}))
 
std::vector< std::shared_ptr< real_derivative_3d > > gradop
 Gradient Operator.
 
ParametrizedExchange K
 Exchange Operator.
 
vector_real_function_3d mos
 Convolution with the gradient of the squared (\gamma*2) slater operator.
 
const Nemo & nemo
 all SCF data
 
F12Parameters param
 parameters
 
QProjector< double, 3 > Q
 Projector on virtual space: Q = 1-|k><k|.
 
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.
 
std::shared_ptr< real_convolution_3d > slaterop
 operator for convolutions with the slater factor exp(-\gamma*r_{12})
 
std::shared_ptr< real_convolution_3d > slaterop_sq
 operator for convolutions with the slater factor exp(-2.0*\gamma*r_{12})
 
World & world
 MPI Communicator.
 

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 
)

References acKmos, acmos, bshop, bshop_sq, madness::BSHOperatorPtr3D(), coulombop, madness::CoulombOperatorPtr(), fop, madness::PNOParameters::freeze(), madness::F12Parameters::gamma(), madness::Nemo::get_calc(), madness::get_size(), gradop, madness::GradSlaterOperator(), K, lo, MADNESS_ASSERT, nemo, madness::norm2(), madness::PNOParameters::op_thresh(), param, pow(), madness::MyTimer::print(), madness::World::rank(), madness::SlaterF12OperatorPtr(), slatergradop, slatergradop_sq, slaterop, slaterop_sq, madness::SlaterOperator(), madness::MyTimer::start(), madness::MyTimer::stop(), test1(), test2(), madness::truncate(), and world.

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

apply the regularized potential $ result = <bra|Ue-[f,K]|ket1,ket2> $ $ <bra|Ue|ket1,ket2> $ $ <bra|[f,K]|ket1,ket2> = <bra[f,K1]|ket1,ket2> + <bra[f,K2]|ket1,ket2> $ $ <bra|[f,K1]|ket1,ket2> = <bra|f|K(ket1)>*|ket2> - <K(bra)|f|ket1>*|ket2> $ <bra|[f,K2]|ket1,ket2> = <bra|f|ket1>*|K(ket2)> - |K(<bra|f|ket1>*ket2)>

References madness::apply(), convolve_with_U(), madness::PNOParameters::exchange(), fop, K, MADNESS_EXCEPTION, param, madness::MyTimer::print(), madness::World::rank(), madness::World::size(), madness::MyTimer::start(), madness::MyTimer::stop(), madness::truncate(), vi, and world.

Referenced by madness::PNO::compute_Vreg_aj_i(), and madness::PNO::compute_Vreg_aj_i().

◆ 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, compute_cijab_integrals(), npairs(), and pit().

Referenced by compute_cijab_integrals(), and compute_f12_correction().

◆ compute_cispd_f12_energies()

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

References acmos, madness::append(), madness::apply(), compute_fQg_integral(), coulombop, madness::PairEnergies::energy_f12, fop, madness::inner(), MADNESS_EXCEPTION, npairs(), pit(), Q, sum, world, and xi.

◆ 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

References compute_hylleraas_f12_energies(), compute_projected_f12_energies(), madness::F12Parameters::energytype(), madness::HYLLERAAS_ENERGYTYPE, MADNESS_EXCEPTION, npairs(), param, madness::PROJECTED_ENERGYTYPE, madness::World::rank(), and world.

◆ compute_f12_energies() [2/2]

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

References compute_hylleraas_f12_energies(), compute_projected_f12_energies(), madness::F12Parameters::energytype(), madness::HYLLERAAS_ENERGYTYPE, MADNESS_EXCEPTION, param, madness::PROJECTED_ENERGYTYPE, madness::World::rank(), and world.

Referenced by madness::PNO::solve_mp2().

◆ 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

References madness::abs(), compute_f12_pair_energies(), pit(), madness::World::rank(), and world.

Referenced by compute_hylleraas_f12_energies().

◆ 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

References acKmos, acmos, madness::apply(), madness::PNOParameters::debug(), madness::ElectronPairIterator::diagonal(), madness::WorldGopInterface::fence(), fop, madness::get_size(), madness::World::gop, madness::ElectronPairIterator::i(), madness::inner(), madness::ElectronPairIterator::j(), K, MADNESS_ASSERT, madness::mul(), param, Q, madness::World::rank(), v, and world.

Referenced by compute_fQc_integrals().

◆ 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

References madness::apply(), convolve_with_fg(), coulombop, fop, madness::inner(), k, MADNESS_ASSERT, mos, and world.

Referenced by madness::PNO::compute_cispd_f12_correction_es(), madness::PNO::compute_cispd_f12_correction_gs(), and compute_cispd_f12_energies().

◆ compute_fQg_integrals()

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

Compute the <ij|fQg|ij> and |ij|fQg|ji> integrals.

References acmos, madness::apply(), convolve_with_fg(), coulombop, fop, ij(), inner(), madness::inner(), madness::matrix_inner(), mos, madness::mul_sparse(), npairs(), pit(), madness::transpose(), madness::truncate(), and world.

Referenced by compute_f12_correction(), compute_f12_pair_energies(), and compute_projected_f12_energies().

◆ compute_fQU_integrals()

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

Compute the <ij|fQU|ij> and |ij|fQU|ji> integrals.

References acmos, madness::apply(), convolve_with_fU(), convolve_with_U(), madness::PNOParameters::debug(), fop, ij(), inner(), madness::inner(), madness::matrix_inner(), mos, madness::mul_sparse(), npairs(), param, pit(), madness::World::rank(), madness::transpose(), madness::truncate(), and world.

Referenced by compute_f12_correction(), and compute_f12_pair_energies().

◆ 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

References madness::F12Parameters::auxbas(), madness::F12Parameters::auxbas_file(), basis, compute_f12_pair_energy(), madness::QCCalculationParametersBase::get(), madness::BasisFunctions::guess_virtuals_internal(), madness::orthonormalize_rrcd(), param, pit(), madness::MyTimer::print(), Q, read_cabs_from_file(), madness::MyTimer::start(), madness::MyTimer::stop(), madness::PNOParameters::thresh(), and world.

Referenced by compute_f12_energies(), and compute_f12_energies().

◆ 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

return 2.0 <ij|fQg|ij> - <ji|fQg|ij> as well as singlet and triplets

References check(), compute_fQg_integrals(), madness::PairEnergies::eijs_f12, madness::PairEnergies::eijt_f12, energy, madness::PairEnergies::energy_f12, MADNESS_ASSERT, npairs(), pit(), madness::MyTimer::print(), madness::MyTimer::start(), madness::MyTimer::stop(), madness::PairEnergies::update(), and world.

Referenced by compute_f12_energies(), compute_f12_energies(), and madness::PNO::solve_mp2().

◆ 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 <ab|g|ij> with the regularized coulomb operator g

Ue part is not really faster than with the fluctuation potential but saves memory [K,f] part is faster as over the fluctuation potential

References acKmos, acmos, madness::apply(), axis, convolve_with_gradslater(), convolve_with_local_U(), convolve_with_U(), madness::ElectronPairIterator::diagonal(), madness::WorldGopInterface::fence(), fop, madness::F12Parameters::gamma(), madness::World::gop, madness::grad(), madness::ElectronPairIterator::i(), madness::ElectronPairIterator::j(), madness::matrix_inner(), madness::mul(), param, madness::MyTimer::print(), madness::MyTimer::start(), madness::MyTimer::stop(), madness::transpose(), vi, and world.

Referenced by madness::PNO::compute_cispd_fluctuation_matrix(), and madness::PNO::compute_fluctuation_matrix().

◆ 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

References a, madness::apply(), axis, b, convolve_with_gradslater(), convolve_with_local_U(), madness::WorldGopInterface::fence(), fop, madness::F12Parameters::gamma(), madness::World::gop, madness::grad(), madness::matrix_inner(), madness::mul(), param, madness::MyTimer::print(), madness::MyTimer::start(), madness::MyTimer::stop(), madness::transpose(), and world.

◆ 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

Compute the <xy|op|ab> integrals, op==NULL pointer means overlap: <xy|ab>

References a, madness::apply(), b, madness::matrix_inner(), madness::mul_sparse(), op(), madness::truncate(), and world.

Referenced by compute_cijab_integrals(), madness::PNO::compute_cispd_fluctuation_matrix(), compute_fijab_integrals(), and compute_ijab_integrals().

◆ 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, function(), 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

References madness::apply(), bshop, coulombop, madness::F12Parameters::gamma(), param, madness::constants::pi, madness::truncate(), and world.

◆ 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(), 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

References convolve_with_local_U(), and function().

Referenced by compute_regularized_fluctuation_matrix(), compute_regularized_fluctuation_matrix(), convolve_with_fU(), convolve_with_local_U(), convolve_with_U(), 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

References convolve_with_fg(), convolve_with_slater_potential(), madness::F12Parameters::gamma(), param, madness::truncate(), and world.

◆ 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
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

References convolve_with_nonlocal_U().

Referenced by convolve_with_fU(), convolve_with_nonlocal_U(), convolve_with_U(), 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

References axis, convolve_with_gradslater(), madness::F12Parameters::gamma(), gradop, madness::mul_sparse(), param, madness::World::size(), madness::truncate(), and world.

◆ 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

Compute the applied Ue potential $ <bra|Ue|ket1,ket2>_1 = <bra|Ulocal|ket1,ket2> + <bra|Unlocal|ket1,ket2> $

References convolve_with_local_U(), convolve_with_nonlocal_U(), and madness::truncate().

Referenced by apply_regularized_potential(), compute_fQU_integrals(), compute_regularized_fluctuation_matrix(), and compute_uijab_integrals().

◆ 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

References convolve_with_local_U(), convolve_with_nonlocal_U(), madness::mul_sparse(), madness::MyTimer::print(), madness::MyTimer::start(), madness::MyTimer::stop(), madness::truncate(), and world.

◆ initialize_active_mos()

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

References madness::PNOParameters::freeze(), madness::Nemo::get_calc(), MADNESS_ASSERT, mos, nemo, and param.

◆ 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

Convenience: Get number of pairs.

References acmos.

Referenced by compute_cijab_integrals(), compute_cispd_f12_energies(), compute_f12_correction(), compute_f12_energies(), compute_f12_pair_energies(), compute_fQc_integrals(), compute_fQg_integrals(), compute_fQU_integrals(), compute_ijab_integrals(), compute_projected_f12_energies(), madness::PNO::iterate_pairs_internal(), and madness::PNO::solve_mp2().

◆ pit()

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

Convenience: Get electron pair iterator.

References acmos, madness::PNOParameters::freeze(), and param.

Referenced by compute_cijab_integrals(), compute_cispd_f12_energies(), compute_f12_correction(), compute_f12_pair_energies(), compute_f12_pair_energy(), compute_fQc_integrals(), compute_fQg_integrals(), compute_fQU_integrals(), compute_hylleraas_f12_energies(), compute_ijab_integrals(), compute_projected_f12_energies(), madness::PNO::iterate_pairs_internal(), madness::PNO::pit(), print_pair_energies(), madness::PNO::t_solve(), madness::PNO::transform_pairs(), and madness::PNO::update_pno().

◆ print_f12_energies()

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

print_f12_energies with PairEnergies POD

References madness::PairEnergies::eijs_f12, madness::PairEnergies::eijt_f12, and print_pair_energies().

Referenced by madness::PNO::solve_mp2().

◆ print_pair_energies() [1/2]

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

convenience for formated printing

Parameters
[in]essinglet pair energies
[in]ettriplet pair energies

References madness::CISPD_PAIRTYPE, madness::PairEnergies::eijs, madness::PairEnergies::eijs_f12, madness::PairEnergies::eijt, madness::PairEnergies::eijt_f12, madness::PNOPairs::energies, madness::PairEnergies::energy, madness::PairEnergies::energy_f12, print_pair_energies(), madness::World::rank(), madness::PairEnergies::total_energy(), madness::PNOPairs::type, and world.

Referenced by compute_f12_correction(), compute_f12_pair_energies(), print_f12_energies(), print_pair_energies(), madness::PNO::solve_cispd(), madness::PNO::solve_mp2(), and madness::PNO::t_solve().

◆ 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

References madness::CISPD_PAIRTYPE, madness::PNOParameters::freeze(), param, pit(), madness::print(), madness::World::rank(), madness::type(), and world.

◆ read_cabs_from_file()

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

References madness::append(), madness::atomic_number_to_symbol(), madness::F12Parameters::auxbas_file(), basis, e(), madness::filename, madness::Nemo::get_calc(), madness::BasisFunctions::guess_virtual_gaussian_shell(), nemo, param, madness::MyTimer::print(), madness::print_size(), Q, madness::World::rank(), madness::BasisFunctions::read_basis_from_file(), madness::MyTimer::start(), madness::MyTimer::stop(), and world.

Referenced by compute_hylleraas_f12_energies().

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

Active Molecular Orbitals.

Referenced by F12Potentials(), compute_cijab_integrals(), madness::PNO::compute_CIS_potentials(), madness::PNO::compute_cispd_correction_es(), madness::PNO::compute_cispd_correction_gs(), madness::PNO::compute_cispd_f12_correction_es(), madness::PNO::compute_cispd_f12_correction_gs(), compute_cispd_f12_energies(), madness::PNO::compute_cispd_fluctuation_matrix(), madness::PNO::compute_cispd_fluctuation_potential(), compute_fijab_integrals(), madness::PNO::compute_fluctuation_matrix(), madness::PNO::compute_fluctuation_potential(), compute_fQc_integrals_ij(), compute_fQg_integrals(), compute_fQU_integrals(), compute_ijab_integrals(), madness::PNO::compute_projected_mp2_energies(), compute_regularized_fluctuation_matrix(), compute_uijab_integrals(), madness::PNO::compute_Vreg_aj_i(), madness::PNO::compute_Vreg_aj_i_commutator_response(), madness::PNO::iterate_pairs_internal(), npairs(), pit(), madness::PNO::solve(), madness::PNO::solve_cispd(), and madness::PNO::solve_mp2().

◆ 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(), 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

operator for convolutions with the coulomb operator

Referenced by F12Potentials(), compute_cispd_f12_energies(), compute_fQg_integral(), compute_fQg_integrals(), compute_gijab_integrals(), and convolve_with_fg().

◆ fop

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

operator for convolutions with the correlation factor: f12 = 1/(2*\gamma)*(1-exp(-\gamma*r_{12}))

Referenced by F12Potentials(), apply_regularized_potential(), compute_cijab_integrals(), madness::PNO::compute_cispd_f12_correction_es(), madness::PNO::compute_cispd_f12_correction_gs(), compute_cispd_f12_energies(), madness::PNO::compute_cispd_fluctuation_matrix(), compute_fijab_integrals(), compute_fijab_integrals(), compute_fQc_integrals_ij(), compute_fQg_integral(), compute_fQg_integrals(), compute_fQU_integrals(), compute_regularized_fluctuation_matrix(), compute_regularized_fluctuation_matrix(), madness::PNO::compute_Vreg_aj_i_commutator_response(), and madness::PNO::compute_Vreg_aj_i_fock_residue().

◆ 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

Exchange Operator.

Referenced by F12Potentials(), apply_regularized_potential(), compute_cijab_integrals(), and compute_fQc_integrals_ij().

◆ 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

all SCF data

Referenced by F12Potentials(), initialize_active_mos(), and read_cabs_from_file().

◆ param

F12Parameters madness::F12Potentials::param

parameters

Referenced by F12Potentials(), madness::PNO::PNO(), apply_regularized_potential(), compute_f12_correction(), compute_f12_energies(), compute_f12_energies(), compute_fQc_integrals_ij(), compute_fQU_integrals(), compute_hylleraas_f12_energies(), compute_regularized_fluctuation_matrix(), compute_regularized_fluctuation_matrix(), convolve_with_fg(), convolve_with_fg(), convolve_with_fU(), convolve_with_local_U(), convolve_with_nonlocal_U(), madness::PNO::energytype(), initialize_active_mos(), pit(), print_pair_energies(), read_cabs_from_file(), madness::PNO::solve(), and madness::PNO::solve_mp2().

◆ Q

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

Projector on virtual space: Q = 1-|k><k|.

Referenced by compute_cispd_f12_energies(), compute_fQc_integrals_ij(), compute_hylleraas_f12_energies(), and read_cabs_from_file().

◆ slatergradop

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

Referenced by F12Potentials(), and convolve_with_gradslater().

◆ 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

MPI Communicator.

Referenced by F12Potentials(), apply_regularized_potential(), compute_cispd_f12_energies(), compute_f12_energies(), compute_f12_energies(), compute_f12_pair_energy(), compute_fQc_integrals_ij(), compute_fQg_integral(), compute_fQg_integrals(), compute_fQU_integrals(), compute_hylleraas_f12_energies(), compute_projected_f12_energies(), compute_regularized_fluctuation_matrix(), compute_regularized_fluctuation_matrix(), compute_uijab_integrals(), compute_xyab_integrals(), convolve_with_fg(), convolve_with_fU(), convolve_with_gradslater(), convolve_with_local_U(), convolve_with_nonlocal_U(), convolve_with_slater_potential(), convolve_with_U(), print_pair_energies(), print_pair_energies(), and read_cabs_from_file().

The documentation for this class was generated from the following files:
Generated on Thu Dec 19 2024 21:22:55 for MADNESS by doxygen 1.9.8