madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM > Class Template Reference

#include <exchangeoperator.h>

Collaboration diagram for madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >:

Classes
class	MacroTaskExchangeRow
class	MacroTaskExchangeSimple

Public Types
typedef Exchange< T, NDIM >::Algorithm	Algorithm

Public Member Functions
	ExchangeImpl (World &world, const double lo, const double thresh)
	default ctor
	ExchangeImpl (World &world, const Nemo *nemo, const int ispin)
	ctor with a nemo calculation
	ExchangeImpl (World &world, const SCF *calc, const int ispin)
	ctor with a conventional calculation
std::string	info () const
bool	is_symmetric () const
vecfuncT	operator() (const vecfuncT &vket) const
	apply the exchange operator on a vector of functions
ExchangeImpl &	set_algorithm (const Algorithm &alg)
void	set_bra_and_ket (const vecfuncT &bra, const vecfuncT &ket)
	set the bra and ket orbital spaces, and the occupation
ExchangeImpl &	set_printlevel (const long &level)
ExchangeImpl &	set_taskq (std::shared_ptr< MacroTaskQ > taskq1)
ExchangeImpl &	symmetric (const bool flag)

Static Public Member Functions
static auto	set_poisson (World &world, const double lo, const double econv=FunctionDefaults< 3 >::get_thresh())

Public Attributes
Algorithm	algorithm_ = multiworld_efficient_row

Private Types
typedef Function< T, NDIM >	functionT
typedef std::vector< functionT >	vecfuncT

Private Member Functions
bool	do_print_timings () const
vecfuncT	K_large_memory (const vecfuncT &vket, const double mul_tol=0.0) const
	computing the upper triangle of the double sum (over vket and the K orbitals)
vecfuncT	K_macrotask_efficient (const vecfuncT &vket, const double mul_tol=0.0) const
	exchange using macrotasks, i.e. apply K on a function in individual worlds
vecfuncT	K_macrotask_efficient_row (const vecfuncT &vket, const double mul_tol=0.0) const
	exchange using macrotasks, i.e. apply K on a function in individual worlds row-wise
vecfuncT	K_small_memory (const vecfuncT &vket, const double mul_tol=0.0) const
	computing the full square of the double sum (over vket and the K orbitals)
bool	printdebug () const

Static Private Member Functions
static vecfuncT	compute_K_tile (World &world, const vecfuncT &mo_bra, const vecfuncT &mo_ket, const vecfuncT &vket, std::shared_ptr< real_convolution_3d > poisson, const bool symmetric, const double mul_tol=0.0)
	computing the upper triangle of the double sum (over vket and the K orbitals)
static void	print_timer (World &world)
static void	reset_timer ()

Private Attributes
double	lo = 1.e-4
vecfuncT	mo_bra
	is the exchange matrix symmetric? K phi_i = \sum_k \phi_k \int \phi_k \phi_i
vecfuncT	mo_ket
	MOs for bra and ket.
double	mul_tol = FunctionDefaults<NDIM>::get_thresh()*0.1
long	printlevel = 0
bool	symmetric_ = false
std::shared_ptr< MacroTaskQ >	taskq
double	thresh = FunctionDefaults<NDIM>::get_thresh()
World &	world

Static Private Attributes
static std::atomic< long >	apply_timer
static std::atomic< long >	mul1_timer
	timing
static std::atomic< long >	mul2_timer

Member Typedef Documentation

Algorithm

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

typedef Exchange<T,NDIM>::Algorithm madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::Algorithm

functionT

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

typedef Function<T, NDIM> madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::functionT

private

vecfuncT

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

typedef std::vector<functionT> madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::vecfuncT

private

Constructor & Destructor Documentation

ExchangeImpl() [1/3]

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::ExchangeImpl ( World &  world, const double  lo, const double  thresh  )

inline

default ctor

ExchangeImpl() [2/3]

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::ExchangeImpl	(	World &	world,
		const SCF *	calc,
		const int	ispin
	)

ctor with a conventional calculation

References madness::SCF::amo, madness::SCF::bmo, madness::conj(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mo_bra, madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mo_ket, madness::nonlinear_vector_solver(), and madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::world.

ExchangeImpl() [3/3]

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::ExchangeImpl	(	World &	world,
		const Nemo *	nemo,
		const int	ispin
	)

ctor with a nemo calculation

References madness::Nemo::get_calc(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mo_bra, madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mo_ket, madness::mul(), madness::NemoBase::ncf, madness::nonlinear_vector_solver(), madness::truncate(), and madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::world.

Member Function Documentation

compute_K_tile()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::vector< Function< T, NDIM > > madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile ( World &  world, const vecfuncT &  mo_bra, const vecfuncT &  mo_ket, const vecfuncT &  vket, std::shared_ptr< real_convolution_3d >  poisson, const bool  symmetric, const double  mul_tol = 0.0  )

staticprivate

computing the upper triangle of the double sum (over vket and the K orbitals)

References madness::apply(), madness::compress(), madness::cpu_time(), madness::WorldGopInterface::fence(), madness::World::gop, ij(), madness::mul_sparse(), madness::nonlinear_vector_solver(), madness::norm_tree(), madness::reconstruct(), and madness::truncate().

do_print_timings()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

bool madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::do_print_timings ( ) const

inlineprivate

References madness::nonlinear_vector_solver(), and madness::World::rank().

info()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::string madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::info ( ) const

inline

is_symmetric()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

bool madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::is_symmetric ( ) const

inline

K_large_memory()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::vector< Function< T, NDIM > > madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_large_memory ( const vecfuncT &  vket, const double  mul_tol = 0.0  ) const

private

computing the upper triangle of the double sum (over vket and the K orbitals)

References madness::Exchange< T, NDIM >::is_symmetric(), lo, madness::nonlinear_vector_solver(), set_poisson(), and madness::truncate().

K_macrotask_efficient()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::vector< Function< T, NDIM > > madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_macrotask_efficient ( const vecfuncT &  vf, const double  mul_tol = 0.0  ) const

private

exchange using macrotasks, i.e. apply K on a function in individual worlds

apply the exchange operator by tiling the exchange matrix

compute the matrix N_{ik} = N \phi_i \phi_k by tiles, with i,k \in batches A,B, do a local reduce within the tiles: K_{iB} = \sum_{k \in batch B} \phi_k N_{ik} and a universe-wide reduce of the tiles: K\phi_i = \sum_{batches B} K_{iB} saving up to half of the cpu time compared to the naive algorithm

Template Parameters

T	number type
NDIM	physical dimension of the argument vket

Parameters

vf	argument of the exchange operator
mul_tol	cutoff parameter for sparse multiplication

Returns

the exchange operator applied on vket

References madness::nonlinear_vector_solver(), and madness::print().

K_macrotask_efficient_row()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::vector< Function< T, NDIM > > madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_macrotask_efficient_row ( const vecfuncT &  vket, const double  mul_tol = 0.0  ) const

private

exchange using macrotasks, i.e. apply K on a function in individual worlds row-wise

compute each row of the exchange matrix in different subworlds

References madness::get_size(), lo, madness::nonlinear_vector_solver(), madness::print(), and madness::SCFOperatorBase< T, NDIM >::taskq.

K_small_memory()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::vector< Function< T, NDIM > > madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_small_memory ( const vecfuncT &  vket, const double  mul_tol = 0.0  ) const

private

computing the full square of the double sum (over vket and the K orbitals)

was vtol

was vtol

References madness::apply(), madness::gaxpy(), lo, madness::mul_sparse(), madness::nonlinear_vector_solver(), set_poisson(), and madness::truncate().

operator()()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::vector< Function< T, NDIM > > madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::operator()

(

const vecfuncT &

vket

)

const

apply the exchange operator on a vector of functions

note that only one spin is used (either alpha or beta orbitals)

Parameters

[in]

vket

the orbitals |i> that the operator is applied on

Returns

a vector of orbitals K| i>

print_timer()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

static void madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::print_timer ( World &  world )

inlinestaticprivate

References madness::World::gop, madness::nonlinear_vector_solver(), madness::World::rank(), and madness::WorldGopInterface::sum().

printdebug()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

bool madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::printdebug ( ) const

inlineprivate

reset_timer()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

static void madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::reset_timer ( )

inlinestaticprivate

set_algorithm()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

ExchangeImpl & madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::set_algorithm ( const Algorithm &  alg )

inline

References madness::nonlinear_vector_solver().

set_bra_and_ket()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

void madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::set_bra_and_ket ( const vecfuncT &  bra, const vecfuncT &  ket  )

inline

set the bra and ket orbital spaces, and the occupation

Parameters

[in]	bra	bra space, must be provided as complex conjugate
[in]	ket	ket space

References madness::copy().

set_poisson()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

static auto madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::set_poisson ( World &  world, const double  lo, const double  econv = FunctionDefaults<3>::get_thresh()  )

inlinestatic

References madness::CoulombOperatorPtr(), and lo.

set_printlevel()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

ExchangeImpl & madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::set_printlevel ( const long &  level )

inline

set_taskq()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

ExchangeImpl & madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::set_taskq ( std::shared_ptr< MacroTaskQ >  taskq1 )

inline

References madness::nonlinear_vector_solver(), and madness::SCFOperatorBase< T, NDIM >::taskq.

symmetric()

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

ExchangeImpl & madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::symmetric ( const bool  flag )

inline

References madness::nonlinear_vector_solver().

Member Data Documentation

algorithm_

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

Algorithm madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::algorithm_ = multiworld_efficient_row

apply_timer

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::atomic<long> madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::apply_timer

inlinestaticprivate

lo

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

double madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::lo = 1.e-4

private

mo_bra

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

vecfuncT madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mo_bra

private

is the exchange matrix symmetric? K phi_i = \sum_k \phi_k \int \phi_k \phi_i

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

mo_ket

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

vecfuncT madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mo_ket

private

MOs for bra and ket.

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

mul1_timer

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::atomic<long> madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mul1_timer

inlinestaticprivate

timing

mul2_timer

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::atomic<long> madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mul2_timer

inlinestaticprivate

mul_tol

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

double madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::mul_tol = FunctionDefaults<NDIM>::get_thresh()*0.1

private

printlevel

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

long madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::printlevel = 0

private

symmetric_

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

bool madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::symmetric_ = false

private

taskq

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

std::shared_ptr<MacroTaskQ> madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::taskq

private

thresh

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

double madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::thresh = FunctionDefaults<NDIM>::get_thresh()

private

world

template<typename T , std::size_t NDIM>

template<typename T , std::size_t NDIM>

World& madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::world

private

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

---

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

• exchangeoperator.h
• exchangeoperator.cc