MADNESS 0.10.1
Classes | Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
madness::XCOperator< T, NDIM > Class Template Reference

operator class for the handling of DFT exchange-correlation functionals More...

#include <SCFOperators.h>

Inheritance diagram for madness::XCOperator< T, NDIM >:
Inheritance graph
[legend]
Collaboration diagram for madness::XCOperator< T, NDIM >:
Collaboration graph
[legend]

Classes

struct  expme
 simple structure to take the pointwise exponential of a function, shifted by +14 More...
 
struct  logme
 simple structure to take the pointwise logarithm of a function, shifted by +14 More...
 

Public Member Functions

 XCOperator (World &world)
 default ctor without information about the XC functional
 
 XCOperator (World &world, const Nemo *nemo, int ispin=0)
 ctor with a Nemo calculation, will initialize the necessary intermediates
 
 XCOperator (World &world, const Nemo *scf, const real_function_3d &arho, const real_function_3d &brho, int ispin=0)
 ctor with an Nemo calculation, will initialize the necessary intermediates
 
 XCOperator (World &world, const SCF *scf, const real_function_3d &arho, const real_function_3d &brho, int ispin=0, std::string deriv="abgv")
 ctor with an SCF calculation, will initialize the necessary intermediates
 
 XCOperator (World &world, const SCF *scf, int ispin=0, std::string deriv="abgv")
 ctor with an SCF calculation, will initialize the necessary intermediates
 
 XCOperator (World &world, std::shared_ptr< XCfunctional > xc, const bool spin_polarized, int ispin, int nbeta, const real_function_3d &arho, const real_function_3d &brho, std::string deriv="abgv")
 custom ctor with the XC functional
 
 XCOperator (World &world, std::string xc_data, const bool spin_polarized, const real_function_3d &arho, const real_function_3d &brho, std::string deriv="abgv")
 custom ctor with information about the XC functional
 
std::vector< Function< T, NDIM > > apply_tau_term (const std::vector< Function< T, NDIM > > &vket) const
 apply the non-multiplicative meta-gga term on a set of orbitals
 
real_function_3d apply_xc_kernel (const real_function_3d &density, const vecfuncT grad_dens_pt=vecfuncT()) const
 construct the xc kernel and apply it directly on the (response) density
 
double compute_xc_energy () const
 compute the xc energy using the precomputed intermediates vf and delrho
 
real_function_3d get_tau (const int spin=0) const
 the kinetic energy density of one spin channel, as set by set_tau()
 
real_function_3d get_vtau () const
 de/dtau, as computed by make_xc_potential()
 
bool has_tau_term () const
 true if the functional contributes a non-multiplicative (meta-gga) term
 
std::string info () const
 print some information about this operator
 
real_function_3d make_xc_potential () const
 return the local xc potential
 
T operator() (const Function< T, NDIM > &bra, const Function< T, NDIM > &ket) const
 compute the matrix element <bra | op | ket>
 
Function< T, NDIM > operator() (const Function< T, NDIM > &ket) const
 apply the xc potential on an orbitals
 
Tensor< T > operator() (const std::vector< Function< T, NDIM > > &vbra, const std::vector< Function< T, NDIM > > &vket) const
 
std::vector< Function< T, NDIM > > operator() (const std::vector< Function< T, NDIM > > &vket) const
 apply the xc potential on a set of orbitals
 
XCOperator & set_extra_truncation (const double &fac)
 
void set_ispin (const int i) const
 set the spin state this operator is acting on
 
XCOperator & set_print_level (const int p)
 print the meta-gga de/dtau range each time the operator is applied
 
void set_tau (const vecfuncT &amo, const Tensor< double > &aocc, const vecfuncT &bmo=vecfuncT(), const Tensor< double > &bocc=Tensor< double >()) const
 compute the kinetic energy density and add it to the intermediates
 
