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

#include <SCFOperators.h>

Inheritance diagram for madness::XCOperator< T, NDIM >:

Collaboration diagram for madness::XCOperator< T, NDIM >:

[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 Types
enum class	TauU1 { mra , pointwise }
	compute the kinetic energy density and add it to the intermediates More...
Public Types inherited from madness::SCFOperatorBase< T, NDIM >
typedef Function< T, NDIM >	functionT
typedef Tensor< T >	tensorT
typedef std::vector< functionT >	vecfuncT

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::shared_ptr< NuclearCorrelationFactor > ncf_, const real_function_3d &arho_reg_, const real_function_3d &brho_reg_, std::string deriv="abgv")
	ctor for the regularized (nemo) path, without a Nemo object
	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
XCOperator &	allow_weak_form ()
	opt in to the weak form, if the xc_weak_gga parameter asks for it
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
const vecfuncT &	get_semilocal_flux () const
	the semilocal flux X = 2 (de/dsigma_ss) grad(rho_s) + (de/dsigma_ab) grad(rho_s')
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_vlocal () const
	the multiplicative part of the potential, as make_xc_potential() returned it
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
bool	is_weak_form () const
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
	the xc contribution to the Fock matrix, as a matrix element
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
	the xc contribution to the Fock matrix
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 TauU1 u1mode=TauU1::pointwise) const
	compute tau = 1/2 sum_i \|grad psi_i\|^2 and store it in the intermediates
XCOperator &	set_weak_gga (const bool flag)
	override CalculationParameters::xc_weak_gga(), for callers without one
void	weak_xc_terms (const std::vector< Function< T, NDIM > > &vket, std::vector< Function< T, NDIM > > &mult, std::vector< std::vector< Function< T, NDIM > > > &flux) const
	weak-form split of the non-multiplicative xc terms
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
real_function_3d	div_dft_deriv (const vecfuncT &v) const
	divergence of a vector field, honouring dft_deriv
bool	has_tau_args () const
	true once set_tau() has supplied tau, by either route
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
nemo_u1_functors	make_u1_functors () const
	the four analytic U1 quantities the xc ops evaluate pointwise
real_function_3d	make_xc_potential_impl () const
	the body of make_xc_potential(); the wrapper only stashes vlocal
vecfuncT	prep_xc_args (const real_function_3d &arho, const real_function_3d &brho, const real_function_3d &arho_reg=real_function_3d(), const real_function_3d &brho_reg=real_function_3d()) 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
vecfuncT	semilocal_flux
	the semilocal flux, assigned by make_xc_potential() in weak form only
real_function_3d	vlocal
	the multiplicative potential, stashed by make_xc_potential()
real_function_3d	vtau
	de/dtau, the prefactor of the non-multiplicative meta-gga term
bool	weak_form_ok =false
	caller has opted in to the weak form, see allow_weak_form()
bool	weak_gga =false
	the user asked for the weak form: CalculationParameters::xc_weak_gga()
World &	world
	the world
vecfuncT	xc_args
	functions that are need for the computation of the XC operator

Detailed Description

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

operator class for the handling of DFT exchange-correlation functionals

Member Enumeration Documentation

◆ TauU1

template<typename T, std::size_t NDIM>

enum class madness::XCOperator::TauU1

strong

compute the kinetic energy density and add it to 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]	amo	alpha orbitals (nemos if a nuclear correlation factor is set)
[in]	aocc	occupation numbers of amo
[in]	bmo	beta orbitals, ignored if the calculation is spin-restricted
[in]	bocc	occupation numbers of bmo how the two U1 terms of tau's product rule are evaluated U1 = -grad(R)/R is analytic but componentwise non-smooth at each nucleus (U1_x ~ x/r), so carrying it as an MRA Function costs depth ~18 and every product with it inherits that depth – which refine_to_common_level then imposes on every xc intermediate.

Enumerator
mra	U1 and \|U1\|^2 projected into Functions and multiplied.
pointwise	U1 evaluated from its functor at the orbital tree's quadrature points; nothing involving it is projected

Constructor & Destructor Documentation

◆ XCOperator() [1/8]

template<typename T, std::size_t NDIM>

madness::XCOperator< T, NDIM >::XCOperator ( World & world )

inline

default ctor without information about the XC functional

References extra_truncation, ispin, nbeta, and world.

Referenced by allow_weak_form(), set_extra_truncation(), set_print_level(), and set_weak_gga().

◆ XCOperator() [2/8]

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 dft_deriv, extra_truncation, ispin, nbeta, madness::Function< T, NDIM >::norm2(), prep_xc_args(), world, xc, and xc_args.

