olb::SuperVarianceF3D< T, W > Class Template Reference

SuperVarianceF3D returns the Variance in each component of f on a indicated subset calcutalted with Steiner translation theorem. More...

#include <superStatisticF3D.h>

Inheritance diagram for olb::SuperVarianceF3D< T, W >:

Collaboration diagram for olb::SuperVarianceF3D< T, W >:

Public Member Functions
	SuperVarianceF3D (FunctorPtr< SuperF3D< T, W > > &&f, SuperGeometry< T, 3 > &superGeometry, const int material, T expectedValue)
	Constructor for determining the standard deviation of f on a indicated subset.
	SuperVarianceF3D (FunctorPtr< SuperF3D< T, W > > &&f, FunctorPtr< SuperIndicatorF3D< T > > &&indicatorF, T expectedValue)
bool	operator() (W output[], const int input[]) override
	Global average operator.
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< T, S >
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
virtual bool	operator() (T output[], const S input[])=0
	has to be implemented for 'every' derived class
bool	operator() (T output[])
	wrapper that call the pure virtual operator() (T output[], const S input[]) from above
bool	operator() (T output[], S input0)
bool	operator() (T output[], S input0, S input1)
bool	operator() (T output[], S input0, S input1, S input2)
bool	operator() (T output[], S input0, S input1, S input2, S input3)

Additional Inherited Members
Public Types inherited from olb::SuperF3D< T, W >
using	identity_functor_type = SuperIdentity3D<T,W>
Public Types inherited from olb::GenericF< T, S >
using	targetType = T
using	sourceType = S
Public Attributes inherited from olb::GenericF< T, S >
std::shared_ptr< GenericF< T, S > >	_ptrCalcC
	memory management, frees resouces (calcClass)
Static Public Attributes inherited from olb::SuperF3D< T, W >
static constexpr bool	isSuper = true
static constexpr unsigned	d = 3
Protected Member Functions inherited from olb::SuperF3D< T, W >
	SuperF3D (SuperStructure< T, 3 > &superStructure, int targetDim)
Protected Member Functions inherited from olb::GenericF< T, S >
	GenericF (int targetDim, int sourceDim)
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.

Detailed Description

template<typename T, typename W = T>
class olb::SuperVarianceF3D< T, W >

SuperVarianceF3D returns the Variance in each component of f on a indicated subset calcutalted with Steiner translation theorem.

Definition at line 37 of file superStatisticF3D.h.

Constructor & Destructor Documentation

SuperVarianceF3D() [1/2]

template<typename T , typename W >

olb::SuperVarianceF3D< T, W >::SuperVarianceF3D	(	FunctorPtr< SuperF3D< T, W > > &&	f,
		SuperGeometry< T, 3 > &	superGeometry,
		const int	material,
		T	expectedValue )

Constructor for determining the standard deviation of f on a indicated subset.

Parameters

f	functor of which the standard deviation is to be determined
indicatorF	indicator describing the subset on which to evaluate f Constructor for determining the standard deviation of f on a given material
f	functor of which the average is to be determined
superGeometry	super geometry for constructing material indicator
material	number of the relevant material

Definition at line 61 of file superStatisticF3D.hh.

  : SuperVarianceF3D(
      std::forward<decltype(f)>(f),
      superGeometry.getMaterialIndicator(material),
      expectedValue)
{ }

SuperVarianceF3D() [2/2]

template<typename T , typename W >

olb::SuperVarianceF3D< T, W >::SuperVarianceF3D	(	FunctorPtr< SuperF3D< T, W > > &&	f,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicatorF,
		T	expectedValue )

