olb::Cuboid3D< T > Class Template Reference

A regular single 3D cuboid is the basic component of a 3D cuboid structure which defines the grid. More...

#include <cuboid3D.h>

Inheritance diagram for olb::Cuboid3D< T >:

Collaboration diagram for olb::Cuboid3D< T >:

Public Member Functions
	Cuboid3D ()
	Construction of an empty cuboid at position 0, 0, 0 with delta 0 and nX = nY = nZ = 0.
	Cuboid3D (T globPosX, T globPosY, T globPosZ, T delta, int nX, int nY, int nZ)
	Construction of a cuboid.
	Cuboid3D (std::vector< T > origin, T delta, std::vector< int > extend)
	Construction of a cuboid vector version.
	Cuboid3D (Vector< T, 3 > origin, T delta, Vector< int, 3 > extend)
	Cuboid3D (IndicatorF3D< T > &indicatorF, T voxelSize)
	Construction of a cuboid using indicator.
	Cuboid3D (Cuboid3D< T > const &rhs, int overlap=0)
	Copy constructor.
Cuboid3D &	operator= (Cuboid3D const &rhs)
	Copy assignment.
void	init (T globPosX, T globPosY, T globPosZ, T delta, int nX, int nY, int nZ)
	Initializes the cuboid.
Vector< T, 3 >	getOrigin () const
	Read only access to left lower corner coordinates.
T	getDeltaR () const
	Read only access to the distance of cuboid nodes.
int	getNx () const
	Read access to cuboid width.
int	getNy () const
	Read access to cuboid height.
int	getNz () const
	Read access to cuboid depth.
Vector< int, 3 > const	getExtent () const
	Read only access to the number of voxels in every dimension.
T	getPhysVolume () const
	Returns the volume of the cuboid.
int	getWeightValue () const
	Returns the actual value of weight (-1 for getLatticeVolume())
std::size_t	getWeight () const
	Returns the number of full cells.
std::size_t	getWeightIn (IndicatorF3D< T > &indicator) const
	Returns the number of full cells w.r.t. indicator.
void	setWeight (size_t fullCells)
	Sets the number of full cells.
T	getFraction () const
	Returns fraction of full cells (weight / volume)
size_t	getLatticeVolume () const
	Returns the number of Nodes in the volume.
T	getPhysPerimeter () const
	Returns the perimeter of the cuboid.
int	getLatticePerimeter () const
	Returns the number of Nodes at the perimeter.
void	refine (int factor)
	Refines by splitting each cell into factor^3 cells.
bool	getLatticeR (Vector< T, 3 > physR, Vector< int, 3 > &latticeR, T eps=1e-5)
bool	operator== (const Cuboid3D< T > &rhs) const
	equal operator
std::size_t	getNblock () const override
	Number of data blocks for the serializable interface.
std::size_t	getSerializableSize () const override
	Binary size for the serializer interface.
bool *	getBlock (std::size_t iBlock, std::size_t &sizeBlock, bool loadingMode) override
void	print () const
	Prints cuboid details.
void	getPhysR (T physR[3], const int latticeR[3]) const
void	getPhysR (T physR[3], const int &iX, const int &iY, const int &iZ) const
void	getPhysR (T physR[3], LatticeR< 3 > latticeR) const
void	getLatticeR (int latticeR[3], const T physR[3]) const
void	getLatticeR (int latticeR[3], const Vector< T, 3 > &physR) const
void	getFloorLatticeR (const std::vector< T > &physR, std::vector< int > &latticeR) const
void	getFloorLatticeR (int latticeR[3], const T physR[3]) const
bool	checkPoint (T globX, T globY, T globZ, int overlap=0) const
	Checks whether a point (globX/gloxY/globZ) is contained in the cuboid extended with an layer of size overlap*delta.
bool	checkPoint (Vector< T, 3 > &globXYZ, int overlap=0) const
bool	physCheckPoint (T globX, T globY, T globZ, double overlap=0) const
	Same for physical overlap.
bool	checkPoint (T globX, T globY, T globZ, int &locX, int &locY, int &locZ, int overlap=0) const
	Checks whether a point (globX/gloxY/globZ) is contained and is a node in the cuboid extended with an layer of size overlap*delta and returns the local active node.
bool	checkInters (T globX0, T globX1, T globY0, T globY1, T globZ0, T globZ1, int overlap=0) const
	Checks whether there is an intersection with the cuboid extended with an layer of size overlap*delta.
bool	checkInters (T globX, T globY, T globZ, int overlap=0) const
	Checks whether a given point intersects the cuboid extended by a layer of size overlap*delta.
bool	checkInters (T globX0, T globX1, T globY0, T globY1, T globZ0, T globZ1, int &locX0, int &locX1, int &locY0, int &locY1, int &locZ0, int &locZ1, int overlap=0) const
	Checks whether there is an intersection and returns the local active node range which can be empty by means of locX0=1, locX1=0, locY0=1, locY1=0, locZ0=1; locZ1=0 of the cuboid extended with an layer of size overlap*delta.
bool	checkInters (Cuboid3D< T > &child) const
	Returns true iff cuboid intersects child.
void	divide (int p, int q, int r, std::vector< Cuboid3D< T > > &childrenC) const
	Divides the cuboid in p*q*r cuboids of equal volume and add them to the given vector.
void	divide (int p, std::vector< Cuboid3D< T > > &childrenC) const
	Divides the cuboid in p cuboids of equal volume and add them to the given vector.
void	divideFractional (int iD, std::vector< T > fractions, std::vector< Cuboid3D< T > > &childrenC) const
	Divides the cuboid into fractions along the iDth dimension.
void	resize (int X, int Y, int Z, int nX, int nY, int nZ)
	resize the cuboid to the passed size
Public Member Functions inherited from olb::Serializable
virtual	~Serializable ()=default
template<bool includeLogOutputDir = true>
bool	save (std::string fileName="", const bool enforceUint=false)
	Save Serializable into file fileName
template<bool includeLogOutputDir = true>
bool	load (std::string fileName="", const bool enforceUint=false)
	Load Serializable from file fileName