- Public Member Functions inherited from madness::SCFOperatorBase< T, NDIM >
 SCFOperatorBase ()=default
 
 SCFOperatorBase (std::shared_ptr< MacroTaskQ > taskq)
 
virtual ~SCFOperatorBase ()
 
virtual tensorT operator() (const vecfuncT &vbra, const vecfuncT &vket) const =0
 compute the matrix <vbra | op | vket>
 
virtual vecfuncT operator() (const vecfuncT &vket) const =0
 apply this operator on the argument vector of functions
 

Public Attributes

std::shared_ptr< XCfunctional > xc
 interface to the actual XC functionals
 
- Public Attributes inherited from madness::SCFOperatorBase< T, NDIM >
nlohmann::json statistics
 
std::shared_ptr< MacroTaskQ > taskq =0
 

Private Member Functions

bool is_initialized () const
 check if the intermediates are initialized
 
std::shared_ptr< Derivative< T, NDIM > > make_derivative (const int axis) const
 gradient operator honouring dft_deriv, for the meta-gga term
 
vecfuncT prep_xc_args (const real_function_3d &arho, const real_function_3d &brho) const
 compute the intermediates for the XC functionals
 
void prep_xc_args_response (const real_function_3d &dens_pt, vecfuncT &xc_args, vecfuncT &ddens_pt) const
 compute the intermediates for the XC functionals
 

Private Attributes

std::string dft_deriv
 which derivative operator to use
 
double extra_truncation
 additional truncation for the densities in the XC kernel
 
int ispin
 the XC functionals depend on the spin of the orbitals they act on
 
int nbeta
 number of beta orbitals
 
std::shared_ptr< NuclearCorrelationFactor > ncf
 the nuclear correlation factor, if it exists, for computing derivatives for GGA
 
int print_level =0
 print level; >=2 logs the meta-gga de/dtau range
 
real_function_3d vtau
 de/dtau, the prefactor of the non-multiplicative meta-gga term
 
World & world
 the world
 
vecfuncT xc_args
 functions that are need for the computation of the XC operator
 

Additional Inherited Members

- Public Types inherited from madness::SCFOperatorBase< T, NDIM >
typedef Function< T, NDIM > functionT
 
typedef Tensor< T > tensorT
 
typedef std::vector< functionT > vecfuncT
 

Detailed Description

template<typename T, std::size_t NDIM>
class madness::XCOperator< T, NDIM >

operator class for the handling of DFT exchange-correlation functionals

Constructor & Destructor Documentation

◆ XCOperator() [1/7]

template<typename T , std::size_t NDIM>
madness::XCOperator< T, NDIM >::XCOperator ( World &  world)
inline

default ctor without information about the XC functional

◆ XCOperator() [2/7]

template<typename T , std::size_t NDIM>
madness::XCOperator< T, NDIM >::XCOperator ( World &  world,
std::string  xc_data,
const bool  spin_polarized,
const real_function_3d &  arho,
const real_function_3d &  brho,
std::string  deriv = "abgv" 
)

custom ctor with information about the XC functional

References madness::XCOperator< T, NDIM >::nbeta, madness::Function< T, NDIM >::norm2(), madness::XCOperator< T, NDIM >::prep_xc_args(), madness::XCOperator< T, NDIM >::world, madness::XCOperator< T, NDIM >::xc, and madness::XCOperator< T, NDIM >::xc_args.

◆ XCOperator() [3/7]

template<typename T , std::size_t NDIM>
madness::XCOperator< T, NDIM >::XCOperator ( World &  world,
std::shared_ptr< XCfunctional >  xc,
const bool  spin_polarized,
int  ispin,
int  nbeta,
const real_function_3d &  arho,
const real_function_3d &  brho,
std::string  deriv = "abgv" 
)

custom ctor with the XC functional

References madness::XCOperator< T, NDIM >::prep_xc_args(), and madness::XCOperator< T, NDIM >::xc_args.

