Arithmetic operations for SuperF2D functors. More...

#include <superCalcF2D.h>

Inheritance diagram for olb::SuperCalcF2D< T, W, F >:

Collaboration diagram for olb::SuperCalcF2D< T, W, F >:

Public Member Functions
	SuperCalcF2D (FunctorPtr< SuperF2D< T, W > > &&f, FunctorPtr< SuperF2D< T, W > > &&g)

	SuperCalcF2D (W scalar, FunctorPtr< SuperF2D< T, W > > &&g)

	SuperCalcF2D (FunctorPtr< SuperF2D< T, W > > &&f, W scalar)

bool	operator() (W output[], const int input[]) override
	has to be implemented for 'every' derived class

Public Member Functions inherited from olb::SuperF2D< T, W >
SuperF2D< T, W > &	operator- (SuperF2D< T, W > &rhs)

SuperF2D< T, W > &	operator+ (SuperF2D< T, W > &rhs)

SuperF2D< T, W > &	operator* (SuperF2D< T, W > &rhs)

SuperF2D< T, W > &	operator/ (SuperF2D< T, W > &rhs)

SuperStructure< T, 2 > &	getSuperStructure ()

int	getBlockFSize () const

BlockF2D< W > &	getBlockF (int iCloc)

bool	operator() (W output[], const int input[]) override

Public Member Functions inherited from olb::GenericF< W, int >
virtual	~GenericF ()=default

int	getSourceDim () const
	read only access to member variable _m

int	getTargetDim () const
	read only access to member variable _n

std::string &	getName ()
	read and write access to name

std::string const &	getName () const
	read only access to name

bool	operator() (W output[])
	wrapper that call the pure virtual operator() (T output[], const S input[]) from above

bool	operator() (W output[], int input0)

bool	operator() (W output[], int input0, int input1)

bool	operator() (W output[], int input0, int input1, int input2)

bool	operator() (W output[], int input0, int input1, int input2, int input3)

Protected Attributes
FunctorPtr< SuperF2D< T, W > >	_f

FunctorPtr< SuperF2D< T, W > >	_g

Protected Attributes inherited from olb::SuperF2D< T, W >
SuperStructure< T, 2 > &	_superStructure

std::vector< std::unique_ptr< BlockF2D< W > > >	_blockF
	Super functors may consist of several BlockF2D<W> derived functors.

Additional Inherited Members
Public Types inherited from olb::SuperF2D< T, W >
using	identity_functor_type

Public Types inherited from olb::GenericF< W, int >
using	targetType

using	sourceType

Public Attributes inherited from olb::GenericF< W, int >
std::shared_ptr< GenericF< W, int > >	_ptrCalcC
	memory management, frees resouces (calcClass)

Protected Member Functions inherited from olb::SuperF2D< T, W >
	SuperF2D (SuperStructure< T, 2 > &superStructure, int targetDim)

Protected Member Functions inherited from olb::GenericF< W, int >
	GenericF (int targetDim, int sourceDim)

Detailed Description

template<typename T, typename W, template< typename > class F>
class olb::SuperCalcF2D< T, W, F >

Arithmetic operations for SuperF2D functors.

Template Parameters

F	Function object defining the arithmetic operation to be perfomed e.g. std::minus for substraction

Block level functors are instantiated for operations if at least one input functor exposes block level functors. See BlockCalcF2D

Global queries are not delegated to block level functors to prevent unnecessary synchronization.

Warning: Allocation error possible in functors that have multiple functor evaluation like SuperSum2D

Definition at line 55 of file superCalcF2D.h.

Constructor & Destructor Documentation

◆ SuperCalcF2D() [1/3]

template<typename T , typename W , template< typename > class F>

olb::SuperCalcF2D< T, W, F >::SuperCalcF2D	(	FunctorPtr< SuperF2D< T, W > > &&	f,
		FunctorPtr< SuperF2D< T, W > > &&	g )