bool	save (std::uint8_t *buffer)
	Save Serializable into buffer of length getSerializableSize
bool	load (const std::uint8_t *buffer)
	Load Serializable from buffer of length getSerializableSize
virtual void	postLoad ()

Static Public Member Functions
static Cuboid3D< T >	motherOf (Cuboid3D< T > a, Cuboid3D< T > b)
	Return minimum bounding cuboid encompassing both a and b.

Additional Inherited Members
Protected Member Functions inherited from olb::Serializable
template<typename DataType >
void	registerVar (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, const DataType &data, const size_t arrayLength=1) const
	Register primitive data types (int, double, ...) or arrays of those.
template<typename DataType >
void	registerSerializableOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, DataType &data, const bool loadingMode=false)
	Register Serializable object of constant size.
template<typename DataType >
void	registerSerializablesOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, DataType *data, const size_t arrayLength, const bool loadingMode=false)
	Register an array of Serializable objects of constant size.

Detailed Description

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

A regular single 3D cuboid is the basic component of a 3D cuboid structure which defines the grid.

A cuboid is given with its left lower corner, the number of nodes in the direction x, y and z and the distance between two nodes. Among after useful methods a cuboid can divide itself in a given number of disjoint subcuboids. The number of nodes at the boundary is minimized.

This class is not intended to be derived from.

Definition at line 58 of file cuboid3D.h.

Constructor & Destructor Documentation

Cuboid3D() [1/6]

template<typename T >

olb::Cuboid3D< T >::Cuboid3D

(

)

Construction of an empty cuboid at position 0, 0, 0 with delta 0 and nX = nY = nZ = 0.

Definition at line 50 of file cuboid3D.hh.

                      : Cuboid3D<T>(0, 0, 0, 0, 0, 0, 0)
{
}

Cuboid3D() [2/6]

template<typename T >

olb::Cuboid3D< T >::Cuboid3D	(	T	globPosX,
		T	globPosY,
		T	globPosZ,
		T	delta,
		int	nX,
		int	nY,
		int	nZ )

Construction of a cuboid.

Definition at line 55 of file cuboid3D.hh.

  : _weight(std::numeric_limits<size_t>::max()), clout(std::cout,"Cuboid3D")
{
  init(globPosX, globPosY, globPosZ, delta, nX, nY, nZ);
}

References olb::Cuboid3D< T >::init().

Here is the call graph for this function:

Cuboid3D() [3/6]

template<typename T >

olb::Cuboid3D< T >::Cuboid3D	(	std::vector< T >	origin,
		T	delta,
		std::vector< int >	extend )

Construction of a cuboid vector version.

Definition at line 63 of file cuboid3D.hh.

  : clout(std::cout,"Cuboid3D")
{
  _weight = std::numeric_limits<size_t>::max();
  init(origin[0], origin[1], origin[2], delta, extend[0], extend[1], extend[2]);
}

References olb::Cuboid3D< T >::init().

Here is the call graph for this function:

Cuboid3D() [4/6]

template<typename T >

olb::Cuboid3D< T >::Cuboid3D	(	Vector< T, 3 >	origin,
		T	delta,
		Vector< int, 3 >	extend )

Definition at line 71 of file cuboid3D.hh.

  : clout(std::cout,"Cuboid3D")
{
  _weight = std::numeric_limits<size_t>::max();
  init(origin[0], origin[1], origin[2], delta, extend[0], extend[1], extend[2]);
}

References olb::Cuboid3D< T >::init().

Here is the call graph for this function:

Cuboid3D() [5/6]

template<typename T >

olb::Cuboid3D< T >::Cuboid3D	(	IndicatorF3D< T > &	indicatorF,
		T	voxelSize )

Construction of a cuboid using indicator.

Definition at line 79 of file cuboid3D.hh.

  : clout(std::cout,"Cuboid3D")
{
  _weight = std::numeric_limits<size_t>::max();
  init(indicatorF.getMin()[0],  indicatorF.getMin()[1],  indicatorF.getMin()[2], voxelSize,
       (int)((indicatorF.getMax()[0]-indicatorF.getMin()[0])/voxelSize+1.5),
       (int)((indicatorF.getMax()[1]-indicatorF.getMin()[1])/voxelSize+1.5),
       (int)((indicatorF.getMax()[2]-indicatorF.getMin()[2])/voxelSize+1.5));
}

Cuboid3D() [6/6]

template<typename T >

olb::Cuboid3D< T >::Cuboid3D	(	Cuboid3D< T > const &	rhs,
		int	overlap = 0 )

Copy constructor.

Definition at line 91 of file cuboid3D.hh.

                                                         : clout(std::cout,"Cuboid3D")
{
  init( rhs._globPosX-rhs._delta*overlap, rhs._globPosY-rhs._delta*overlap,
        rhs._globPosZ-rhs._delta*overlap, rhs._delta, rhs._nX+2*overlap,
        rhs._nY+2*overlap, rhs._nZ+2*overlap);
  _weight = rhs._weight;
}

Member Function Documentation

checkInters() [1/4]

template<typename T >

bool olb::Cuboid3D< T >::checkInters

(

Cuboid3D< T > &

child

)

const

Returns true iff cuboid intersects child.

Definition at line 431 of file cuboid3D.hh.

{
  return checkInters(child.getOrigin()[0], child.getOrigin()[0] + child.getDeltaR()*(child.getExtent()[0]-1),
                     child.getOrigin()[1], child.getOrigin()[1] + child.getDeltaR()*(child.getExtent()[1]-1),
                     child.getOrigin()[2], child.getOrigin()[2] + child.getDeltaR()*(child.getExtent()[2]-1),
                     0);
}

References olb::Cuboid3D< T >::getDeltaR(), olb::Cuboid3D< T >::getExtent(), and olb::Cuboid3D< T >::getOrigin().

Here is the call graph for this function:

checkInters() [2/4]

template<typename T >

bool olb::Cuboid3D< T >::checkInters	(	T	globX,
		T	globY,
		T	globZ,
		int	overlap = 0 ) const