◆ XCOperator() [4/7]

template<typename T , std::size_t NDIM>
madness::XCOperator< T, NDIM >::XCOperator ( World &  world,
const SCF *  scf,
int  ispin = 0,
std::string  deriv = "abgv" 
)

ctor with an SCF calculation, will initialize the necessary intermediates

References madness::SCF::amo, madness::SCF::aocc, madness::SCF::bmo, madness::SCF::bocc, madness::SCF::make_density(), madness::CalculationParameters::nbeta(), madness::XCOperator< T, NDIM >::nbeta, madness::SCF::param, madness::XCOperator< T, NDIM >::prep_xc_args(), madness::CalculationParameters::spin_restricted(), madness::XCOperator< T, NDIM >::world, madness::CalculationParameters::xc(), madness::XCOperator< T, NDIM >::xc, and madness::XCOperator< T, NDIM >::xc_args.

◆ XCOperator() [5/7]

template<typename T , std::size_t NDIM>
madness::XCOperator< T, NDIM >::XCOperator ( World &  world,
const Nemo *  nemo,
int  ispin = 0 
)

ctor with a Nemo calculation, will initialize the necessary intermediates

References ncf::ncf(), madness::XCOperator< T, NDIM >::extra_truncation, madness::XCOperator< T, NDIM >::nbeta, madness::nemo, madness::XCOperator< T, NDIM >::prep_xc_args(), madness::truncate(), madness::XCOperator< T, NDIM >::world, madness::XCOperator< T, NDIM >::xc, and madness::XCOperator< T, NDIM >::xc_args.

◆ XCOperator() [6/7]

template<typename T , std::size_t NDIM>
madness::XCOperator< T, NDIM >::XCOperator ( World &  world,
const SCF *  scf,
const real_function_3d &  arho,
const real_function_3d &  brho,
int  ispin = 0,
std::string  deriv = "abgv" 
)

ctor with an SCF calculation, will initialize the necessary intermediates

References madness::SCF::param, madness::CalculationParameters::spin_restricted(), madness::XCOperator< T, NDIM >::world, madness::CalculationParameters::xc(), and madness::XCOperator< T, NDIM >::xc.

◆ XCOperator() [7/7]

template<typename T , std::size_t NDIM>
madness::XCOperator< T, NDIM >::XCOperator ( World &  world,
const Nemo *  scf,
const real_function_3d &  arho,
const real_function_3d &  brho,
int  ispin = 0 
)

ctor with an Nemo calculation, will initialize the necessary intermediates

References madness::nemo, madness::XCOperator< T, NDIM >::world, and madness::XCOperator< T, NDIM >::xc.

Member Function Documentation

◆ apply_tau_term()

template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > > madness::XCOperator< T, NDIM >::apply_tau_term ( const std::vector< Function< T, NDIM > > &  vket) const

apply the non-multiplicative meta-gga term on a set of orbitals

apply the non-multiplicative meta-gga term, -1/2 sum_x D_x(vtau D_x psi_i)

\[ \hat v_\tau \psi_i = -\frac{1}{2}\nabla\cdot \left(\frac{\partial e_{xc}}{\partial\tau_\sigma}\nabla\psi_i\right) \]

evaluated as $ -\frac{1}{2}\sum_x D_x(v_\tau D_x\psi_i) $, so that $ v_\tau $ is only ever multiplied and never differentiated. That nested form is also self-adjoint by construction, while the expanded $ -\frac{1}{2}(v_\tau\nabla^2\psi + \nabla v_\tau\cdot\nabla\psi) $ is symmetric only up to discretization error and needs $\nabla^2\psi$. Requires make_xc_potential() to have been called first, which is where $ v_\tau $ is computed.

References madness::add(), madness::apply(), axis, madness::copy(), madness::FunctionDefaults< NDIM >::get_cell_width(), madness::FunctionDefaults< NDIM >::get_thresh(), L, lo, MADNESS_CHECK_THROW, madness::Tensor< T >::max(), madness::mul_sparse(), madness::print(), madness::refine(), madness::scale(), madness::truncate(), and v.

