olb::SuperPlaneIntegralF2D< T > Class Template Reference

Surface integral of a subset of a interpolated hyperplane. More...

#include <superPlaneIntegralF2D.h>

Inheritance diagram for olb::SuperPlaneIntegralF2D< T >:

Collaboration diagram for olb::SuperPlaneIntegralF2D< T >:

Public Member Functions
	SuperPlaneIntegralF2D (FunctorPtr< SuperF2D< T > > &&f, SuperGeometry< T, 2 > &geometry, const HyperplaneLattice2D< T > &hyperplaneLattice, FunctorPtr< SuperIndicatorF2D< T > > &&integrationIndicator, FunctorPtr< IndicatorF1D< T > > &&subplaneIndicator, BlockDataReductionMode mode=BlockDataReductionMode::Analytical)
	Primary constructor.
	SuperPlaneIntegralF2D (FunctorPtr< SuperF2D< T > > &&f, SuperGeometry< T, 2 > &geometry, const Hyperplane2D< T > &hyperplane, FunctorPtr< SuperIndicatorF2D< T > > &&integrationIndicator, FunctorPtr< IndicatorF1D< T > > &&subplaneIndicator, BlockDataReductionMode mode=BlockDataReductionMode::Analytical)
	Constructor providing automatic lattice generation.
	SuperPlaneIntegralF2D (FunctorPtr< SuperF2D< T > > &&f, SuperGeometry< T, 2 > &geometry, const Hyperplane2D< T > &hyperplane, FunctorPtr< SuperIndicatorF2D< T > > &&integrationIndicator, BlockDataReductionMode mode=BlockDataReductionMode::Analytical)
	Constructor providing automatic lattice generation and omitting subplane restriction.
	SuperPlaneIntegralF2D (FunctorPtr< SuperF2D< T > > &&f, SuperGeometry< T, 2 > &geometry, const Vector< T, 2 > &origin, const Vector< T, 2 > &u, std::vector< int > materials, BlockDataReductionMode mode=BlockDataReductionMode::Analytical)
	Constructor providing automatic lattice and material indicator instantiation.
	SuperPlaneIntegralF2D (FunctorPtr< SuperF2D< T > > &&f, SuperGeometry< T, 2 > &geometry, const Vector< T, 2 > &origin, const Vector< T, 2 > &u, BlockDataReductionMode mode=BlockDataReductionMode::Analytical)
	Constructor providing automatic lattice parametrization, only interpolating material 1.
bool	operator() (T output[], const int input[]) override
	Returns the line integral in the following structure:
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< 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)

Protected Member Functions
bool	isToBeIntegrated (const Vector< T, 2 > &physR, int iC)
	This is determined using the _integrationIndicatorF indicated subset of the 2d hyperplane reduced by _reductionF.
Protected Member Functions inherited from olb::SuperF2D< T, W >
	SuperF2D (SuperStructure< T, 2 > &superStructure, int targetDim)
Protected Member Functions inherited from olb::GenericF< T, S >
	GenericF (int targetDim, int sourceDim)

Protected Attributes
SuperGeometry< T, 2 > &	_geometry
FunctorPtr< SuperF2D< T > >	_f
	Functor to be integrated on the line.
FunctorPtr< SuperIndicatorF2D< T > >	_integrationIndicatorF
	Indicator describing relevant discrete integration points.
FunctorPtr< IndicatorF1D< T > >	_subplaneIndicatorF
	Indicator describing the relevant subset of the interpolated hyperplane.
BlockReduction2D1D< T >	_reductionF
	Functor describing line to be interpolated and integrated.
Vector< T, 2 >	_origin
	Origin vector as given by hyperplane definition, (0,0) in respect to the subplane indicator _subplaneIndicatorF.
Vector< T, 2 >	_u
	Direction vector u as given by hyperplane definition, normalized to h.
Vector< T, 2 >	_normal
	Orthogonal vector to _u.
std::vector< int >	_rankLocalSubplane
	Subset of the discrete line points given by _reductionF as indicated by _integrationIndicatorF.
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 = SuperIdentity2D<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)

Detailed Description

template<typename T>
class olb::SuperPlaneIntegralF2D< T >

Surface integral of a subset of a interpolated hyperplane.

Definition at line 44 of file superPlaneIntegralF2D.h.

Constructor & Destructor Documentation

SuperPlaneIntegralF2D() [1/5]

template<typename T >

olb::SuperPlaneIntegralF2D< T >::SuperPlaneIntegralF2D	(	FunctorPtr< SuperF2D< T > > &&	f,
		SuperGeometry< T, 2 > &	geometry,
		const HyperplaneLattice2D< T > &	hyperplaneLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	integrationIndicator,
		FunctorPtr< IndicatorF1D< T > > &&	subplaneIndicator,
		BlockDataReductionMode	mode = BlockDataReductionMode::Analytical )