Checks whether a given point intersects the cuboid extended by a layer of size overlap*delta.

Definition at line 425 of file cuboid3D.hh.

{
  return checkInters(globX, globX, globY, globY, globZ, globZ, overlap);
}

checkInters() [3/4]

template<typename T >

bool olb::Cuboid3D< T >::checkInters	(	T	globX0,
		T	globX1,
		T	globY0,
		T	globY1,
		T	globZ0,
		T	globZ1,
		int &	locX0,
		int &	locX1,
		int &	locY0,
		int &	locY1,
		int &	locZ0,
		int &	locZ1,
		int	overlap = 0 ) const

Checks whether there is an intersection and returns the local active node range which can be empty by means of locX0=1, locX1=0, locY0=1, locY1=0, locZ0=1; locZ1=0 of the cuboid extended with an layer of size overlap*delta.

Definition at line 440 of file cuboid3D.hh.

{
  if (overlap!=0) {
    Cuboid3D tmp(_globPosX - overlap*_delta, _globPosY - overlap*_delta, _globPosZ - overlap*_delta,
                 _delta, _nX + overlap*2, _nY + overlap*2, _nZ + overlap*2);
    return tmp.checkInters(globX0, globX1, globY0, globY1, globZ0, globZ1,
                           locX0, locX1, locY0, locY1, locZ0, locZ1);
  }
  else if (!checkInters(globX0, globX1, globY0, globY1, globZ0, globZ1)) {
    locX0 = 1;
    locX1 = 0;
    locY0 = 1;
    locY1 = 0;
    locZ0 = 1;
    locZ1 = 0;
    return false;
  }
  else {
    locX0 = 0;
    for (int i=0; _globPosX + i*_delta < globX0; i++) {
      locX0 = i+1;
    }
    locX1 = _nX-1;
    for (int i=_nX-1; _globPosX + i*_delta > globX1; i--) {
      locX1 = i-1;
    }
    locY0 = 0;
    for (int i=0; _globPosY + i*_delta < globY0; i++) {
      locY0 = i+1;
    }
    locY1 = _nY-1;
    for (int i=_nY-1; _globPosY + i*_delta > globY1; i--) {
      locY1 = i-1;
    }
    locZ0 = 0;
    for (int i=0; _globPosZ + i*_delta < globZ0; i++) {
      locZ0 = i+1;
    }
    locZ1 = _nZ-1;
    for (int i=_nZ-1; _globPosZ + i*_delta > globZ1; i--) {
      locZ1 = i-1;
    }
    return true;
  }
}

References olb::Cuboid3D< T >::checkInters().

Here is the call graph for this function:

checkInters() [4/4]

template<typename T >

bool olb::Cuboid3D< T >::checkInters	(	T	globX0,
		T	globX1,
		T	globY0,
		T	globY1,
		T	globZ0,
		T	globZ1,
		int	overlap = 0 ) const

Checks whether there is an intersection with the cuboid extended with an layer of size overlap*delta.

Definition at line 409 of file cuboid3D.hh.

{
  T locX0d = util::max(_globPosX-overlap*_delta,globX0);
  T locY0d = util::max(_globPosY-overlap*_delta,globY0);
  T locZ0d = util::max(_globPosZ-overlap*_delta,globZ0);
  T locX1d = util::min(_globPosX+(_nX+overlap-1)*_delta,globX1);
  T locY1d = util::min(_globPosY+(_nY+overlap-1)*_delta,globY1);
  T locZ1d = util::min(_globPosZ+(_nZ+overlap-1)*_delta,globZ1);
 
  return locX1d >= locX0d
      && locY1d >= locY0d
      && locZ1d >= locZ0d;
}

References olb::util::max(), and olb::util::min().

Here is the call graph for this function:

Here is the caller graph for this function:

checkPoint() [1/3]

template<typename T >

bool olb::Cuboid3D< T >::checkPoint	(	T	globX,
		T	globY,
		T	globZ,
		int &	locX,
		int &	locY,
		int &	locZ,
		int	overlap = 0 ) const

Checks whether a point (globX/gloxY/globZ) is contained and is a node in the cuboid extended with an layer of size overlap*delta and returns the local active node.

Definition at line 389 of file cuboid3D.hh.

{
  if (overlap!=0) {
    Cuboid3D tmp(_globPosX - overlap*_delta, _globPosY - overlap*_delta, _globPosZ - overlap*_delta,
                 _delta, _nX + overlap*2, _nY + overlap*2, _nZ + overlap*2);
    return tmp.checkPoint(globX, globY, globZ, locX, locY, locZ);
  }
  else if (!checkPoint(globX, globY, globZ)) {
    return false;
  }
  else {
    locX = (int)util::floor((globX - (T)_globPosX)/_delta + .5);
    locY = (int)util::floor((globY - (T)_globPosY)/_delta + .5);
    locZ = (int)util::floor((globZ - (T)_globPosZ)/_delta + .5);
    return true;
  }
}

References olb::Cuboid3D< T >::checkPoint(), and olb::util::floor().

Here is the call graph for this function:

checkPoint() [2/3]

template<typename T >

bool olb::Cuboid3D< T >::checkPoint	(	T	globX,
		T	globY,
		T	globZ,
		int	overlap = 0 ) const

Checks whether a point (globX/gloxY/globZ) is contained in the cuboid extended with an layer of size overlap*delta.

Definition at line 361 of file cuboid3D.hh.

{
  return _globPosX <= globX + overlap * _delta + _delta / 2. &&
         _globPosX + T(_nX+overlap) * _delta  > globX + _delta / 2. &&
         _globPosY <= globY + overlap * _delta + _delta/2. &&
         _globPosY + T(_nY+overlap) * _delta  > globY + _delta / 2. &&
         _globPosZ <= globZ + overlap * _delta + _delta/2. &&
         _globPosZ + T(_nZ+overlap) * _delta  > globZ + _delta / 2.;
}

Here is the caller graph for this function:

checkPoint() [3/3]

template<typename T >

