Arithmetic operations for SuperF3D functors. More...

#include <superCalcF3D.h>

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

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

Public Member Functions
	SuperCalcF3D (FunctorPtr< SuperF3D< T, W > > &&f, FunctorPtr< SuperF3D< T, W > > &&g)

	SuperCalcF3D (W scalar, FunctorPtr< SuperF3D< T, W > > &&g)

	SuperCalcF3D (FunctorPtr< SuperF3D< 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::SuperF3D< T, W >
SuperF3D< T, W > &	operator- (SuperF3D< T, W > &rhs)

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

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

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

SuperStructure< T, 3 > &	getSuperStructure ()

int	getBlockFSize () const

BlockF3D< W > &	getBlockF (int iCloc)

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

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< SuperF3D< T, W > >	_f

FunctorPtr< SuperF3D< T, W > >	_g

Protected Attributes inherited from olb::SuperF3D< T, W >
SuperStructure< T, 3 > &	_superStructure

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

Additional Inherited Members
Public Types inherited from olb::SuperF3D< 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)

Static Public Attributes inherited from olb::SuperF3D< T, W >
static constexpr bool	isSuper

static constexpr unsigned	d

Protected Member Functions inherited from olb::SuperF3D< T, W >
	SuperF3D (SuperStructure< T, 3 > &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::SuperCalcF3D< T, W, F >

Arithmetic operations for SuperF3D 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 BlockCalcF3D.

All operations are performed componentwise if functor target dimensions are equal. If at least one of the target dimensions is equal to 1 it is applied to the other functor as a scalar (i.e. scalar multiplication, addition...).

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

Definition at line 58 of file superCalcF3D.h.

Constructor & Destructor Documentation

◆ SuperCalcF3D() [1/3]

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

olb::SuperCalcF3D< T, W, F >::SuperCalcF3D	(	FunctorPtr< SuperF3D< T, W > > &&	f,
		FunctorPtr< SuperF3D< T, W > > &&	g )

Definition at line 37 of file superCalcF3D.hh.

  : SuperF3D<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 BlockCalcF3D<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 BlockCalcF3D<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 BlockCalcF3D<W,F>(*f, load.glob(iC), _g->getBlockF(iC))
      );
    }
  }
}

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

Here is the call graph for this function:

◆ SuperCalcF3D() [2/3]

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

olb::SuperCalcF3D< T, W, F >::SuperCalcF3D	(	W	scalar,
		FunctorPtr< SuperF3D< T, W > > &&	g )

Definition at line 83 of file superCalcF3D.hh.

  : SuperCalcF3D(
      std::unique_ptr<SuperF3D<T,W>>(new SuperConst3D<T,W>(g->getSuperStructure(), scalar)),
      std::forward<decltype(g)>(g))
{ }

◆ SuperCalcF3D() [3/3]

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

olb::SuperCalcF3D< T, W, F >::SuperCalcF3D	(	FunctorPtr< SuperF3D< T, W > > &&	f,
		W	scalar )

Definition at line 90 of file superCalcF3D.hh.

  : SuperCalcF3D(
      std::forward<decltype(f)>(f),
      std::unique_ptr<SuperF3D<T,W>>(new SuperConst3D<T,W>(f->getSuperStructure(), scalar)))
{ }

Member Function Documentation

◆ operator()()

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

bool olb::SuperCalcF3D< 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 superCalcF3D.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;
}