Primary constructor.

All other constructors defer the actual construction to this constructor.

Parameters

f	(non-)owning pointer or reference to SuperF2D<T>.
hyperplaneLattice	Parametrization of the hyperplane lattice to be interpolated.
integrationIndicator	(non-)owning pointer or reference to SuperIndicatorF2D<T>. Describes the set of lattice points relevant for integration.
subplaneIndicator	(non-)owning pointer or reference to IndicatorF2D<T>. Describes the relevant subplane of the interpolated hyperplane.
mode	Defines how the values of the discrete hyperplane are determined. i.e. if they are interpolated or read directly from lattice points. Note: BlockDataReductionMode::Analytical imposes restrictions on hyperplane definition and discretization. If you are not sure consider providing only a hyperplane defintion instead of both a definition and a discretization.

Definition at line 56 of file superPlaneIntegralF2D.hh.

  : SuperF2D<T>(f->getSuperStructure(), 2 + f->getTargetDim()),
    _geometry(geometry),
    _f(std::move(f)),
    _integrationIndicatorF(std::move(integrationIndicator)),
    _subplaneIndicatorF(std::move(subplaneIndicator)),
    _reductionF(*_f,
                hyperplaneLattice,
                BlockDataSyncMode::None,
                mode),
    _origin(hyperplaneLattice.getHyperplane().origin),
    _u(hyperplaneLattice.getVectorU()),
    _normal(hyperplaneLattice.getHyperplane().normal)
{
  this->getName() = "SuperPlaneIntegralF2D";
 
  _normal = normalize(_normal);
  _u = normalize(_u);
 
  for ( const std::tuple<int,int>& pos : _reductionF.getRankLocalSubplane() ) {
    const int& i  = std::get<0>(pos);
    const int& iC = std::get<1>(pos);
    const Vector<T,2> physR = _reductionF.getPhysR(i);
    if (isToBeIntegrated(physR, iC)) {
      // check if interpolated hyperplane is to be restricted further
      // e.g. using IndicatorCircle2D
      if ( _subplaneIndicatorF ) {
        // determine physical coordinates relative to original hyperplane origin
        // [!] different from _reductionF._origin in the general case.
        const Vector<T,2> physRelativeToOrigin = physR - _origin;
        const T physOnHyperplane = physRelativeToOrigin * _u;
 
        if ( _subplaneIndicatorF->operator()(&physOnHyperplane) ) {
          _rankLocalSubplane.emplace_back(i);
        }
      }
      else {
        // plane is not restricted further
        _rankLocalSubplane.emplace_back(i);
      }
    }
  }
}

References olb::SuperPlaneIntegralF2D< T >::_normal, olb::SuperPlaneIntegralF2D< T >::_origin, olb::SuperPlaneIntegralF2D< T >::_rankLocalSubplane, olb::SuperPlaneIntegralF2D< T >::_reductionF, olb::SuperPlaneIntegralF2D< T >::_subplaneIndicatorF, olb::SuperPlaneIntegralF2D< T >::_u, olb::GenericF< T, S >::getName(), olb::SuperPlaneIntegralF2D< T >::isToBeIntegrated(), and olb::normalize().

Here is the call graph for this function:

SuperPlaneIntegralF2D() [2/5]

template<typename T >

olb::SuperPlaneIntegralF2D< T >::SuperPlaneIntegralF2D	(	FunctorPtr< SuperF2D< T > > &&	f,
		SuperGeometry< T, 2 > &	geometry,
		const Hyperplane2D< T > &	hyperplane,
		FunctorPtr< SuperIndicatorF2D< T > > &&	integrationIndicator,
		FunctorPtr< IndicatorF1D< T > > &&	subplaneIndicator,
		BlockDataReductionMode	mode = BlockDataReductionMode::Analytical )

Constructor providing automatic lattice generation.

Parameters

f	(non-)owning pointer or reference to SuperF2D<T>.
hyperplane	Parametrization of the hyperplane to be integrated. The lattice resolution is set to CuboidGeometry2D<T>::getMinDeltaR.
integrationIndicator	(non-)owning pointer or reference to SuperIndicatorF2D<T>. Describes the set of lattice points relevant for integration.
subplaneIndicator	(non-)owning pointer or reference to IndicatorF2D<T>. Describes the relevant subplane of the interpolated hyperplane.
mode	Defines how the values of the discrete hyperplane are determined. i.e. if they are interpolated or read directly from lattice points.