bool olb::Cuboid3D< T >::checkPoint	(	Vector< T, 3 > &	globXYZ,
		int	overlap = 0 ) const

Definition at line 372 of file cuboid3D.hh.

{
  return checkPoint(globXYZ[0], globXYZ[1], globXYZ[2], overlap);
}

divide() [1/2]

template<typename T >

void olb::Cuboid3D< T >::divide	(	int	p,
		int	q,
		int	r,
		std::vector< Cuboid3D< T > > &	childrenC ) const

Divides the cuboid in p*q*r cuboids of equal volume and add them to the given vector.

Definition at line 488 of file cuboid3D.hh.

{
  int xN_child = 0;
  int yN_child = 0;
  int zN_child = 0;
 
  T globPosX_child = _globPosX;
  T globPosY_child = _globPosY;
  T globPosZ_child = _globPosZ;
 
  for (int iX=0; iX<nX; iX++) {
    for (int iY=0; iY<nY; iY++) {
      for (int iZ=0; iZ<nZ; iZ++) {
        xN_child       = (_nX+nX-iX-1)/nX;
        yN_child       = (_nY+nY-iY-1)/nY;
        zN_child       = (_nZ+nZ-iZ-1)/nZ;
        Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                          _delta, xN_child, yN_child, zN_child);
        childrenC.push_back(child);
        globPosZ_child += zN_child*_delta;
      }
      globPosZ_child = _globPosZ;
      globPosY_child += yN_child*_delta;
    }
    globPosY_child = _globPosY;
    globPosX_child += xN_child*_delta;
  }
}

Here is the caller graph for this function:

divide() [2/2]

template<typename T >

void olb::Cuboid3D< T >::divide	(	int	p,
		std::vector< Cuboid3D< T > > &	childrenC ) const

Divides the cuboid in p cuboids of equal volume and add them to the given vector.

Definition at line 561 of file cuboid3D.hh.