◆ XCOperator() [3/8]

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 dft_deriv, extra_truncation, ispin, nbeta, prep_xc_args(), world, xc, and xc_args.

◆ XCOperator() [4/8]

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, dft_deriv, extra_truncation, ispin, madness::SCF::make_density(), madness::CalculationParameters::nbeta(), nbeta, madness::SCF::param, prep_xc_args(), madness::CalculationParameters::spin_restricted(), world, madness::CalculationParameters::xc(), xc, and xc_args.

◆ XCOperator() [5/8]

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 dft_deriv, extra_truncation, ispin, madness::nemo, param, weak_gga, world, and xc.

◆ XCOperator() [6/8]

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::shared_ptr< NuclearCorrelationFactor >	ncf_,
		const real_function_3d &	arho_reg_,
		const real_function_3d &	brho_reg_,
		std::string	deriv = "abgv" )

ctor for the regularized (nemo) path, without a Nemo object

custom ctor for the regularized (nemo) path, without a Nemo object

Parameters

[in]	arho,brho	the physical densities rho_s
[in]	ncf_	the nuclear correlation factor
[in]	arho_reg,brho_reg	the regularized densities rho_s/R^2, which let prep_xc_args build zeta without putting the nuclear cusp under a numerical derivative

References dft_deriv, extra_truncation, ispin, nbeta, ncf, madness::Function< T, NDIM >::norm2(), prep_xc_args(), world, xc, and xc_args.

◆ XCOperator() [7/8]

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 dft_deriv, extra_truncation, ispin, nbeta, madness::SCF::param, param, prep_xc_args(), madness::CalculationParameters::spin_restricted(), world, madness::CalculationParameters::xc(), xc, and xc_args.

◆ XCOperator() [8/8]

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

Member Function Documentation

◆ allow_weak_form()

template<typename T, std::size_t NDIM>

XCOperator & madness::XCOperator< T, NDIM >::allow_weak_form ( )

inline

opt in to the weak form, if the xc_weak_gga parameter asks for it

Load-bearing: in weak form make_xc_potential() returns only de/drho, so a caller that does not also apply weak_xc_terms() and add the matrix form's contribution (operator()(vbra,vket)) would silently drop the whole semilocal contribution and return a plausible but wrong energy. Only Nemo::compute_nemo_potentials implements the split, so only it opts in; SCF, OEP, TDHF and the response kernels keep the multiplicative potential.

References XCOperator(), and weak_form_ok.

Referenced by madness::Nemo::compute_nemo_potentials_impl(), and test_XCOperator_matrix().

◆ 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::FunctionDefaults< NDIM >::refine, madness::FunctionDefaults< NDIM >::get_cell_width(), madness::FunctionDefaults< NDIM >::get_thresh(), has_tau_term(), L, lo, MADNESS_CHECK_THROW, make_derivative(), madness::Tensor< T >::max(), madness::mul(), madness::mul_sparse(), ncf, madness::print(), print_level, madness::scale(), madness::sub(), madness::truncate(), v, vtau, world, and madness::zero_functions_compressed().

Referenced by madness::Nemo::compute_nemo_potentials_impl(), operator()(), and operator()().