Definition at line 34 of file superStatisticF3D.hh.

  : SuperF3D<T,W>(f->getSuperStructure(), f->getTargetDim()+1),
    _f(std::move(f)),
    _indicatorF(std::move(indicatorF)),
    _expectedValue(expectedValue)
{
  this->getName() = "Variance("+_f->getName()+")";
 
  LoadBalancer<T>& load = _f->getSuperStructure().getLoadBalancer();
  CuboidGeometry3D<T>& cuboid = _f->getSuperStructure().getCuboidGeometry();
 
  if ( _f->getBlockFSize()          == load.size() &&
       _indicatorF->getBlockFSize() == load.size() ) {
    for (int iC = 0; iC < load.size(); ++iC) {
      this->_blockF.emplace_back(
        new BlockVarianceF3D<T,W>(_f->getBlockF(iC),
                                  _indicatorF->getBlockIndicatorF(iC),
                                  cuboid.get(load.glob(iC)),
                                  _expectedValue)
      );
    }
  }
}

References olb::SuperF3D< T, W >::_blockF, olb::CuboidGeometry3D< T >::get(), olb::GenericF< T, S >::getName(), olb::LoadBalancer< T >::glob(), and olb::LoadBalancer< T >::size().

Here is the call graph for this function:

Member Function Documentation

operator()()

template<typename T , typename W >

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

override

Global average operator.

Note: While this functor exposes BlockStdDeviation3D functors if possible, a call to this function will not use them but calculate the global standard deviation by summing all components and voxel counts. Calling BlockStdDevation3D in this situation would unnecessarily complicate this as we would have to weight the aggregated averages according to their share in the global average.

Definition at line 72 of file superStatisticF3D.hh.

{
  _f->getSuperStructure().communicate();
  CuboidGeometry3D<T>& geometry = _f->getSuperStructure().getCuboidGeometry();
  LoadBalancer<T>&     load     = _f->getSuperStructure().getLoadBalancer();
 
  std::size_t voxels(0);
 
  for (int i = 0; i <= _f->getTargetDim(); ++i) {
    output[i] = W(0);
  }
 
  if (this->_blockF.empty()) {
    W outputTmp[_f->getTargetDim()];
    for(unsigned i=0; i<_f->getTargetDim(); ++i) {
      outputTmp[i] = W(0);
    }
    int inputTmp[_f->getSourceDim()];
 
    for (int iC = 0; iC < load.size(); ++iC) {
      const Cuboid3D<T> cuboid = geometry.get(load.glob(iC));
      inputTmp[0] = load.glob(iC);
      for (inputTmp[1] = 0; inputTmp[1] < cuboid.getNx(); ++inputTmp[1]) {
        for (inputTmp[2] = 0; inputTmp[2] < cuboid.getNy(); ++inputTmp[2]) {
          for (inputTmp[3] = 0; inputTmp[3] < cuboid.getNz(); ++inputTmp[3]) {
            if (_indicatorF(inputTmp)) {
              _f(outputTmp,inputTmp);
              for (int i = 0; i < _f->getTargetDim(); ++i) {
                output[i] += util::pow(outputTmp[i] - _expectedValue, 2);
              }
              voxels += 1;
            }
          }
        }
      }
      output[_f->getTargetDim()] += voxels;
    }
  }
  else {
    for (int iC = 0; iC < load.size(); ++iC) {
      this->getBlockF(iC)(output, input);
    }
  }
 
#ifdef PARALLEL_MODE_MPI
  for (int i = 0; i <= this->getTargetDim(); ++i) {
    singleton::mpi().reduceAndBcast(output[i], MPI_SUM);
  }
#endif
 
  for (int i = 0; i < _f->getTargetDim(); ++i) {
    output[i] = output[i] / output[_f->getTargetDim()];
  }
 
  return true;
}

References olb::SuperStructure< T, D >::communicate(), olb::CuboidGeometry3D< T >::get(), olb::Cuboid3D< T >::getNx(), olb::Cuboid3D< T >::getNy(), olb::Cuboid3D< T >::getNz(), olb::SuperF3D< T, W >::getSuperStructure(), olb::LoadBalancer< T >::glob(), olb::singleton::mpi(), olb::util::pow(), olb::singleton::MpiManager::reduceAndBcast(), and olb::LoadBalancer< T >::size().

Here is the call graph for this function:

---

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

• src/functors/lattice/superStatisticF3D.h
• src/functors/lattice/superStatisticF3D.hh