{
 
  OLB_PRECONDITION(p>0);
 
  int iXX = 1;
  int iYY = 1;
  int iZZ = p;
  int nX = _nX/iXX;
  int bestIx = iXX;
  int nY = _nY/iYY;
  int bestIy = iYY;
  int nZ = _nZ/iZZ;
  int bestIz = iZZ;
  T bestRatio = ((T)(_nX/iXX)/(T)(_nY/iYY)-1)*((T)(_nX/iXX)/(T)(_nY/iYY)-1)
                + ((T)(_nY/iYY)/(T)(_nZ/iZZ)-1)*((T)(_nY/iYY)/(T)(_nZ/iZZ)-1)
                + ((T)(_nZ/iZZ)/(T)(_nX/iXX)-1)*((T)(_nZ/iZZ)/(T)(_nX/iXX)-1);
 
  for (int iX=1; iX<=p; iX++) {
    for (int iY=1; iY*iX<=p; iY++) {
      for (int iZ=p/(iX*iY); iZ*iY*iX<=p; iZ++) {
        if ((iX+1)*iY*iZ>p && iX*(iY+1)*iZ>p ) {
          T ratio = ((T)(_nX/iX)/(T)(_nY/iY)-1)*((T)(_nX/iX)/(T)(_nY/iY)-1)
                    + ((T)(_nY/iY)/(T)(_nZ/iZ)-1)*((T)(_nY/iY)/(T)(_nZ/iZ)-1)
                    + ((T)(_nZ/iZ)/(T)(_nX/iX)-1)*((T)(_nZ/iZ)/(T)(_nX/iX)-1);
          if (ratio<bestRatio) {
            bestRatio = ratio;
            bestIx = iX;
            bestIy = iY;
            bestIz = iZ;
            nX = _nX/iX;
            nY = _nY/iY;
            nZ = _nZ/iZ;
          }
        }
      }
    }
  }
 
  int rest = p - bestIx*bestIy*bestIz;
 
  // split in one cuboid
  if (rest==0) {
    divide(bestIx, bestIy, bestIz, childrenC);
    return;
  }
  else {
 
    // add in z than in y direction
    if (nZ>nY && nZ>nX) {
 
      int restY = rest%bestIy;
      // split in two cuboid
      if (restY==0) {
        int restX = rest/bestIy;
        CuboidGeometry2D<T> helpG(_globPosX, _globPosZ, _delta, _nX, _nZ, bestIx*bestIz+restX);
 
        int yN_child = 0;
        T globPosY_child = _globPosY;
 
        for (int iY=0; iY<bestIy; iY++) {
          yN_child         = (_nY+bestIy-iY-1)/bestIy;
          for (int iC=0; iC<helpG.getNc(); iC++) {
            int xN_child     = helpG.get(iC).getNx();
            int zN_child     = helpG.get(iC).getNy();
            T globPosX_child = helpG.get(iC).get_globPosX();
            T globPosZ_child = helpG.get(iC).get_globPosY();
 
            Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                              _delta, xN_child, yN_child, zN_child);
            childrenC.push_back(child);
 
          }
          globPosY_child += yN_child*_delta;
        }
        return;
      }
 
      // split in four cuboid
 
      int restX = rest/bestIy+1;
      int yN_child = 0;
      T globPosY_child = _globPosY;
      int splited_nY = (int) (_nY * (T)((bestIx*bestIz+restX)*restY)/(T)p);
      CuboidGeometry2D<T> helpG0(_globPosX, _globPosZ, _delta, _nX, _nZ, bestIx*bestIz+restX);
 
      for (int iY=0; iY<restY; iY++) {
        yN_child         = (splited_nY+restY-iY-1)/restY;
        for (int iC=0; iC<helpG0.getNc(); iC++) {
          int xN_child     = helpG0.get(iC).getNx();
          int zN_child     = helpG0.get(iC).getNy();
          T globPosX_child = helpG0.get(iC).get_globPosX();
          T globPosZ_child = helpG0.get(iC).get_globPosY();
 
          Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                            _delta, xN_child, yN_child, zN_child);
          childrenC.push_back(child);
        }
        globPosY_child += yN_child*_delta;
      }
 
      splited_nY = _nY - splited_nY;
      restX = rest/bestIy;
      CuboidGeometry2D<T> helpG1(_globPosX, _globPosZ, _delta, _nX, _nZ, bestIx*bestIz+restX);
      yN_child = 0;
 
      for (int iY=0; iY<bestIy-restY; iY++) {
        yN_child         = (splited_nY+bestIy-restY-iY-1)/(bestIy-restY);
        for (int iC=0; iC<helpG1.getNc(); iC++) {
          int xN_child     = helpG1.get(iC).getNx();
          int zN_child     = helpG1.get(iC).getNy();
          T globPosX_child = helpG1.get(iC).get_globPosX();
          T globPosZ_child = helpG1.get(iC).get_globPosY();
 
          Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                            _delta, xN_child, yN_child, zN_child);
          childrenC.push_back(child);
        }
        globPosY_child += yN_child*_delta;
      }
      return;
    }
 
    // add in x than in y direction
    else if (nX>nY && nX>nZ) {
      int restY = rest%bestIy;
      // split in two cuboid
      if (restY==0) {
        int restZ = rest/bestIy;
        CuboidGeometry2D<T> helpG(_globPosX, _globPosZ, _delta, _nX, _nZ, bestIx*bestIz+restZ);
 
        int yN_child = 0;
        T globPosY_child = _globPosY;
 
        for (int iY=0; iY<bestIy; iY++) {
          yN_child         = (_nY+bestIy-iY-1)/bestIy;
          for (int iC=0; iC<helpG.getNc(); iC++) {
            int xN_child     = helpG.get(iC).getNx();
            int zN_child     = helpG.get(iC).getNy();
            T globPosX_child = helpG.get(iC).get_globPosX();
            T globPosZ_child = helpG.get(iC).get_globPosY();
 
            Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                              _delta, xN_child, yN_child, zN_child);
            childrenC.push_back(child);
 
          }
          globPosY_child += yN_child*_delta;
        }
        return;
      }
 
      // split in four cuboid
 
      int restZ = rest/bestIy+1;
 
      int yN_child = 0;
      T globPosY_child = _globPosY;
      int splited_nY = (int) (_nY * (T)((bestIx*bestIz+restZ)*restY)/(T)p);
      CuboidGeometry2D<T> helpG0(_globPosX, _globPosZ, _delta, _nX, _nZ, bestIx*bestIz+restZ);
 
      for (int iY=0; iY<restY; iY++) {
        yN_child         = (splited_nY+restY-iY-1)/restY;
        for (int iC=0; iC<helpG0.getNc(); iC++) {
          int xN_child     = helpG0.get(iC).getNx();
          int zN_child     = helpG0.get(iC).getNy();
          T globPosX_child = helpG0.get(iC).get_globPosX();
          T globPosZ_child = helpG0.get(iC).get_globPosY();
 
          Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                            _delta, xN_child, yN_child, zN_child);
          childrenC.push_back(child);
        }
        globPosY_child += yN_child*_delta;
      }
 
      splited_nY = _nY - splited_nY;
      restZ = rest/bestIy;
 
      CuboidGeometry2D<T> helpG1(_globPosX, _globPosZ, _delta, _nX, _nZ, bestIx*bestIz+restZ);
      yN_child = 0;
 
      for (int iY=0; iY<bestIy-restY; iY++) {
        yN_child         = (splited_nY+bestIy-restY-iY-1)/(bestIy-restY);
        for (int iC=0; iC<helpG1.getNc(); iC++) {
          int xN_child     = helpG1.get(iC).getNx();
          int zN_child     = helpG1.get(iC).getNy();
          T globPosX_child = helpG1.get(iC).get_globPosX();
          T globPosZ_child = helpG1.get(iC).get_globPosY();
 
          Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                            _delta, xN_child, yN_child, zN_child);
          childrenC.push_back(child);
        }
        globPosY_child += yN_child*_delta;
      }
      return;
    }
 
    // add in y than in x direction
    else {
      int restX = rest%bestIx;
      // split in two cuboid
      if (restX==0) {
        int restZ = rest/bestIx;
        CuboidGeometry2D<T> helpG(_globPosZ, _globPosY, _delta, _nZ, _nY, bestIz*bestIy+restZ);
 
 
        int xN_child = 0;
        T globPosX_child = _globPosX;
 
        for (int iX=0; iX<bestIx; iX++) {
          xN_child         = (_nX+bestIx-iX-1)/bestIx;
          for (int iC=0; iC<helpG.getNc(); iC++) {
            int zN_child     = helpG.get(iC).getNx();
            int yN_child     = helpG.get(iC).getNy();
            T globPosZ_child = helpG.get(iC).get_globPosX();
            T globPosY_child = helpG.get(iC).get_globPosY();
 
            Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                              _delta, xN_child, yN_child, zN_child);
            childrenC.push_back(child);
          }
          globPosX_child += xN_child*_delta;
        }
        return;
      }
 
      // split in four cuboid
 
      int restZ = rest/bestIx+1;
      int xN_child = 0;
      T globPosX_child = _globPosX;
      int splited_nX = (int) (_nX * (T)((bestIz*bestIy+restZ)*restX)/(T)p);
      CuboidGeometry2D<T> helpG0(_globPosZ, _globPosY, _delta, _nZ, _nY, bestIz*bestIy+restZ);
 
      for (int iX=0; iX<restX; iX++) {
        xN_child         = (splited_nX+restX-iX-1)/restX;
        for (int iC=0; iC<helpG0.getNc(); iC++) {
          int zN_child     = helpG0.get(iC).getNx();
          int yN_child     = helpG0.get(iC).getNy();
          T globPosZ_child = helpG0.get(iC).get_globPosX();
          T globPosY_child = helpG0.get(iC).get_globPosY();
 
          Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                            _delta, xN_child, yN_child, zN_child);
          childrenC.push_back(child);
        }
        globPosX_child += xN_child*_delta;
      }
 
      splited_nX = _nX - splited_nX;
      restZ = rest/bestIx;
      CuboidGeometry2D<T> helpG1(_globPosZ, _globPosY, _delta, _nZ, _nY, bestIz*bestIy+restZ);
      xN_child = 0;
 
      for (int iX=0; iX<bestIx-restX; iX++) {
        xN_child         = (splited_nX+bestIx-restX-iX-1)/(bestIx-restX);
        for (int iC=0; iC<helpG1.getNc(); iC++) {
          int zN_child     = helpG1.get(iC).getNx();
          int yN_child     = helpG1.get(iC).getNy();
          T globPosZ_child = helpG1.get(iC).get_globPosX();
          T globPosY_child = helpG1.get(iC).get_globPosY();
 
          Cuboid3D<T> child(globPosX_child, globPosY_child, globPosZ_child,
                            _delta, xN_child, yN_child, zN_child);
          childrenC.push_back(child);
        }
        globPosX_child += xN_child*_delta;
      }
      return;
    }
  }
}