◆ apply_xc_kernel()

template<typename T , std::size_t NDIM>
real_function_3d madness::XCOperator< T, NDIM >::apply_xc_kernel ( const real_function_3d &  dens_pt,
const vecfuncT  grad_dens_pt = vecfuncT() 
) const

construct the xc kernel and apply it directly on the (response) density

apply the xc kernel on a perturbed density

the xc kernel is the second derivative of the xc functions wrt the density

Parameters
[in]densitythe (response) density on which the kernel is applied
Returns
kernel * density

cf Eq. (13) of T. Yanai, R. J. Harrison, and N. Handy, “Multiresolution quantum chemistry in multiwavelet bases: time-dependent density functional theory with asymptotically corrected potentials in local density and generalized gradient approximations,” Mol. Phys., vol. 103, no. 2, pp. 413–424, 2005.

the application of the xc kernel is (RHF only)

\[ \frac{\partial^2E_{xc}}{\partial \rho_\alpha^2}\circ\tilde\rho = second_{local} + second_{semilocal} + first_{semilocal} \]

where the second partial derivatives are

\[ second_{local} = \frac{\partial^2 f_{xc}}{\partial \rho_\alpha^2}\tilde \rho + 2\frac{\partial^2 f_{xc}}{\partial \rho_\alpha\sigma_{\alpha\alpha}} \left(\vec\nabla \rho_a\cdot \vec \nabla\tilde\rho\right) \]

the second partial derivatives that need to be multiplied with the density gradients

\[ second_{semilocal} = -\vec\nabla\cdot\left((\vec\nabla\rho) \left[2\frac{\partial^2 f_{xc}}{\partial\rho_\alpha\partial\sigma_{\alpha\alpha}}\tilde\rho + 4\frac{\partial^2 f_{xc}}{\partial\sigma_{\alpha\alpha}^2} \left(\vec\nabla\rho_\alpha\cdot\vec\nabla\tilde\rho\right)\right]\right) \]

and the first derivatives that need to be multiplied with the density gradients

\[ first_{semilocal} = -\vec\nabla\cdot\left(2\frac{\partial f_{xc}}{\partial\sigma_{\alpha\alpha}}\vec\nabla\tilde\rho\right) \]

References madness::div(), madness::XCfunctional::is_gga(), madness::XCfunctional::is_spin_polarized(), MADNESS_ASSERT, MADNESS_EXCEPTION, madness::multi_to_multi_op_values(), op(), madness::refine_to_common_level(), madness::Function< T, NDIM >::truncate(), madness::truncate(), and xc.

◆ compute_xc_energy()

template<typename T , std::size_t NDIM>
double madness::XCOperator< T, NDIM >::compute_xc_energy ( ) const

compute the xc energy using the precomputed intermediates vf and delrho

References madness::XCfunctional::enum_taua, MADNESS_EXCEPTION, madness::refine_to_common_level(), madness::Function< T, NDIM >::trace(), madness::truncate(), and xc.

Referenced by madness::Nemo::compute_energy_regularized(), and test_XCOperator().

◆ get_tau()

template<typename T , std::size_t NDIM>
real_function_3d madness::XCOperator< T, NDIM >::get_tau ( const int  spin = 0) const

the kinetic energy density of one spin channel, as set by set_tau()

exposed for diagnostics and for the exact check int(tau) == T

References madness::XCfunctional::enum_taua, and madness::XCfunctional::enum_taub.

Referenced by test_meta_gga().

◆ get_vtau()

template<typename T , std::size_t NDIM>
real_function_3d madness::XCOperator< T, NDIM >::get_vtau ( ) const
inline

de/dtau, as computed by make_xc_potential()

References madness::XCOperator< T, NDIM >::vtau.

◆ has_tau_term()

template<typename T , std::size_t NDIM>
bool madness::XCOperator< T, NDIM >::has_tau_term ( ) const

true if the functional contributes a non-multiplicative (meta-gga) term

References madness::XCfunctional::needs_tau(), and xc.

◆ info()

template<typename T , std::size_t NDIM>
std::string madness::XCOperator< T, NDIM >::info ( ) const
inlinevirtual

print some information about this operator

Implements madness::SCFOperatorBase< T, NDIM >.

◆ is_initialized()

template<typename T , std::size_t NDIM>
bool madness::XCOperator< T, NDIM >::is_initialized ( ) const
inlineprivate

check if the intermediates are initialized

References madness::XCOperator< T, NDIM >::xc_args.

◆ make_derivative()

template<typename T , std::size_t NDIM>
std::shared_ptr< Derivative< T, NDIM > > madness::XCOperator< T, NDIM >::make_derivative ( const int  axis) const
private

gradient operator honouring dft_deriv, for the meta-gga term

gradient operator for the meta-gga term, honouring dft_deriv

References axis.

◆ make_xc_potential()

template<typename T , std::size_t NDIM>
real_function_3d madness::XCOperator< T, NDIM >::make_xc_potential ( ) const

return the local xc potential

References madness::div(), madness::XCfunctional::enum_taua, madness::XCfunctional::is_spin_polarized(), MADNESS_EXCEPTION, madness::multi_to_multi_op_values(), madness::XCfunctional::needs_sigma(), op(), madness::refine_to_common_level(), madness::Function< T, NDIM >::truncate(), madness::truncate(), and xc.

Referenced by madness::Nemo::compute_nemo_potentials(), madness::Nemo::make_fock_operator(), and test_XCOperator().

◆ operator()() [1/4]

template<typename T , std::size_t NDIM>
T madness::XCOperator< T, NDIM >::operator() ( const Function< T, NDIM > &  bra,
const Function< T, NDIM > &  ket 
) const
inlinevirtual

compute the matrix element <bra | op | ket>

Parameters
brabra state
ketket state
Returns
the matrix element <bra | op | ket>

Implements madness::SCFOperatorBase< T, NDIM >.

References MADNESS_EXCEPTION.

◆ operator()() [2/4]

template<typename T , std::size_t NDIM>
Function< T, NDIM > madness::XCOperator< T, NDIM >::operator() ( const Function< T, NDIM > &  ket) const
inlinevirtual

apply the xc potential on an orbitals

Implements madness::SCFOperatorBase< T, NDIM >.

References madness::XCOperator< T, NDIM >::operator()().

◆ operator()() [3/4]

template<typename T , std::size_t NDIM>
Tensor< T > madness::XCOperator< T, NDIM >::operator() ( const std::vector< Function< T, NDIM > > &  vbra,
const std::vector< Function< T, NDIM > > &  vket 
) const
inline

References MADNESS_EXCEPTION.

◆ operator()() [4/4]

template<typename T , std::size_t NDIM>
std::vector< Function< T, NDIM > > madness::XCOperator< T, NDIM >::operator() ( const std::vector< Function< T, NDIM > > &  vket) const

apply the xc potential on a set of orbitals

References madness::FunctionDefaults< NDIM >::get_thresh(), and madness::mul_sparse().

Referenced by madness::XCOperator< T, NDIM >::operator()().

◆ prep_xc_args()

template<typename T , std::size_t NDIM>
vecfuncT madness::XCOperator< T, NDIM >::prep_xc_args ( const real_function_3d &  arho,
const real_function_3d &  brho 
) const
private

compute the intermediates for the XC functionals

prepare xc args

Parameters
[in]arhodensity of the alpha orbitals
[in]brhodensity of the beta orbitals (necessary only if spin-polarized)
Returns
xc_args vector of intermediates as described above