◆ 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] density the (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 div_dft_deriv(), is_initialized(), ispin, MADNESS_ASSERT, MADNESS_EXCEPTION, madness::multi_to_multi_op_values(), op(), prep_xc_args_response(), madness::refine_to_common_level(), madness::Function< T, NDIM >::truncate(), madness::truncate(), world, xc, and xc_args.

◆ 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 has_tau_args(), has_tau_term(), is_initialized(), MADNESS_EXCEPTION, make_u1_functors(), madness::multiop_values(), madness::refine_to_common_level(), madness::Function< T, NDIM >::trace(), madness::truncate(), world, xc, and xc_args.

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

◆ div_dft_deriv()

template<typename T, std::size_t NDIM>

real_function_3d madness::XCOperator< T, NDIM >::div_dft_deriv ( const vecfuncT & v ) const

private

divergence of a vector field, honouring dft_deriv

divergence of a real vector field, honouring dft_deriv

vmra.h's div() is div_abgv(), so a caller that has selected dft_deriv bspline/ble has to name the matching derivative explicitly.

References madness::abgv, madness::ble, madness::bspline, dft_deriv, madness::div_deriv(), and v.

Referenced by apply_xc_kernel(), and make_xc_potential_impl().

◆ get_semilocal_flux()

template<typename T, std::size_t NDIM>

const vecfuncT & madness::XCOperator< T, NDIM >::get_semilocal_flux ( ) const

inline

the semilocal flux X = 2 (de/dsigma_ss) grad(rho_s) + (de/dsigma_ab) grad(rho_s')

Only assigned in weak form, by make_xc_potential(). Same-spin and cross-spin contributions are summed: they enter as a single divergence.

References semilocal_flux.

◆ 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, madness::XCfunctional::enum_taub, and xc_args.

Referenced by test_meta_gga().

◆ get_vlocal()

template<typename T, std::size_t NDIM>

real_function_3d madness::XCOperator< T, NDIM >::get_vlocal ( ) const

inline

the multiplicative part of the potential, as make_xc_potential() returned it

References vlocal.

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

◆ has_tau_args()

template<typename T, std::size_t NDIM>

bool madness::XCOperator< T, NDIM >::has_tau_args ( ) const

private

true once set_tau() has supplied tau, by either route

References madness::XCfunctional::enum_gradfa, madness::XCfunctional::enum_nemo_R2, madness::XCfunctional::enum_taua, is_initialized(), and xc_args.

Referenced by compute_xc_energy(), and make_xc_potential_impl().

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

Referenced by apply_tau_term(), madness::Nemo::compute_energy_regularized(), madness::Nemo::compute_nemo_potentials_impl(), compute_xc_energy(), madness::Nemo::make_fock_operator(), make_xc_potential_impl(), operator()(), operator()(), and weak_xc_terms().

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

Referenced by apply_xc_kernel(), compute_xc_energy(), has_tau_args(), make_u1_functors(), make_xc_potential_impl(), and set_tau().

◆ is_weak_form()

template<typename T, std::size_t NDIM>

bool madness::XCOperator< T, NDIM >::is_weak_form ( ) const

true if this operator is running in weak form, i.e. make_xc_potential() returns only de/drho and the flux is carried separately Requires both the caller's allow_weak_form() opt-in and the user's xc_weak_gga parameter. A functional with no sigma dependence has no flux, so it is never in weak form either.

Why it exists: the semilocal potential is -div(X) with X = 2 de/dsigma grad(rho), and X has a jump at every nucleus (zeta = grad log rho -> -2Z r_hat, whose Cartesian components flip sign across the origin). Differentiating that jump is what produces the +-8e4 excursions, and no rearrangement of the multiplicative form avoids it, because div(X) is a derivative of X.

The weak form never differentiates X: <phi|v|psi> = int (df/drho) phi psi + int X . grad(phi psi) and in a Green's-function code the same holds for the orbital update, because a radial convolution commutes with the gradient: G * (psi div X) = div(G * (X psi)) - G * (X . grad psi) so the divergence acts on G*(X psi), which is C^1, and the jump is only ever convolved. Same for the meta-gga term -1/2 div(v_tau grad psi).

References weak_form_ok, weak_gga, and xc.

Referenced by madness::Nemo::compute_nemo_potentials_impl(), make_xc_potential_impl(), operator()(), test_XCOperator_matrix(), and weak_xc_terms().

◆ 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, dft_deriv, and world.

Referenced by apply_tau_term(), operator()(), and weak_xc_terms().

◆ make_u1_functors()

template<typename T, std::size_t NDIM>

nemo_u1_functors madness::XCOperator< T, NDIM >::make_u1_functors ( ) const

private

the four analytic U1 quantities the xc ops evaluate pointwise

Empty unless the pointwise route is in use. They are handed to the op rather than projected into xc_args precisely because a projected product with U1 is what rings; see nemo_u1_functors.

References axis, madness::XCfunctional::enum_gradfa, madness::f, is_initialized(), ncf, and xc_args.

Referenced by compute_xc_energy(), and make_xc_potential_impl().

◆ 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

A thin wrapper whose only job is to stash the result: operator()(vbra,vket) needs whatever the caller got, with no argument to receive it through.

References make_xc_potential_impl(), and vlocal.

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

◆ make_xc_potential_impl()

template<typename T, std::size_t NDIM>

real_function_3d madness::XCOperator< T, NDIM >::make_xc_potential_impl ( ) const

private

the body of make_xc_potential(); the wrapper only stashes vlocal

References madness::copy(), div_dft_deriv(), has_tau_args(), has_tau_term(), is_initialized(), is_weak_form(), ispin, MADNESS_EXCEPTION, make_u1_functors(), madness::multi_to_multi_op_values(), nbeta, op(), madness::refine_to_common_level(), semilocal_flux, madness::Function< T, NDIM >::truncate(), madness::truncate(), vtau, world, xc, and xc_args.

Referenced by make_xc_potential().

◆ 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

the xc contribution to the Fock matrix, as a matrix element

The 1x1 case of the vector form below; the same bra convention applies.

Implements madness::SCFOperatorBase< T, NDIM >.

References operator()().

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

the xc contribution to the Fock matrix

With a nuclear correlation factor the bra must carry R^2 – call it as xcoperator(R2nemo, nemo), the way Kinetic is called in Nemo::compute_fock_matrix. Without one, bra and ket are the same orbitals.

See the declaration for the bra convention – vbra carries R^2, vket does not.

References madness::apply(), apply_tau_term(), axis, madness::FunctionDefaults< NDIM >::thresh, madness::FunctionDefaults< NDIM >::get_thresh(), has_tau_term(), is_weak_form(), MADNESS_CHECK_THROW, make_derivative(), madness::matrix_inner(), madness::mul_sparse(), ncf, madness::norm2(), one(), semilocal_flux, madness::transpose(), vlocal, weak_xc_terms(), and world.

◆ 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 apply_tau_term(), madness::FunctionDefaults< NDIM >::get_thresh(), has_tau_term(), make_xc_potential(), madness::mul_sparse(), and world.

Referenced by operator()(), and 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 real_function_3d &	arho_reg = real_function_3d(),
		const real_function_3d &	brho_reg = real_function_3d() ) const

private

compute the intermediates for the XC functionals

prepare xc args

Parameters

[in]	arho	density of the alpha orbitals
[in]	brho	density of the beta orbitals (necessary only if spin-polarized)

Returns: xc_args vector of intermediates as described above compute the intermediates for the XC functionals If the regularized densities are supplied, zeta = grad log(rho) is built as grad log(rho_reg) - 2 U1 – exact, and it keeps the nuclear cusp of rho = R^2 rho_reg out from under the numerical derivative.

Referenced by XCOperator(), XCOperator(), XCOperator(), XCOperator(), and 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_pt	perturbed densities from CPHF or TDDFT equations
[in,out]	xc_args	vector of intermediates as described above
[out]	ddens_pt	xyz-derivatives of dens_pt

Referenced by apply_xc_kernel().

◆ set_extra_truncation()

template<typename T, std::size_t NDIM>

XCOperator & madness::XCOperator< T, NDIM >::set_extra_truncation ( const double & fac )

inline

References XCOperator(), extra_truncation, madness::print(), and 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 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 XCOperator(), p(), and 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 TauU1	u1mode = TauU1::pointwise ) const

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