References olb::CuboidGeometry2D< T >::get(), olb::CuboidGeometry2D< T >::getNc(), and OLB_PRECONDITION.

Here is the call graph for this function:

divideFractional()

template<typename T >

void olb::Cuboid3D< T >::divideFractional	(	int	iD,
		std::vector< T >	fractions,
		std::vector< Cuboid3D< T > > &	childrenC ) const

Divides the cuboid into fractions along the iDth dimension.

Definition at line 530 of file cuboid3D.hh.

{
  auto delta = Vector<T,3>([&](int i) -> T {
    return i == iD ? _delta : 0;
  });
  auto base = Vector<int,3>([&](int i) -> T {
    return i == iD ? 1 : 0;
  });
 
  std::vector<int> fractionWidths;
  int totalWidth = 0;
  for (T f : fractions) {
    fractionWidths.emplace_back(f * (getExtent()*base));
    totalWidth += fractionWidths.back();
  }
  fractionWidths.back() += getExtent()*base - totalWidth;
 
  auto origin = getOrigin();
  auto extent = Vector<int,3>([&](int i) -> T {
    return i == iD ? 0 : getExtent()[i];
  });
 
  for (int width : fractionWidths) {
    Cuboid3D<T> child(origin, _delta, extent + (width)*base);
    child.print();
    origin += width*delta;
    childrenC.push_back(child);
  }
}

References olb::Cuboid3D< T >::print().

Here is the call graph for this function:

Here is the caller graph for this function:

getBlock()

template<typename T >

bool * olb::Cuboid3D< T >::getBlock ( std::size_t iBlock, std::size_t & sizeBlock, bool loadingMode )

overridevirtual

Returns

a pointer to the memory of the current block and its size for the serializable interface

Implements olb::Serializable.

Definition at line 266 of file cuboid3D.hh.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _globPosX);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _globPosY);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _globPosZ);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _delta);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _nX);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _nY);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _nZ);
  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _weight);
 
  return dataPtr;
}

getDeltaR()

template<typename T >

T olb::Cuboid3D< T >::getDeltaR

(

)

const

Read only access to the distance of cuboid nodes.

Definition at line 141 of file cuboid3D.hh.

{
  return _delta;
}

Here is the caller graph for this function:

getExtent()

template<typename T >

Vector< int, 3 > const olb::Cuboid3D< T >::getExtent

(

)

const

Read only access to the number of voxels in every dimension.

Definition at line 165 of file cuboid3D.hh.

{
  return Vector<int,3> (_nX, _nY, _nZ);
}

Here is the caller graph for this function:

getFloorLatticeR() [1/2]

template<typename T >

void olb::Cuboid3D< T >::getFloorLatticeR	(	const std::vector< T > &	physR,
		std::vector< int > &	latticeR ) const

Definition at line 347 of file cuboid3D.hh.

{
  getFloorLatticeR(&latticeR[0], &physR[0]);
}

getFloorLatticeR() [2/2]

template<typename T >

void olb::Cuboid3D< T >::getFloorLatticeR	(	int	latticeR[3],
		const T	physR[3] ) const

Definition at line 353 of file cuboid3D.hh.

{
  latticeR[0] = (int)util::floor( (physR[0] - _globPosX)/_delta);
  latticeR[1] = (int)util::floor( (physR[1] - _globPosY)/_delta);
  latticeR[2] = (int)util::floor( (physR[2] - _globPosZ)/_delta);
}

References olb::util::floor().

Here is the call graph for this function:

getFraction()

template<typename T >

T olb::Cuboid3D< T >::getFraction ( ) const

inline

Returns fraction of full cells (weight / volume)

Definition at line 115 of file cuboid3D.h.

                        {
    return T(getWeight()) / getLatticeVolume();
  }

References olb::Cuboid3D< T >::getLatticeVolume(), and olb::Cuboid3D< T >::getWeight().

Here is the call graph for this function:

getLatticePerimeter()

template<typename T >

int olb::Cuboid3D< T >::getLatticePerimeter

(

)

const

Returns the number of Nodes at the perimeter.

Definition at line 233 of file cuboid3D.hh.

{
  return 2*((_nX-1)*(_nY-1) + (_nY-1)*(_nZ-1) + (_nZ-1)*(_nX-1));
}

getLatticeR() [1/3]

template<typename T >

void olb::Cuboid3D< T >::getLatticeR	(	int	latticeR[3],
		const T	physR[3] ) const

Definition at line 331 of file cuboid3D.hh.

{
  latticeR[0] = (int)util::floor( (physR[0] - _globPosX )/_delta +.5);
  latticeR[1] = (int)util::floor( (physR[1] - _globPosY )/_delta +.5);
  latticeR[2] = (int)util::floor( (physR[2] - _globPosZ )/_delta +.5);
}

References olb::util::floor().

Here is the call graph for this function:

getLatticeR() [2/3]

template<typename T >

void olb::Cuboid3D< T >::getLatticeR	(	int	latticeR[3],
		const Vector< T, 3 > &	physR ) const

Definition at line 339 of file cuboid3D.hh.