References madness::copy(), madness::XCfunctional::enum_rhoa, madness::XCfunctional::enum_rhob, madness::XCfunctional::enum_zetaa_x, madness::XCfunctional::enum_zetaa_y, madness::XCfunctional::enum_zetaa_z, madness::XCfunctional::enum_zetab_x, madness::XCfunctional::enum_zetab_y, madness::XCfunctional::enum_zetab_z, madness::WorldGopInterface::fence(), madness::World::gop, madness::grad(), madness::grad_ble_one(), madness::grad_bspline_one(), madness::XCfunctional::is_spin_polarized(), madness::XCfunctional::needs_sigma(), madness::XCfunctional::number_xc_args, madness::Function< T, NDIM >::reconstruct(), madness::truncate(), madness::unary_op(), madness::Function< T, NDIM >::world(), and xc.

Referenced by madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), and madness::XCOperator< T, NDIM >::XCOperator().

◆ prep_xc_args_response()

template<typename T , std::size_t NDIM>
void madness::XCOperator< T, NDIM >::prep_xc_args_response ( const real_function_3d &  dens_pt,
vecfuncT &  xc_args,
vecfuncT &  ddens_pt 
) const
private

compute the intermediates for the XC functionals

add intermediates for the response kernels to xc_args

Parameters
[in]dens_ptperturbed densities from CPHF or TDDFT equations
[in,out]xc_argsvector of intermediates as described above
[out]ddens_ptxyz-derivatives of dens_pt

References madness::dot(), madness::XCfunctional::enum_ddens_ptx, madness::XCfunctional::enum_ddens_pty, madness::XCfunctional::enum_ddens_ptz, madness::XCfunctional::enum_rho_pt, madness::XCfunctional::enum_sigma_pta_div_rho, madness::XCfunctional::enum_sigma_ptb_div_rho, madness::XCfunctional::enum_zetaa_x, madness::XCfunctional::enum_zetaa_y, madness::XCfunctional::enum_zetaa_z, madness::XCfunctional::enum_zetab_x, madness::XCfunctional::enum_zetab_y, madness::XCfunctional::enum_zetab_z, madness::WorldGopInterface::fence(), madness::World::gop, madness::grad(), madness::XCfunctional::is_gga(), madness::XCfunctional::is_spin_polarized(), madness::print(), madness::truncate(), madness::Function< T, NDIM >::world(), xc, and zeta.

◆ set_extra_truncation()

template<typename T , std::size_t NDIM>
XCOperator & madness::XCOperator< T, NDIM >::set_extra_truncation ( const double &  fac)
inline

References madness::XCOperator< T, NDIM >::extra_truncation, madness::print(), madness::World::rank(), and madness::XCOperator< T, NDIM >::world.

◆ set_ispin()

template<typename T , std::size_t NDIM>
void madness::XCOperator< T, NDIM >::set_ispin ( const int  i) const
inline

set the spin state this operator is acting on

References madness::XCOperator< T, NDIM >::ispin.

Referenced by test_XCOperator().

◆ set_print_level()

template<typename T , std::size_t NDIM>
XCOperator & madness::XCOperator< T, NDIM >::set_print_level ( const int  p)
inline

print the meta-gga de/dtau range each time the operator is applied

References p(), and madness::XCOperator< T, NDIM >::print_level.

◆ set_tau()

template<typename T , std::size_t NDIM>
void madness::XCOperator< T, NDIM >::set_tau ( const vecfuncT &  amo,
const Tensor< double > &  aocc,
const vecfuncT &  bmo = vecfuncT(),
const Tensor< double > &  bocc = Tensor<double>() 
) const

compute the kinetic energy density and add it to the intermediates

compute tau = 1/2 sum_i |grad psi_i|^2 and store it in the intermediates