Definition at line 107 of file superPlaneIntegralF2D.hh.

  : SuperPlaneIntegralF2D(
      std::forward<decltype(f)>(f),
      geometry,
      HyperplaneLattice2D<T>(geometry.getCuboidGeometry(), hyperplane),
      std::forward<decltype(integrationIndicator)>(integrationIndicator),
      std::forward<decltype(subplaneIndicator)>(subplaneIndicator),
      mode)
{ }

SuperPlaneIntegralF2D() [3/5]

template<typename T >

olb::SuperPlaneIntegralF2D< T >::SuperPlaneIntegralF2D	(	FunctorPtr< SuperF2D< T > > &&	f,
		SuperGeometry< T, 2 > &	geometry,
		const Hyperplane2D< T > &	hyperplane,
		FunctorPtr< SuperIndicatorF2D< T > > &&	integrationIndicator,
		BlockDataReductionMode	mode = BlockDataReductionMode::Analytical )

Constructor providing automatic lattice generation and omitting subplane restriction.

i.e. the intersection between geometry and hyperplane is integrated wherever _integrationIndicatorF allows.

Parameters

f	(non-)owning pointer or reference to SuperF2D<T>.
hyperplane	Parametrization of the hyperplane to be integrated. The lattice resolution is set to the cuboid geometry's minDeltaR.
integrationIndicator	(non-)owning pointer or reference to SuperIndicatorF2D<T>. Describes the set of lattice points relevant for integration.
mode	Defines how the values of the discrete hyperplane are determined. i.e. if they are interpolated or read directly from lattice points.

Definition at line 124 of file superPlaneIntegralF2D.hh.

  : SuperPlaneIntegralF2D(
      std::forward<decltype(f)>(f),
      geometry,
      hyperplane,
      std::forward<decltype(integrationIndicator)>(integrationIndicator),
      nullptr,
      mode)
{ }

SuperPlaneIntegralF2D() [4/5]

template<typename T >

olb::SuperPlaneIntegralF2D< T >::SuperPlaneIntegralF2D	(	FunctorPtr< SuperF2D< T > > &&	f,
		SuperGeometry< T, 2 > &	geometry,
		const Vector< T, 2 > &	origin,
		const Vector< T, 2 > &	u,
		std::vector< int >	materials,
		BlockDataReductionMode	mode = BlockDataReductionMode::Analytical )

Constructor providing automatic lattice and material indicator instantiation.

Parameters

f	(non-)owning pointer or reference to SuperF2D<T>.
origin	hyperplane origin origin
u	hyperplane direction vector
materials	material numbers relevant for hyperplane integration
mode	defines how the values of the discrete hyperplane are determined

Definition at line 140 of file superPlaneIntegralF2D.hh.

  : SuperPlaneIntegralF2D(
      std::forward<decltype(f)>(f),
      geometry,
      Hyperplane2D<T>().originAt(origin).parallelTo(u),
      geometry.getMaterialIndicator(std::forward<decltype(materials)>(materials)),
      mode)
{ }

SuperPlaneIntegralF2D() [5/5]

template<typename T >

olb::SuperPlaneIntegralF2D< T >::SuperPlaneIntegralF2D	(	FunctorPtr< SuperF2D< T > > &&	f,
		SuperGeometry< T, 2 > &	geometry,
		const Vector< T, 2 > &	origin,
		const Vector< T, 2 > &	u,
		BlockDataReductionMode	mode = BlockDataReductionMode::Analytical )

Constructor providing automatic lattice parametrization, only interpolating material 1.

Parameters

f	(non-)owning pointer or reference to SuperF2D<T>.
origin	hyperplane origin
u	hyperplane direction vector
mode	defines how the values of the discrete hyperplane are determined

Definition at line 155 of file superPlaneIntegralF2D.hh.

  : SuperPlaneIntegralF2D(
      std::forward<decltype(f)>(f),
      geometry,
      origin, u,
      std::vector<int>(1,1),
      mode)
{ }

Member Function Documentation

isToBeIntegrated()

template<typename T >

bool olb::SuperPlaneIntegralF2D< T >::isToBeIntegrated ( const Vector< T, 2 > & physR, int iC )

protected

This is determined using the _integrationIndicatorF indicated subset of the 2d hyperplane reduced by _reductionF.

Returns

true iff the given physical position is to be integrated

Definition at line 36 of file superPlaneIntegralF2D.hh.

{
  Vector<int,3> latticeR;
  //get nearest lattice point
  if ( _geometry.getCuboidGeometry().getFloorLatticeR(physR, latticeR) ) {
    const int& iX = latticeR[1];
    const int& iY = latticeR[2];
 
    // interpolation is possible iff all neighbours are within the indicated subset
    return _integrationIndicatorF->operator()(   iC, iX,   iY  )
           && _integrationIndicatorF->operator()(iC, iX,   iY+1)
           && _integrationIndicatorF->operator()(iC, iX+1, iY  )
           && _integrationIndicatorF->operator()(iC, iX+1, iY+1);
  }
  else {
    return false;
  }
}