{
  latticeR[0] = (int)util::floor( (physR[0] - _globPosX )/_delta +.5);
  latticeR[1] = (int)util::floor( (physR[1] - _globPosY )/_delta +.5);
  latticeR[2] = (int)util::floor( (physR[2] - _globPosZ )/_delta +.5);
}

References olb::util::floor().

Here is the call graph for this function:

getLatticeR() [3/3]

template<typename T >

bool olb::Cuboid3D< T >::getLatticeR ( Vector< T, 3 > physR, Vector< int, 3 > & latticeR, T eps = 1e-5 )

inline

Definition at line 128 of file cuboid3D.h.

                                                                           {
    auto globR = Vector<T,3>{_globPosX, _globPosY, _globPosZ};
    auto physLatticeR = (physR - globR) / _delta;
    if (   std::fabs(std::roundf(physLatticeR[0]) - physLatticeR[0]) <= eps
        && std::fabs(std::roundf(physLatticeR[1]) - physLatticeR[1]) <= eps
        && std::fabs(std::roundf(physLatticeR[2]) - physLatticeR[2]) <= eps) {
      latticeR[0] = std::roundf(physLatticeR[0]);
      latticeR[1] = std::roundf(physLatticeR[1]);
      latticeR[2] = std::roundf(physLatticeR[2]);
      return true;
    } else {
      return false;
    }
  }

Here is the caller graph for this function:

getLatticeVolume()

template<typename T >

size_t olb::Cuboid3D< T >::getLatticeVolume

(

)

const

Returns the number of Nodes in the volume.

Definition at line 221 of file cuboid3D.hh.

{
  return static_cast<size_t>(_nY)*static_cast<size_t>(_nX)*static_cast<size_t>(_nZ);
}

Here is the caller graph for this function:

getNblock()

template<typename T >

std::size_t olb::Cuboid3D< T >::getNblock ( ) const

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 123 of file cuboid3D.hh.

{
  return 9;
}

getNx()

template<typename T >

int olb::Cuboid3D< T >::getNx

(

)

const

Read access to cuboid width.

Definition at line 147 of file cuboid3D.hh.

{
  return _nX;
}

Here is the caller graph for this function:

getNy()

template<typename T >

int olb::Cuboid3D< T >::getNy

(

)

const

Read access to cuboid height.

Definition at line 153 of file cuboid3D.hh.

{
  return _nY;
}

Here is the caller graph for this function:

getNz()

template<typename T >

int olb::Cuboid3D< T >::getNz

(

)

const

Read access to cuboid depth.

Definition at line 159 of file cuboid3D.hh.

{
  return _nZ;
}

Here is the caller graph for this function:

getOrigin()

template<typename T >

Vector< T, 3 > olb::Cuboid3D< T >::getOrigin

(

)

const

Read only access to left lower corner coordinates.

Definition at line 135 of file cuboid3D.hh.

{
  return Vector<T,3> (_globPosX, _globPosY, _globPosZ);
}

Here is the caller graph for this function:

getPhysPerimeter()

template<typename T >

T olb::Cuboid3D< T >::getPhysPerimeter

(

)

const

Returns the perimeter of the cuboid.

Definition at line 227 of file cuboid3D.hh.

{
  return 2*_delta*_delta*(_nX*_nY + _nY*_nZ + _nZ*_nX);
}

getPhysR() [1/3]

template<typename T >

void olb::Cuboid3D< T >::getPhysR	(	T	physR[3],
		const int &	iX,
		const int &	iY,
		const int &	iZ ) const

Definition at line 323 of file cuboid3D.hh.

{
  physR[0] = _globPosX + iX*_delta;
  physR[1] = _globPosY + iY*_delta;
  physR[2] = _globPosZ + iZ*_delta;
}

getPhysR() [2/3]

template<typename T >

void olb::Cuboid3D< T >::getPhysR	(	T	physR[3],
		const int	latticeR[3] ) const

Definition at line 307 of file cuboid3D.hh.

{
  physR[0] = _globPosX + latticeR[0]*_delta;
  physR[1] = _globPosY + latticeR[1]*_delta;
  physR[2] = _globPosZ + latticeR[2]*_delta;
}

getPhysR() [3/3]

template<typename T >

void olb::Cuboid3D< T >::getPhysR	(	T	physR[3],
		LatticeR< 3 >	latticeR ) const

Definition at line 315 of file cuboid3D.hh.

{
  physR[0] = _globPosX + latticeR[0]*_delta;
  physR[1] = _globPosY + latticeR[1]*_delta;
  physR[2] = _globPosZ + latticeR[2]*_delta;
}

getPhysVolume()

template<typename T >

T olb::Cuboid3D< T >::getPhysVolume

(

)

const

Returns the volume of the cuboid.

Definition at line 171 of file cuboid3D.hh.

{
  return _nY*_nX*_nZ*_delta*_delta*_delta;
}

getSerializableSize()

template<typename T >

std::size_t olb::Cuboid3D< T >::getSerializableSize ( ) const

overridevirtual

Binary size for the serializer interface.

Implements olb::Serializable.

Definition at line 129 of file cuboid3D.hh.

{
  return ( 4 * sizeof(T) )  + ( 5 * sizeof(int) );
}

getWeight()

template<typename T >

size_t olb::Cuboid3D< T >::getWeight

(

)

const

Returns the number of full cells.

Definition at line 183 of file cuboid3D.hh.

{
  if (_weight == std::numeric_limits<size_t>::max()) {
    return getLatticeVolume();
  }
  else {
    return _weight;
  }
}

Here is the caller graph for this function:

getWeightIn()

template<typename T >

std::size_t olb::Cuboid3D< T >::getWeightIn

(

IndicatorF3D< T > &

indicator

)

const

Returns the number of full cells w.r.t. indicator.

Definition at line 194 of file cuboid3D.hh.

{
  std::size_t weight = 0;
  T physR[3] { };
  int latticeR[3] { };
  for (latticeR[0] = 0; latticeR[0] < getNx(); ++latticeR[0]) {
    for (latticeR[1] = 0; latticeR[1] < getNy(); ++latticeR[1]) {
      for (latticeR[2] = 0; latticeR[2] < getNz(); ++latticeR[2]) {
        getPhysR(physR, latticeR);
        bool inside;
        indicatorF(&inside, physR);
        if (inside) {
          weight += 1;
        }
      }
    }
  }
  return weight;
}