< sum_i w_i |grad F_i|^2

< sum_i w_i F_i^2

< sum_i w_i F_i dF_i/dx_a = 1/2 grad(n)

Referenced by madness::Nemo::compute_energy_regularized(), madness::Nemo::compute_nemo_potentials_impl(), and test_meta_gga().

◆ set_weak_gga()

template<typename T, std::size_t NDIM>

XCOperator & madness::XCOperator< T, NDIM >::set_weak_gga ( const bool flag )

inline

override CalculationParameters::xc_weak_gga(), for callers without one

References XCOperator(), and weak_gga.

Referenced by test_XCOperator_matrix().

◆ weak_xc_terms()

template<typename T, std::size_t NDIM>

void madness::XCOperator< T, NDIM >::weak_xc_terms	(	const std::vector< Function< T, NDIM > > &	vket,
		std::vector< Function< T, NDIM > > &	mult,
		std::vector< std::vector< Function< T, NDIM > > > &	flux ) const

weak-form split of the non-multiplicative xc terms

Writes the decomposition v_xc^{semilocal+tau} psi_i = mult_i - div(Y_i) with (nemo kets F_i, W_i = v_tau (grad F_i - U1 F_i)) mult_i = X.grad(F_i) + 1/2 U1.W_i, Y_i = X F_i + 1/2 W_i. mult goes into V psi; flux is what the caller pushes through the Green's function, as 2 div(G*Y_i), so that neither X nor v_tau is ever differentiated. Requires make_xc_potential() first.

References madness::apply(), axis, madness::FunctionDefaults< NDIM >::get_thresh(), has_tau_term(), is_weak_form(), MADNESS_CHECK_THROW, make_derivative(), madness::mul(), madness::mul_sparse(), ncf, semilocal_flux, madness::sub(), madness::truncate(), vtau, world, and madness::zero_functions_compressed().

Referenced by madness::Nemo::compute_nemo_potentials_impl(), and operator()().

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

Referenced by XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), div_dft_deriv(), make_derivative(), prep_xc_args(), and set_tau().

◆ 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 XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), prep_xc_args(), prep_xc_args_response(), madness::Coulomb< double, 3 >::reset_poisson_operator_ptr(), set_extra_truncation(), and set_tau().

◆ 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 XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), apply_xc_kernel(), make_xc_potential_impl(), and set_ispin().

◆ nbeta

template<typename T, std::size_t NDIM>

int madness::XCOperator< T, NDIM >::nbeta

private

number of beta orbitals

Referenced by XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), make_xc_potential_impl(), prep_xc_args(), prep_xc_args_response(), and set_tau().

◆ 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

Referenced by XCOperator(), apply_tau_term(), make_u1_functors(), operator()(), prep_xc_args(), set_tau(), and weak_xc_terms().

◆ 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 apply_tau_term(), and set_print_level().

◆ semilocal_flux

template<typename T, std::size_t NDIM>

vecfuncT madness::XCOperator< T, NDIM >::semilocal_flux

mutableprivate

the semilocal flux, assigned by make_xc_potential() in weak form only

Referenced by get_semilocal_flux(), make_xc_potential_impl(), operator()(), and weak_xc_terms().

◆ vlocal

template<typename T, std::size_t NDIM>

real_function_3d madness::XCOperator< T, NDIM >::vlocal

mutableprivate

the multiplicative potential, stashed by make_xc_potential()

Referenced by get_vlocal(), make_xc_potential(), and operator()().

◆ 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 apply_tau_term(), get_vtau(), make_xc_potential_impl(), and weak_xc_terms().

◆ weak_form_ok

template<typename T, std::size_t NDIM>

bool madness::XCOperator< T, NDIM >::weak_form_ok =false

private

caller has opted in to the weak form, see allow_weak_form()

Referenced by allow_weak_form(), and is_weak_form().

◆ weak_gga

template<typename T, std::size_t NDIM>

bool madness::XCOperator< T, NDIM >::weak_gga =false

private

the user asked for the weak form: CalculationParameters::xc_weak_gga()

Two independent conditions, and both are needed. weak_form_ok says the caller implements the split; this says the user wants it.

Referenced by XCOperator(), is_weak_form(), and set_weak_gga().

◆ world

template<typename T, std::size_t NDIM>

World& madness::XCOperator< T, NDIM >::world

private

the world

Referenced by XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), apply_tau_term(), apply_xc_kernel(), compute_xc_energy(), make_derivative(), make_xc_potential_impl(), operator()(), operator()(), prep_xc_args(), prep_xc_args_response(), set_extra_truncation(), set_tau(), and weak_xc_terms().

◆ 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 XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), apply_xc_kernel(), compute_xc_energy(), has_tau_term(), is_weak_form(), make_xc_potential_impl(), prep_xc_args(), prep_xc_args_response(), and set_tau().

◆ 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 XCOperator(), XCOperator(), XCOperator(), XCOperator(), XCOperator(), apply_xc_kernel(), compute_xc_energy(), get_tau(), has_tau_args(), is_initialized(), make_u1_functors(), make_xc_potential_impl(), prep_xc_args_response(), and set_tau().

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

Classes

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ TauU1

Constructor & Destructor Documentation

◆ XCOperator() [1/8]

◆ XCOperator() [2/8]

◆ XCOperator() [3/8]

◆ XCOperator() [4/8]

◆ XCOperator() [5/8]

◆ XCOperator() [6/8]

◆ XCOperator() [7/8]

◆ XCOperator() [8/8]

Member Function Documentation

◆ allow_weak_form()

◆ apply_tau_term()

◆ apply_xc_kernel()

◆ compute_xc_energy()

◆ div_dft_deriv()

◆ get_semilocal_flux()

◆ get_tau()

◆ get_vlocal()

◆ get_vtau()

◆ has_tau_args()

◆ has_tau_term()

◆ info()

◆ is_initialized()

◆ is_weak_form()

◆ make_derivative()

◆ make_u1_functors()

◆ make_xc_potential()

◆ make_xc_potential_impl()

◆ operator()() [1/4]

◆ operator()() [2/4]

◆ operator()() [3/4]

◆ operator()() [4/4]

◆ prep_xc_args()

◆ prep_xc_args_response()

◆ set_extra_truncation()

◆ set_ispin()

◆ set_print_level()

◆ set_tau()

◆ set_weak_gga()

◆ weak_xc_terms()

Member Data Documentation

◆ dft_deriv

◆ extra_truncation

◆ ispin

◆ nbeta

◆ ncf

◆ print_level

◆ semilocal_flux

◆ vlocal

◆ vtau

◆ weak_form_ok

◆ weak_gga

◆ world

◆ xc

◆ xc_args