MADNESS 0.10.1
madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT > Struct Template Reference

Hartree product of two LDIM functions to yield a NDIM = 2*LDIM function. More...

#include <funcimpl.h>

Collaboration diagram for madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >:

Public Types

typedef CoeffTracker< T, LDIM > ctL
typedef hartree_op< LDIM, leaf_opT > this_type

Public Member Functions

 hartree_op ()
 hartree_op (implT *result, const ctL &p11, const ctL &p22, const leaf_opT &leaf_op)
Future< this_type > activate () const
this_type forward_ctor (implT *result1, const ctL &p11, const ctL &p22, const leaf_opT &leaf_op)
this_type make_child (const keyT &child) const
std::pair< bool, coeffT > operator() (const Key< NDIM > &key) const
bool randomize () const
template<typename Archive>
void serialize (const Archive &ar)

Public Attributes

leaf_opT leaf_op
 determine if a given node will be a leaf node
ctL p1
ctL p2
 tracking coeffs of the two lo-dim functions
implT * result
 where to construct the pair function

Detailed Description

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
struct madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >

Hartree product of two LDIM functions to yield a NDIM = 2*LDIM function.

Member Typedef Documentation

◆ ctL

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
typedef CoeffTracker<T,LDIM> madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::ctL

◆ this_type

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
typedef hartree_op<LDIM,leaf_opT> madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::this_type

Constructor & Destructor Documentation

◆ hartree_op() [1/2]

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::hartree_op ( )
inline

References result.

◆ hartree_op() [2/2]

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::hartree_op ( implT * result,
const ctL & p11,
const ctL & p22,
const leaf_opT & leaf_op )
inline

References leaf_op, MADNESS_ASSERT, NDIM, p1, p2, and result.

Member Function Documentation

◆ activate()

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
Future< this_type > madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::activate ( ) const
inline

◆ forward_ctor()

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
this_type madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::forward_ctor ( implT * result1,
const ctL & p11,
const ctL & p22,
const leaf_opT & leaf_op )
inline

References leaf_op.

Referenced by activate().

◆ make_child()

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
this_type madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::make_child ( const keyT & child) const
inline

◆ operator()()

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
std::pair< bool, coeffT > madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::operator() ( const Key< NDIM > & key) const
inline

◆ randomize()

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
bool madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::randomize ( ) const
inline

◆ serialize()

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
template<typename Archive>
void madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::serialize ( const Archive & ar)
inline

References leaf_op, p1, p2, and result.

Member Data Documentation

◆ leaf_op

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
leaf_opT madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::leaf_op

determine if a given node will be a leaf node

Referenced by hartree_op(), activate(), forward_ctor(), make_child(), operator()(), and serialize().

◆ p1

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
ctL madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::p1

◆ p2

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
ctL madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::p2

tracking coeffs of the two lo-dim functions

Referenced by hartree_op(), activate(), make_child(), operator()(), and serialize().

◆ result

template<typename T, std::size_t NDIM>
template<size_t LDIM, typename leaf_opT>
implT* madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::result

where to construct the pair function

Referenced by hartree_op(), hartree_op(), activate(), make_child(), operator()(), and serialize().


The documentation for this struct was generated from the following file: