MADNESS 0.10.1
madness::CCConvolutionOperator< T, NDIM > Class Template Reference

#include <CCStructures.h>

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

Classes

struct  Parameters
 parameter class More...

Public Member Functions

 CCConvolutionOperator (const CCConvolutionOperator &other)=default
 CCConvolutionOperator (World &world, const OpType type, Parameters param)
void clear_intermediates (const FuncType &type)
TwoElectronFactory< T, 2 *NDIM > get_kernel () const
 create a TwoElectronFactory with the operatorkernel
std::shared_ptr< SeparatedConvolution< T, NDIM > > get_op () const
size_t info () const
 prints out information (operatorname, number of stored intermediates ...)
std::string name () const
std::vector< Function< T, NDIM > > operator() (const CC_vecfunction &bra, const CCFunction< T, NDIM > &ket) const
Function< T, NDIM > operator() (const CCFunction< T, NDIM > &bra, const CCFunction< T, NDIM > &ket, const bool use_im=true) const
Function< T, NDIM > operator() (const CCFunction< T, NDIM > &bra, const Function< T, 2 *NDIM > &u, const size_t particle) const
Function< T, 2 *NDIM > operator() (const Function< T, 2 *NDIM > &u, const size_t particle) const
Function< T, NDIM > operator() (const Function< T, NDIM > &f) const
std::vector< Function< T, NDIM > > operator() (const std::vector< Function< T, NDIM > > &f) const
void print_intermediate (const FuncType type) const
void sanity () const
 sanity check .. doens not do so much
OpType type () const
void update_elements (const CC_vecfunction &bra, const CC_vecfunction &ket)

Static Public Member Functions

static std::shared_ptr< CCConvolutionOperator > CCConvolutionOperatorPtr (World &world, const OpType type, Parameters param)

Public Attributes

const Parameters parameters

Private Member Functions

void error (const std::string &msg) const
SeparatedConvolution< T, NDIM > * init_op (const OpType &type, const Parameters &parameters) const

Private Attributes

intermediateT< T, NDIM > imH
intermediateT< T, NDIM > imP
intermediateT< T, NDIM > imR
std::shared_ptr< SeparatedConvolution< T, NDIM > > op
World & world
 the world

Friends

CCConvolutionOperator combine (const CCConvolutionOperator &a, const CCConvolutionOperator &b)
std::shared_ptr< CCConvolutionOperator > combine (const std::shared_ptr< CCConvolutionOperator > &a, const std::shared_ptr< CCConvolutionOperator > &b)
hashT hash_value (CCConvolutionOperator< T, NDIM > &op)

Detailed Description

template<typename T = double, std::size_t NDIM = 3>
class madness::CCConvolutionOperator< T, NDIM >

Helper Structure that carries out operations on CC_functions The structure can hold intermediates for g12 and f12 of type : <mo_bra_k|op|type> with type=HOLE,PARTICLE or RESPONSE some 6D operations are also included The structure does not know if nuclear correlation facors are used, so the corresponding bra states have to be prepared beforehand

Constructor & Destructor Documentation

◆ CCConvolutionOperator() [1/2]

template<typename T = double, std::size_t NDIM = 3>
madness::CCConvolutionOperator< T, NDIM >::CCConvolutionOperator ( World & world,
const OpType type,
Parameters param )
inline
Parameters
[in]world
[in]optypethe operatortype (can be g12_ or f12_)
[in]paramthe parameters of the current CC-Calculation (including function and operator thresholds and the exponent for f12)

References init_op(), op, param, parameters, type(), and world.

Referenced by CCConvolutionOperator(), CCConvolutionOperatorPtr(), combine, combine, and hash_value.

◆ CCConvolutionOperator() [2/2]

template<typename T = double, std::size_t NDIM = 3>
madness::CCConvolutionOperator< T, NDIM >::CCConvolutionOperator ( const CCConvolutionOperator< T, NDIM > & other)
default

Member Function Documentation

◆ CCConvolutionOperatorPtr()

template<typename T = double, std::size_t NDIM = 3>
std::shared_ptr< CCConvolutionOperator > madness::CCConvolutionOperator< T, NDIM >::CCConvolutionOperatorPtr ( World & world,
const OpType type,
Parameters param )
inlinestatic

◆ clear_intermediates()

template<typename T, std::size_t NDIM>
void madness::CCConvolutionOperator< T, NDIM >::clear_intermediates ( const FuncType & type)
Parameters
[in]thetype of which intermediates will be deleted e.g if(type==HOLE) then all intermediates of type <mo_bra_k|op|HOLE> will be deleted

References madness::assign_name(), madness::error(), madness::HOLE, imH, imP, imR, madness::name(), madness::PARTICLE, madness::RESPONSE, type(), and world.

◆ error()

template<typename T = double, std::size_t NDIM = 3>
void madness::CCConvolutionOperator< T, NDIM >::error ( const std::string & msg) const
inlineprivate
Parameters
[in]msgoutput message the function will throw an MADNESS_EXCEPTION

References MADNESS_EXCEPTION, name(), and world.

◆ get_kernel()

template<typename T = double, std::size_t NDIM = 3>
TwoElectronFactory< T, 2 *NDIM > madness::CCConvolutionOperator< T, NDIM >::get_kernel ( ) const
inline

create a TwoElectronFactory with the operatorkernel

References op, and world.

◆ get_op()

template<typename T = double, std::size_t NDIM = 3>
std::shared_ptr< SeparatedConvolution< T, NDIM > > madness::CCConvolutionOperator< T, NDIM >::get_op ( ) const
inline