Definition at line 36 of file superCalcF2D.hh.

  : SuperF2D<T,W>(
      f->getSuperStructure(),
      f->getTargetDim() > g->getTargetDim() ? f->getTargetDim() : g->getTargetDim()),
    _f(std::move(f)),
    _g(std::move(g))
{
  OLB_ASSERT(
    _f->getTargetDim() == _g->getTargetDim() || _f->getTargetDim() == 1 || _g->getTargetDim() == 1,
    "Componentwise operation must be well defined.");
 
  this->getName() = "(" + _f->getName() + F<T>::symbol + _g->getName() + ")";
 
  std::swap(_f->_ptrCalcC, this->_ptrCalcC);
 
  LoadBalancer<T>& load = _f->getSuperStructure().getLoadBalancer();
 
  if ( _f->getBlockFSize() == load.size() ) {
    if ( _g->getBlockFSize() == load.size() ) {
      // both functors expose the correct count of block level functors
      for (int iC = 0; iC < load.size(); ++iC) {
        this->_blockF.emplace_back(
          new BlockCalcF2D<W,F>(_f->getBlockF(iC), _g->getBlockF(iC))
        );
      }
    }
    else {
      // operate on super functor `g` and block level functors provided by `f`
      for (int iC = 0; iC < load.size(); ++iC) {
        this->_blockF.emplace_back(
          new BlockCalcF2D<W,F>(_f->getBlockF(iC), *g, load.glob(iC))
        );
      }
    }
  }
  else if ( _g->getBlockFSize() == load.size() ) {
    // operate on block level functors provided by `f` and super functor `g`
    for (int iC = 0; iC < load.size(); ++iC) {
      this->_blockF.emplace_back(
        new BlockCalcF2D<W,F>(*f, load.glob(iC), _g->getBlockF(iC))
      );
    }
  }
}

References olb::SuperF2D< T, W >::_blockF, olb::SuperCalcF2D< T, W, F >::_f, olb::SuperCalcF2D< T, W, F >::_g, olb::GenericF< W, int >::getName(), OLB_ASSERT, and olb::LoadBalancer< T >::size().

Here is the call graph for this function:

◆ SuperCalcF2D() [2/3]

template<typename T , typename W , template< typename > class F>

olb::SuperCalcF2D< T, W, F >::SuperCalcF2D	(	W	scalar,
		FunctorPtr< SuperF2D< T, W > > &&	g )

Definition at line 83 of file superCalcF2D.hh.

  : SuperCalcF2D(
      std::unique_ptr<SuperF2D<T,W>>(new SuperConst2D<T,W>(g->getSuperStructure(), scalar)),
      std::forward<decltype(g)>(g))
{ }

◆ SuperCalcF2D() [3/3]

template<typename T , typename W , template< typename > class F>

olb::SuperCalcF2D< T, W, F >::SuperCalcF2D	(	FunctorPtr< SuperF2D< T, W > > &&	f,
		W	scalar )

Definition at line 90 of file superCalcF2D.hh.

  : SuperCalcF2D(
      std::forward<decltype(f)>(f),
      std::unique_ptr<SuperF2D<T,W>>(new SuperConst2D<T,W>(f->getSuperStructure(), scalar)))
{ }

Member Function Documentation

◆ operator()()

template<typename T , typename W , template< typename > class F>

bool olb::SuperCalcF2D< T, W, F >::operator()	(	W	output[],
		const int	input[] )

overridevirtual

has to be implemented for 'every' derived class

Implements olb::GenericF< W, int >.

Definition at line 97 of file superCalcF2D.hh.

{
  if ( _f->getTargetDim() == 1 || _g->getTargetDim() == 1 ) {
    // scalar operation
    W scalar;
    if ( _f->getTargetDim() == 1 ) {
      // apply the scalar f to possibly multidimensional g
      _f(&scalar, input);
      _g(output, input);
 
      for (int i = 0; i < this->getTargetDim(); i++) {
        output[i] = F<T>()(scalar, output[i]);
      }
    }
    else {
      // apply scalar g to possibly multidimensional f
      _f(output, input);
      _g(&scalar, input);
 
      for (int i = 0; i < this->getTargetDim(); i++) {
        output[i] = F<T>()(output[i], scalar);
      }
    }
  }
  else {
    // componentwise operation on equidimensional functors
    W* outputF = output;
    W outputG[this->getTargetDim()];
 
    _f(outputF, input);
    _g(outputG, input);
 
    for (int i = 0; i < this->getTargetDim(); i++) {
      output[i] = F<T>()(outputF[i], outputG[i]);
    }
  }
  return true;
}