tau is orbital-dependent, so unlike the density it cannot be recovered from what the ctors are given – it has to be supplied separately. Call this after construction and before make_xc_potential() whenever has_tau_term() is true; make_xc_potential() throws otherwise. The occupation numbers are required, not optional: amo/bmo may carry virtual orbitals (occupation zero), which contribute nothing to the density but would inflate an unweighted sum of |grad psi|^2, and occupations may be fractional.

Parameters
[in]amoalpha orbitals (nemos if a nuclear correlation factor is set)
[in]aoccoccupation numbers of amo
[in]bmobeta orbitals, ignored if the calculation is spin-restricted
[in]boccoccupation numbers of bmo

References MADNESS_CHECK_THROW.

Referenced by test_meta_gga().

Member Data Documentation

◆ dft_deriv

template<typename T , std::size_t NDIM>
std::string madness::XCOperator< T, NDIM >::dft_deriv
private

which derivative operator to use

◆ extra_truncation

template<typename T , std::size_t NDIM>
double madness::XCOperator< T, NDIM >::extra_truncation
private

additional truncation for the densities in the XC kernel

the densities in the DFT kernal are processed as their inverses, so noise in the small density regions might amplify and lead to inaccurate results. Extra truncation will tighten the truncation threshold by a specified factor, default is 0.01.

Referenced by madness::XCOperator< T, NDIM >::XCOperator(), and madness::XCOperator< T, NDIM >::set_extra_truncation().

◆ ispin

template<typename T , std::size_t NDIM>
int madness::XCOperator< T, NDIM >::ispin
mutableprivate

the XC functionals depend on the spin of the orbitals they act on

Referenced by madness::XCOperator< T, NDIM >::set_ispin().

◆ nbeta

template<typename T , std::size_t NDIM>
int madness::XCOperator< T, NDIM >::nbeta
private

number of beta orbitals

Referenced by madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), and madness::XCOperator< T, NDIM >::XCOperator().

◆ ncf

template<typename T , std::size_t NDIM>
std::shared_ptr<NuclearCorrelationFactor> madness::XCOperator< T, NDIM >::ncf
private

the nuclear correlation factor, if it exists, for computing derivatives for GGA

◆ print_level

template<typename T , std::size_t NDIM>
int madness::XCOperator< T, NDIM >::print_level =0
private

print level; >=2 logs the meta-gga de/dtau range

Referenced by madness::XCOperator< T, NDIM >::set_print_level().

◆ vtau

template<typename T , std::size_t NDIM>
real_function_3d madness::XCOperator< T, NDIM >::vtau
mutableprivate

de/dtau, the prefactor of the non-multiplicative meta-gga term

falls out of the same pointwise pass as the multiplicative potential, so it is stashed by make_xc_potential() rather than recomputed

Referenced by madness::XCOperator< T, NDIM >::get_vtau().

◆ world

template<typename T , std::size_t NDIM>
World& madness::XCOperator< T, NDIM >::world
private

the world

Referenced by madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), and madness::XCOperator< T, NDIM >::set_extra_truncation().

◆ xc

template<typename T , std::size_t NDIM>
std::shared_ptr<XCfunctional> madness::XCOperator< T, NDIM >::xc

interface to the actual XC functionals

Referenced by madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), and madness::XCOperator< T, NDIM >::XCOperator().

◆ xc_args

template<typename T , std::size_t NDIM>
vecfuncT madness::XCOperator< T, NDIM >::xc_args
mutableprivate

functions that are need for the computation of the XC operator

the ordering of the intermediates is fixed, but the code can handle non-initialized functions, so if e.g. no GGA is requested, all the corresponding vector components may be left empty. For the ordering of the intermediates see xcfunctional::xc_arg

Referenced by madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), madness::XCOperator< T, NDIM >::XCOperator(), and madness::XCOperator< T, NDIM >::is_initialized().

The documentation for this class was generated from the following files:
Generated on Sun Sep 6 2026 03:34:23 for MADNESS by doxygen 1.9.8