Here is the caller graph for this function:

operator()()

template<typename T >

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

override

Returns the line integral in the following structure:

output[0] = integral, e.g. flow[0] * h for 1-dimensional target sizes
output[1] = #voxels * h i.e. length of line
output[2..2+f.getTargetSize()] = flow

Note: output[0] contains the flux value if applicable

Parameters

input

irrelevant

Definition at line 170 of file superPlaneIntegralF2D.hh.

{
  this->getSuperStructure().communicate();
 
  _reductionF.update();
 
  const int flowDim = _reductionF.getTargetDim();
 
  std::vector<T> flow(flowDim,0.);
 
  for ( int pos : _rankLocalSubplane ) {
    T outputTmp[flowDim];
    _reductionF(outputTmp, pos);
 
    for ( int j = 0; j < flowDim; j++ ) {
      flow[j] += outputTmp[j];
    }
  }
 
  int vox = _rankLocalSubplane.size();
 
#ifdef PARALLEL_MODE_MPI
  for ( int j = 0; j < flowDim; j++ ) {
    singleton::mpi().reduceAndBcast(flow[j], MPI_SUM);
  }
  singleton::mpi().reduceAndBcast(vox, MPI_SUM);
#endif
 
  const T h = _reductionF.getPhysSpacing();
 
  switch ( flowDim ) {
  case 1: {
    output[0] = flow[0] * h;
    break;
  }
  case 2: {
    output[0] = (h * Vector<T,2>(flow)) * _normal;
    break;
  }
  }
 
  // area
  output[1] = vox * h;
  // write flow to output[2..]
  std::copy_n(flow.cbegin(), flowDim, &output[2]);
 
  return true;
}

References olb::GenericF< T, S >::getTargetDim(), olb::singleton::mpi(), and olb::singleton::MpiManager::reduceAndBcast().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_f

template<typename T >

FunctorPtr<SuperF2D<T> > olb::SuperPlaneIntegralF2D< T >::_f

protected

Functor to be integrated on the line.

Definition at line 49 of file superPlaneIntegralF2D.h.

_geometry

template<typename T >

SuperGeometry<T,2>& olb::SuperPlaneIntegralF2D< T >::_geometry

protected

Definition at line 46 of file superPlaneIntegralF2D.h.

_integrationIndicatorF

template<typename T >

FunctorPtr<SuperIndicatorF2D<T> > olb::SuperPlaneIntegralF2D< T >::_integrationIndicatorF

protected

Indicator describing relevant discrete integration points.

Definition at line 51 of file superPlaneIntegralF2D.h.

_normal

template<typename T >

Vector<T,2> olb::SuperPlaneIntegralF2D< T >::_normal

protected

Orthogonal vector to _u.

Definition at line 68 of file superPlaneIntegralF2D.h.

_origin

template<typename T >

Vector<T,2> olb::SuperPlaneIntegralF2D< T >::_origin

protected

Origin vector as given by hyperplane definition, (0,0) in respect to the subplane indicator _subplaneIndicatorF.

Note: The reduced plane _reductionF calculates its own origin based on _origin as its spans the maximum size possible given the direction vector, origin and geometry size.

Definition at line 64 of file superPlaneIntegralF2D.h.

_rankLocalSubplane

template<typename T >

std::vector<int> olb::SuperPlaneIntegralF2D< T >::_rankLocalSubplane

protected

Subset of the discrete line points given by _reductionF as indicated by _integrationIndicatorF.

i.e. the points used to interpolate the hyperplane

Definition at line 72 of file superPlaneIntegralF2D.h.

_reductionF

template<typename T >

BlockReduction2D1D<T> olb::SuperPlaneIntegralF2D< T >::_reductionF

protected

Functor describing line to be interpolated and integrated.

Definition at line 55 of file superPlaneIntegralF2D.h.

_subplaneIndicatorF

template<typename T >

FunctorPtr<IndicatorF1D<T> > olb::SuperPlaneIntegralF2D< T >::_subplaneIndicatorF

protected

Indicator describing the relevant subset of the interpolated hyperplane.

Definition at line 53 of file superPlaneIntegralF2D.h.

_u

template<typename T >

Vector<T,2> olb::SuperPlaneIntegralF2D< T >::_u

protected

Direction vector u as given by hyperplane definition, normalized to h.

Definition at line 66 of file superPlaneIntegralF2D.h.

---

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

• src/functors/lattice/integral/superPlaneIntegralF2D.h
• src/functors/lattice/integral/superPlaneIntegralF2D.hh