getWeightValue()

template<typename T >

int olb::Cuboid3D< T >::getWeightValue

(

)

const

Returns the actual value of weight (-1 for getLatticeVolume())

Definition at line 177 of file cuboid3D.hh.

{
  return _weight;
}

init()

template<typename T >

void olb::Cuboid3D< T >::init	(	T	globPosX,
		T	globPosY,
		T	globPosZ,
		T	delta,
		int	nX,
		int	nY,
		int	nZ )

Initializes the cuboid.

Definition at line 111 of file cuboid3D.hh.

{
  _globPosX = globPosX;
  _globPosY = globPosY;
  _globPosZ = globPosZ;
  _delta    = delta;
  _nX       = nX;
  _nY       = nY;
  _nZ       = nZ;
}

Here is the caller graph for this function:

motherOf()

template<typename T >

static Cuboid3D< T > olb::Cuboid3D< T >::motherOf ( Cuboid3D< T > a, Cuboid3D< T > b )

static

Return minimum bounding cuboid encompassing both a and b.

operator=()

template<typename T >

Cuboid3D< T > & olb::Cuboid3D< T >::operator=

(

Cuboid3D< T > const &

rhs

)

Copy assignment.

Definition at line 102 of file cuboid3D.hh.

{
  init( rhs._globPosX, rhs._globPosY, rhs._globPosZ, rhs._delta, rhs._nX,
        rhs._nY, rhs._nZ);
  _weight = rhs._weight;
  return *this;
}

operator==()

template<typename T >

bool olb::Cuboid3D< T >::operator==

(

const Cuboid3D< T > &

rhs

)

const

equal operator

Definition at line 252 of file cuboid3D.hh.

{
  return util::nearZero<T>(_globPosX - rhs._globPosX) &&
         util::nearZero<T>(_globPosY - rhs._globPosY) &&
         util::nearZero<T>(_globPosZ - rhs._globPosZ) &&
         util::nearZero<T>(_delta    - rhs._delta) &&
         _nX              == rhs._nX &&
         _nY              == rhs._nY &&
         _nZ              == rhs._nZ &&
         _weight          == rhs._weight;
}

physCheckPoint()

template<typename T >

bool olb::Cuboid3D< T >::physCheckPoint	(	T	globX,
		T	globY,
		T	globZ,
		double	overlap = 0 ) const

Same for physical overlap.

Definition at line 378 of file cuboid3D.hh.

{
  return _globPosX <= globX + T(0.5 + overlap) * _delta &&
         _globPosX + T(_nX+overlap)*_delta  > globX + _delta / 2. &&
         _globPosY <= globY + T(0.5 + overlap)*_delta &&
         _globPosY + T(_nY+overlap)*_delta  > globY + _delta / 2. &&
         _globPosZ <= globZ + T(0.5 + overlap)*_delta &&
         _globPosZ + T(_nZ+overlap)*_delta  > globZ + _delta / 2.;
}

print()

template<typename T >

void olb::Cuboid3D< T >::print

(

)

const

Prints cuboid details.

Definition at line 284 of file cuboid3D.hh.

{
  clout << "--------Cuboid Details----------" << std::endl;
  clout << " Corner (x/y/z): " << "\t" << "("
        << _globPosX-_delta/2. << "/" << _globPosY - _delta/2.
        << "/" << _globPosZ - _delta/2. << ")" << std::endl;
  clout << " Delta: " << "\t" << "\t" << getDeltaR() << std::endl;
  clout << " Perimeter: " << "\t" << "\t" << getPhysPerimeter() << std::endl;
  clout << " Volume: " << "\t" << "\t" << getPhysVolume() << std::endl;
  clout << " Extent (x/y/z): " << "\t" << "("
        << getNx() << "/" << getNy() << "/"
        << getNz() << ")" << std::endl;
  clout << " Nodes at Perimeter: " << "\t" << getLatticePerimeter() << std::endl;
  clout << " Nodes in Volume: " << "\t" << getLatticeVolume() << std::endl;
  clout << " Nodes in Indicator: " << "\t" << getWeight() << std::endl;
  clout << " Other Corner: "  << "\t"<<  "(" << _globPosX + T(_nX-0.5)*_delta << "/"
        << _globPosY + T(_nY-0.5)*_delta << "/"
        << _globPosZ + T(_nZ-0.5)*_delta <<  ")" << std::endl;
  clout << "--------------------------------" << std::endl;
 
}

Here is the caller graph for this function:

refine()

template<typename T >

void olb::Cuboid3D< T >::refine

(

int

factor

)

Refines by splitting each cell into factor^3 cells.

Definition at line 239 of file cuboid3D.hh.

                                   {
  if (factor < 1) {
    throw std::invalid_argument("refinement factor must be >= 1");
  } else if (factor > 1) {
    _delta /= factor;
    _nX *= factor;
    _nY *= factor;
    _nZ *= factor;
    _weight *= factor*factor*factor;
  }
}

resize()

template<typename T >

void olb::Cuboid3D< T >::resize	(	int	X,
		int	Y,
		int	Z,
		int	nX,
		int	nY,
		int	nZ )

resize the cuboid to the passed size

Definition at line 518 of file cuboid3D.hh.

{
  _globPosX = _globPosX+iX*_delta;
  _globPosY = _globPosY+iY*_delta;
  _globPosZ = _globPosZ+iZ*_delta;
 
  _nX = nX;
  _nY = nY;
  _nZ = nZ;
}

setWeight()

template<typename T >

void olb::Cuboid3D< T >::setWeight

(

size_t

fullCells

)

Sets the number of full cells.

Definition at line 215 of file cuboid3D.hh.

{
  _weight = fullCells;
}

---

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

• src/communication/heuristicLoadBalancer.hh
• src/geometry/cuboid3D.h
• src/geometry/cuboid3D.hh