References op.

Referenced by type().

◆ info()

template<typename T, std::size_t NDIM>
size_t madness::CCConvolutionOperator< T, NDIM >::info ( ) const

prints out information (operatorname, number of stored intermediates ...)

References imH, imP, imR, madness::name(), madness::size_of(), and world.

Referenced by combine.

◆ init_op()

template<typename T = double, std::size_t NDIM = 3>
SeparatedConvolution< T, NDIM > * madness::CCConvolutionOperator< T, NDIM >::init_op ( const OpType & type,
const Parameters & parameters ) const
private
Parameters
[in]optypecan be f12_ or g12_ depending on which operator shall be intitialzied
[in]parametersparameters (thresholds etc) initializes the operators

References madness::FunctionDefaults< NDIM >::debug, parameters, madness::print(), type(), and world.

Referenced by CCConvolutionOperator(), and update_elements().

◆ name()

template<typename T = double, std::size_t NDIM = 3>
std::string madness::CCConvolutionOperator< T, NDIM >::name ( ) const
inline
Parameters
[out]printsthe name of the operator (convenience) which is g12 or f12 or maybe other things like gf in the future

References type().

Referenced by error(), and print_intermediate().

◆ operator()() [1/6]

template<typename T = double, std::size_t NDIM = 3>
std::vector< Function< T, NDIM > > madness::CCConvolutionOperator< T, NDIM >::operator() ( const CC_vecfunction & bra,
const CCFunction< T, NDIM > & ket ) const
inline

◆ operator()() [2/6]

◆ operator()() [3/6]

template<typename T, std::size_t NDIM>
Function< T, NDIM > madness::CCConvolutionOperator< T, NDIM >::operator() ( const CCFunction< T, NDIM > & bra,
const Function< T, 2 *NDIM > & u,
const size_t particle ) const

◆ operator()() [4/6]

template<typename T, std::size_t NDIM>
Function< T, 2 *NDIM > madness::CCConvolutionOperator< T, NDIM >::operator() ( const Function< T, 2 *NDIM > & u,
const size_t particle ) const

References MADNESS_CHECK, op, and u().

◆ operator()() [5/6]

template<typename T = double, std::size_t NDIM = 3>
Function< T, NDIM > madness::CCConvolutionOperator< T, NDIM >::operator() ( const Function< T, NDIM > & f) const
inline
Parameters
[in]fa 3D function
[out]theconvolution op(f), no intermediates are used

References madness::f, and op.

Referenced by operator()().

◆ operator()() [6/6]

template<typename T = double, std::size_t NDIM = 3>
std::vector< Function< T, NDIM > > madness::CCConvolutionOperator< T, NDIM >::operator() ( const std::vector< Function< T, NDIM > > & f) const
inline

◆ print_intermediate()

template<typename T = double, std::size_t NDIM = 3>
void madness::CCConvolutionOperator< T, NDIM >::print_intermediate ( const FuncType type) const
inline
Parameters
[in]typethe type of intermediates which will be printed, can be HOLE,PARTICLE or RESPONSE

References madness::HOLE, imH, imP, imR, name(), madness::PARTICLE, madness::RESPONSE, and type().

Referenced by sanity().

◆ sanity()

template<typename T = double, std::size_t NDIM = 3>
void madness::CCConvolutionOperator< T, NDIM >::sanity ( ) const
inline

sanity check .. doens not do so much

References madness::HOLE, and print_intermediate().

◆ type()

template<typename T = double, std::size_t NDIM = 3>
OpType madness::CCConvolutionOperator< T, NDIM >::type ( ) const
inline

◆ update_elements()

template<typename T, std::size_t NDIM>
void madness::CCConvolutionOperator< T, NDIM >::update_elements ( const CC_vecfunction & bra,
const CC_vecfunction & ket )

◆ combine [1/2]

template<typename T = double, std::size_t NDIM = 3>
CCConvolutionOperator combine ( const CCConvolutionOperator< T, NDIM > & a,
const CCConvolutionOperator< T, NDIM > & b )
friend

◆ combine [2/2]

template<typename T = double, std::size_t NDIM = 3>
std::shared_ptr< CCConvolutionOperator > combine ( const std::shared_ptr< CCConvolutionOperator< T, NDIM > > & a,
const std::shared_ptr< CCConvolutionOperator< T, NDIM > > & b )
friend

References CCConvolutionOperator(), a, b, and combine.

◆ hash_value

template<typename T = double, std::size_t NDIM = 3>
hashT hash_value ( CCConvolutionOperator< T, NDIM > & op)
friend

Member Data Documentation

◆ imH

template<typename T = double, std::size_t NDIM = 3>
intermediateT<T,NDIM> madness::CCConvolutionOperator< T, NDIM >::imH
private

◆ imP

template<typename T = double, std::size_t NDIM = 3>
intermediateT<T,NDIM> madness::CCConvolutionOperator< T, NDIM >::imP
private

◆ imR

template<typename T = double, std::size_t NDIM = 3>
intermediateT<T,NDIM> madness::CCConvolutionOperator< T, NDIM >::imR
private

◆ op

template<typename T = double, std::size_t NDIM = 3>
std::shared_ptr<SeparatedConvolution<T,NDIM> > madness::CCConvolutionOperator< T, NDIM >::op
private

◆ parameters

template<typename T = double, std::size_t NDIM = 3>
const Parameters madness::CCConvolutionOperator< T, NDIM >::parameters

◆ world


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