olb::CuboidGeometry2D< T > Class Template Reference

A cuboid structure represents the grid of a considered domain. More...

#include <cuboidGeometry2D.h>

Collaboration diagram for olb::CuboidGeometry2D< T >:

Public Member Functions
	CuboidGeometry2D ()
	Constructs empty Geometry.
	CuboidGeometry2D (T originX, T originY, T deltaR, int nX, int nY, int nC=1)
	Constructs a cuboid geometry with a cubic shape of size nX times nY with origin originR=(originX, originY) that consits of nC cuboids.
	CuboidGeometry2D (IndicatorF2D< T > &indicatorF, T voxelSize, int nC=1)
	Constructs a cuboid structure with a uniform spacing of voxelsize which consits of nC cuboids, the cuboids not needed are removed and too big ones are shrinked.
void	reInit (T globPosX, T globPosY, T delta, int nX, int nY, int nC=1)
	Re init.
Cuboid2D< T > &	get (int i)
	Read and write access to the cuboids.
Cuboid2D< T > const &	get (int i) const
	Read access to the cuboids.
void	setPeriodicity (bool periodicityX, bool periodicityY)
	Set flag to enable/disable periodicity.
bool	getC (std::vector< T > physR, int &iC) const
	Returns true and the cuboid number of the nearest lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.
bool	getC (const Vector< T, 2 > &physR, int &iC) const
	Returns true and the cuboid number of the nearest lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.
bool	getLatticeR (std::vector< T > physR, std::vector< int > &latticeR) const
	Returns true and the nearest lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.
bool	getLatticeR (int latticeR[], const T physR[]) const
bool	getLatticeR (const Vector< T, 2 > &physR, Vector< int, 3 > &latticeR) const
bool	getFloorLatticeR (std::vector< T > physR, std::vector< int > &latticeR) const
	Returns true and the util::floor lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.
bool	getFloorLatticeR (const Vector< T, 2 > &physR, Vector< int, 3 > &latticeR) const
	Returns true and the util::floor lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.
std::vector< T >	getPhysR (int iCglob, int iX, int iY) const
	Returns the physical position to the given lattice position respecting periodicity for the overlap nodes which are not in the mother cuboid for the case the flag periodicityOn[iDim]=true if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.
std::vector< T >	getPhysR (std::vector< int > latticeR) const
	Returns the physical position to the given lattice position respecting periodicity for the overlap nodes which are not in the mother cuboid for the case the flag periodicityOn[iDim]=true.
void	getPhysR (T output[2], const int latticeR[3]) const
void	getPhysR (T output[2], const int iCglob, const int iX, const int iY) const
void	getPhysR (T output[2], const int iCglob, LatticeR< 2 > latticeR) const
void	getPhysR (T output[3], LatticeR< 3 > latticeR) const
int	getNc () const
	Returns the number of cuboids in t < 2he structure.
T	getMinRatio () const
	Returns the maximum/minimum of the ratio nX/NY in the structure.
T	getMaxRatio () const
std::vector< T >	getMinPhysR () const
	Returns the minimum coordinate in the structure.
std::vector< T >	getMaxPhysR () const
	Returns the maximum coordinate in the structure.
T	getMinPhysVolume () const
	Returns the maximum/minimum volume in the structure.
T	getMaxPhysVolume () const
size_t	getMinLatticeVolume () const
	Returns the maximum/minimum number of nodes in the structure.
size_t	getMaxLatticeVolume () const
T	getMinDeltaR () const
	Returns the maximum/minimum delata in the structure.
T	getMaxDeltaR () const
Cuboid2D< T >	getMotherCuboid () const
	Returns the smallest cuboid that includes all cuboids of the structure.
int	get_iC (T globX, T globY, int offset=0) const
	for a given point (globX/globY), returns the related cuboidID and _p if the point is not in any of the cuboid _childrenQ
int	get_iC (T globX, T globY, int orientationX, int orientationY) const
	This function checks if the points (globX/globY) and (globX + orientationX/delta /globY + orientationY/delta) is in a cuboid.
void	add (Cuboid2D< T > cuboid)
	Adds a cuboid.
void	remove (int iC)
	Removes the cuboid iC.
void	split (int iC, int p)
	Removes all cuboids where geometryData = 0.
void	shrink (IndicatorF2D< T > &indicatorF)
	Shrink all cuboids so that no empty planes are left.
void	getNeighbourhood (int cuboid, std::vector< int > &neighbours, int offset=0)
	stores the neighbouring cuboids in array neighbours;
void	print () const
	Prints cuboid geometry details.
void	printExtended ()
	Prints cuboid geometry details plus details of all cuboids.

Detailed Description

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

A cuboid structure represents the grid of a considered domain.

A cuboid structure is given by a number of cuboids. To represent a connected domain it is required that the distance between two neighbooring cuboids is less than the smallest delta of them.

WARNING: At the moment there are only cuboids with a constant delta possible and the distance between two neighbooring cuboids must be delta since an interpolation operator in time and space is missing in cuboidNeigbourhood and superLattice.

This class is not intended to be derived from.

Definition at line 56 of file cuboidGeometry2D.h.

Constructor & Destructor Documentation

CuboidGeometry2D() [1/3]

template<typename T >

olb::CuboidGeometry2D< T >::CuboidGeometry2D

(

)

Constructs empty Geometry.

Definition at line 44 of file cuboidGeometry2D.hh.

  : _motherCuboid(0,0,0,0,0), _periodicityOn(3, bool(false)), clout(std::cout, "CuboidGeometry3D")
{
  add(_motherCuboid);
  split(0, 1);
}

References olb::CuboidGeometry2D< T >::add(), and olb::CuboidGeometry2D< T >::split().

Here is the call graph for this function:

CuboidGeometry2D() [2/3]

template<typename T >

olb::CuboidGeometry2D< T >::CuboidGeometry2D	(	T	originX,
		T	originY,
		T	deltaR,
		int	nX,
		int	nY,
		int	nC = 1 )

Constructs a cuboid geometry with a cubic shape of size nX times nY with origin originR=(originX, originY) that consits of nC cuboids.

Definition at line 52 of file cuboidGeometry2D.hh.

  : _motherCuboid(originX, originY, deltaR, nX, nY), _periodicityOn(2, bool(false)),
    clout(std::cout, "CuboidGeometry2D")
{
  add(_motherCuboid);
  split(0, nC);
}

References olb::CuboidGeometry2D< T >::add(), and olb::CuboidGeometry2D< T >::split().

Here is the call graph for this function:

CuboidGeometry2D() [3/3]

template<typename T >

olb::CuboidGeometry2D< T >::CuboidGeometry2D	(	IndicatorF2D< T > &	indicatorF,
		T	voxelSize,
		int	nC = 1 )

Constructs a cuboid structure with a uniform spacing of voxelsize which consits of nC cuboids, the cuboids not needed are removed and too big ones are shrinked.

Definition at line 61 of file cuboidGeometry2D.hh.

  : _motherCuboid(indicatorF.getMin()[0],  indicatorF.getMin()[1], voxelSize,
                  (int)((indicatorF.getMax()[0] - indicatorF.getMin()[0]) / voxelSize + 1.5),
                  (int)((indicatorF.getMax()[1] - indicatorF.getMin()[1]) / voxelSize + 1.5)),
    _periodicityOn(2, bool(false)), clout(std::cout, "CuboidGeometry2D")
{
 
  add(_motherCuboid);
  split(0, nC);
  shrink(indicatorF);
}

References olb::CuboidGeometry2D< T >::add(), olb::CuboidGeometry2D< T >::shrink(), and olb::CuboidGeometry2D< T >::split().

Here is the call graph for this function:

Member Function Documentation

add()

template<typename T >

void olb::CuboidGeometry2D< T >::add

(

Cuboid2D< T >

cuboid

)

Adds a cuboid.

Definition at line 495 of file cuboidGeometry2D.hh.

{
 
  _cuboids.push_back(cuboid);
}

Here is the caller graph for this function:

get() [1/2]

template<typename T >

Cuboid2D< T > & olb::CuboidGeometry2D< T >::get

(

int

i

)

Read and write access to the cuboids.

Definition at line 89 of file cuboidGeometry2D.hh.

{
  return _cuboids[i];
}

Here is the caller graph for this function:

get() [2/2]

template<typename T >

Cuboid2D< T > const & olb::CuboidGeometry2D< T >::get

(

int

i

)

const

Read access to the cuboids.

Definition at line 95 of file cuboidGeometry2D.hh.

{
  return _cuboids[i];
}

get_iC() [1/2]

template<typename T >

int olb::CuboidGeometry2D< T >::get_iC	(	T	globX,
		T	globY,
		int	offset = 0 ) const

for a given point (globX/globY), returns the related cuboidID and _p if the point is not in any of the cuboid _childrenQ

Definition at line 468 of file cuboidGeometry2D.hh.

{
  unsigned i;
  for (i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].checkPoint(globX, globY, offset)) {
      return (int)i;
    }
  }
  return (int)i;
}

get_iC() [2/2]

template<typename T >

int olb::CuboidGeometry2D< T >::get_iC	(	T	globX,
		T	globY,
		int	orientationX,
		int	orientationY ) const

This function checks if the points (globX/globY) and (globX + orientationX/delta /globY + orientationY/delta) is in a cuboid.

It gives the related cuboidID and _p if the points are not in any of the cuboids. util::abs(orientationX) = util::abs(orientationY) = 1 must be satisfied

Definition at line 480 of file cuboidGeometry2D.hh.

{
  unsigned i;
  for (i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].checkPoint(globX, globY) &&
        _cuboids[i].checkPoint(globX + orientationX / _cuboids[i].getDeltaR(),
                               globY + orientationY / _cuboids[i].getDeltaR())) {
      return (int)i;
    }
  }
  return (int)i;
}

getC() [1/2]

template<typename T >

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

Returns true and the cuboid number of the nearest lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.

Definition at line 123 of file cuboidGeometry2D.hh.

{
  int iCtmp = get_iC(physR[0], physR[1]);
  if (iCtmp < getNc()) {
    iC = iCtmp;
    return true;
  }
  else {
    return false;
  }
}

getC() [2/2]

template<typename T >

bool olb::CuboidGeometry2D< T >::getC	(	std::vector< T >	physR,
		int &	iC ) const

Returns true and the cuboid number of the nearest lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.

Definition at line 110 of file cuboidGeometry2D.hh.

{
  int iCtmp = get_iC(physR[0], physR[1]);
  if (iCtmp < getNc()) {
    iC = iCtmp;
    return true;
  }
  else {
    return false;
  }
}

Here is the caller graph for this function:

getFloorLatticeR() [1/2]

template<typename T >

bool olb::CuboidGeometry2D< T >::getFloorLatticeR	(	const Vector< T, 2 > &	physR,
		Vector< int, 3 > &	latticeR ) const

Returns true and the util::floor lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.

Definition at line 197 of file cuboidGeometry2D.hh.

{
  int iCtmp = get_iC(physR[0], physR[1]);
  if (iCtmp < getNc()) {
    latticeR[0] = iCtmp;
    latticeR[1] = (int)util::floor( (physR[0] - _cuboids[latticeR[0]].getOrigin()[0] ) / _cuboids[latticeR[0]].getDeltaR() );
    latticeR[2] = (int)util::floor( (physR[1] - _cuboids[latticeR[0]].getOrigin()[1] ) / _cuboids[latticeR[0]].getDeltaR() );
    return true;
  }
  else {
    return false;
  }
}

References olb::util::floor().

Here is the call graph for this function:

getFloorLatticeR() [2/2]

template<typename T >

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

Returns true and the util::floor lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.

Definition at line 182 of file cuboidGeometry2D.hh.

{
  int iCtmp = get_iC(physR[0], physR[1]);
  if (iCtmp < getNc()) {
    latticeR[0] = iCtmp;
    latticeR[1] = (int)util::floor( (physR[0] - _cuboids[latticeR[0]].getOrigin()[0] ) / _cuboids[latticeR[0]].getDeltaR() );
    latticeR[2] = (int)util::floor( (physR[1] - _cuboids[latticeR[0]].getOrigin()[1] ) / _cuboids[latticeR[0]].getDeltaR() );
    return true;
  }
  else {
    return false;
  }
}

References olb::util::floor().

Here is the call graph for this function:

getLatticeR() [1/3]

template<typename T >

bool olb::CuboidGeometry2D< T >::getLatticeR	(	const Vector< T, 2 > &	physR,
		Vector< int, 3 > &	latticeR ) const

Definition at line 166 of file cuboidGeometry2D.hh.

{
  int iCtmp = get_iC(physR[0], physR[1]);
  if (iCtmp < getNc()) {
    latticeR[0] = iCtmp;
    latticeR[1] = (int)util::floor( (physR[0] - _cuboids[latticeR[0]].getOrigin()[0] ) / _cuboids[latticeR[0]].getDeltaR() + .5);
    latticeR[2] = (int)util::floor( (physR[1] - _cuboids[latticeR[0]].getOrigin()[1] ) / _cuboids[latticeR[0]].getDeltaR() + .5);
    return true;
  }
  else {
    return false;
  }
}

References olb::util::floor().

Here is the call graph for this function:

getLatticeR() [2/3]

template<typename T >

bool olb::CuboidGeometry2D< T >::getLatticeR	(	int	latticeR[],
		const T	physR[] ) const

Definition at line 151 of file cuboidGeometry2D.hh.

{
  int iCtmp = get_iC(physR[0], physR[1]);
  if (iCtmp < getNc()) {
    latticeR[0] = iCtmp;
    latticeR[1] = (int)util::floor( (physR[0] - _cuboids[latticeR[0]].getOrigin()[0] ) / _cuboids[latticeR[0]].getDeltaR() + .5);
    latticeR[2] = (int)util::floor( (physR[1] - _cuboids[latticeR[0]].getOrigin()[1] ) / _cuboids[latticeR[0]].getDeltaR() + .5);
    return true;
  }
  else {
    return false;
  }
}

References olb::util::floor().

Here is the call graph for this function:

getLatticeR() [3/3]

template<typename T >

bool olb::CuboidGeometry2D< T >::getLatticeR	(	std::vector< T >	physR,
		std::vector< int > &	latticeR ) const

Returns true and the nearest lattice position to the given physical position if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.

Definition at line 136 of file cuboidGeometry2D.hh.

{
  return getLatticeR(&latticeR[0], &physR[0]);
  /*  int iCtmp = get_iC(physR[0], physR[1]);
    if (iCtmp < getNc()) {
      latticeR[0] = iCtmp;
      latticeR[1] = (int)util::floor( (physR[0] - _cuboids[latticeR[0]].getOrigin()[0] ) / _cuboids[latticeR[0]].getDeltaR() + .5);
      latticeR[2] = (int)util::floor( (physR[1] - _cuboids[latticeR[0]].getOrigin()[1] ) / _cuboids[latticeR[0]].getDeltaR() + .5);
      return true;
    } else {
      return false;
    }*/
}

getMaxDeltaR()

template<typename T >

T olb::CuboidGeometry2D< T >::getMaxDeltaR

(

)

const

Definition at line 410 of file cuboidGeometry2D.hh.

{
  T maxDelta = _cuboids[0].getDeltaR();
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getDeltaR() > maxDelta) {
      maxDelta = _cuboids[i].getDeltaR();
    }
  }
  return maxDelta;
}

getMaxLatticeVolume()

template<typename T >

size_t olb::CuboidGeometry2D< T >::getMaxLatticeVolume

(

)

const

Definition at line 386 of file cuboidGeometry2D.hh.

{
  size_t maxNodes = _cuboids[0].getLatticeVolume();
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getLatticeVolume() > maxNodes) {
      maxNodes = _cuboids[i].getLatticeVolume();
    }
  }
  return maxNodes;
}

getMaxPhysR()

template<typename T >

std::vector< T > olb::CuboidGeometry2D< T >::getMaxPhysR

(

)

const

Returns the maximum coordinate in the structure.

Definition at line 333 of file cuboidGeometry2D.hh.

{
  Vector<T,2> output(_cuboids[0].getOrigin());
  output[0] += _cuboids[0].getNx()*_cuboids[0].getDeltaR();
  output[1] += _cuboids[0].getNy()*_cuboids[0].getDeltaR();
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getOrigin()[0] + _cuboids[i].getNx()*_cuboids[i].getDeltaR() > output[0]) {
      output[0] = _cuboids[i].getOrigin()[0] + _cuboids[i].getNx()*_cuboids[i].getDeltaR();
    }
    if (_cuboids[i].getOrigin()[1] + _cuboids[i].getNy()*_cuboids[i].getDeltaR() > output[1]) {
      output[1] = _cuboids[i].getOrigin()[1] + _cuboids[i].getNy()*_cuboids[i].getDeltaR();
    }
  }
  return std::vector<T> {output[0],output[1]};
}

getMaxPhysVolume()

template<typename T >

T olb::CuboidGeometry2D< T >::getMaxPhysVolume

(

)

const

Definition at line 362 of file cuboidGeometry2D.hh.

{
  T maxVolume = _cuboids[0].getPhysVolume();
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getPhysVolume() > maxVolume) {
      maxVolume = _cuboids[i].getPhysVolume();
    }
  }
  return maxVolume;
}

getMaxRatio()

template<typename T >

T olb::CuboidGeometry2D< T >::getMaxRatio

(

)

const

Definition at line 306 of file cuboidGeometry2D.hh.

{
  T maxRatio = 1.;
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if ((T)_cuboids[i].getNx() / (T)_cuboids[i].getNy() > maxRatio) {
      maxRatio = (T)_cuboids[i].getNx() / (T)_cuboids[i].getNy();
    }
  }
  return maxRatio;
}

getMinDeltaR()

template<typename T >

T olb::CuboidGeometry2D< T >::getMinDeltaR

(

)

const

Returns the maximum/minimum delata in the structure.

Definition at line 398 of file cuboidGeometry2D.hh.

{
  T minDelta = _cuboids[0].getDeltaR();
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getDeltaR() < minDelta) {
      minDelta = _cuboids[i].getDeltaR();
    }
  }
  return minDelta;
}

Here is the caller graph for this function:

getMinLatticeVolume()

template<typename T >

size_t olb::CuboidGeometry2D< T >::getMinLatticeVolume

(

)

const

Returns the maximum/minimum number of nodes in the structure.

Definition at line 374 of file cuboidGeometry2D.hh.

{
  size_t minNodes = _cuboids[0].getLatticeVolume();
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getLatticeVolume() < minNodes) {
      minNodes = _cuboids[i].getLatticeVolume();
    }
  }
  return minNodes;
}

getMinPhysR()

template<typename T >

std::vector< T > olb::CuboidGeometry2D< T >::getMinPhysR

(

)

const

Returns the minimum coordinate in the structure.

Definition at line 318 of file cuboidGeometry2D.hh.

{
  Vector<T,2> output(_cuboids[0].getOrigin());
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getOrigin()[0] < output[0]) {
      output[0] = _cuboids[i].getOrigin()[0];
    }
    if (_cuboids[i].getOrigin()[1] < output[1]) {
      output[1] = _cuboids[i].getOrigin()[1];
    }
  }
  return std::vector<T> {output[0],output[1]};
}

getMinPhysVolume()

template<typename T >

T olb::CuboidGeometry2D< T >::getMinPhysVolume

(

)

const

Returns the maximum/minimum volume in the structure.

Definition at line 350 of file cuboidGeometry2D.hh.

{
  T minVolume = _cuboids[0].getPhysVolume();
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].getPhysVolume() < minVolume) {
      minVolume = _cuboids[i].getPhysVolume();
    }
  }
  return minVolume;
}

getMinRatio()

template<typename T >

T olb::CuboidGeometry2D< T >::getMinRatio

(

)

const

Returns the maximum/minimum of the ratio nX/NY in the structure.

Definition at line 294 of file cuboidGeometry2D.hh.

{
  T minRatio = 1.;
  for ( auto& cuboid : _cuboids ) {
    if ((T)cuboid.getNx() / (T)cuboid.getNy() < minRatio) {
      minRatio = (T)cuboid.getNx() / (T)cuboid.getNy();
    }
  }
  return minRatio;
}

getMotherCuboid()

template<typename T >

Cuboid2D< T > olb::CuboidGeometry2D< T >::getMotherCuboid

(

)

const

Returns the smallest cuboid that includes all cuboids of the structure.

Definition at line 422 of file cuboidGeometry2D.hh.

{
 
  /*Cuboid2D<T> found;
  if(_cuboids.size()==0) {
      found.init(0, 0, 0, 0, 0);
      return found;
  }
 
  T delta = _cuboids[0].getDeltaR();
  T globPosXmin = _cuboids[0].get_globPosX();
  T globPosYmin = _cuboids[0].get_globPosY();
  T globPosXmax = _cuboids[0].get_globPosX() + delta*(_cuboids[0].getNx()-1);
  T globPosYmax = _cuboids[0].get_globPosY() + delta*(_cuboids[0].getNy()-1);
 
  for (unsigned i=1; i<_cuboids.size(); i++) {
      if(delta > _cuboids[i].getDeltaR() ) {
          delta = _cuboids[i].getDeltaR();
      }
      if(globPosXmin > _cuboids[i].get_globPosX() ) {
          globPosXmin = _cuboids[i].get_globPosX();
      }
      if(globPosYmin > _cuboids[i].get_globPosY() ) {
          globPosYmin = _cuboids[i].get_globPosY();
      }
      if(globPosXmax < _cuboids[i].get_globPosX()
                          + delta*(_cuboids[i].getNx()-1)) {
          globPosXmax = _cuboids[i].get_globPosX()
                          + delta*(_cuboids[i].getNx()-1);
      }
      if(globPosYmax < _cuboids[i].get_globPosY()
                          + delta*(_cuboids[i].getNy()-1)) {
          globPosYmax = _cuboids[i].get_globPosY()
                          + delta*(_cuboids[i].getNy()-1);
      }
  }
  int nX = int(util::ceil((globPosXmax - globPosXmin)/delta))+1;
  int nY = int(util::ceil((globPosYmax - globPosYmin)/delta))+1;
 
  found.init(globPosXmin, globPosYmin, delta, nX, nY);
 
  return found;*/
  return _motherCuboid;
}

Here is the caller graph for this function:

getNc()

template<typename T >

int olb::CuboidGeometry2D< T >::getNc

(

)

const

Returns the number of cuboids in t < 2he structure.

Definition at line 288 of file cuboidGeometry2D.hh.

{
  return _cuboids.size();
}

Here is the caller graph for this function:

getNeighbourhood()

template<typename T >

void olb::CuboidGeometry2D< T >::getNeighbourhood	(	int	cuboid,
		std::vector< int > &	neighbours,
		int	offset = 0 )

stores the neighbouring cuboids in array neighbours;

Definition at line 597 of file cuboidGeometry2D.hh.

{
  for (int iC = 0; iC < getNc(); iC++) {
    if (cuboid == iC) {
      continue;
    }
    T globX = get(iC).get_globPosX();
    T globY = get(iC).get_globPosY();
    T nX = get(iC).getNx();
    T nY = get(iC).getNy();
    if (get(cuboid).checkInters(globX, globX + nX, globY, globY + nY, offset)) {
      neighbours.push_back(iC);
    }
  }
}

Here is the caller graph for this function:

getPhysR() [1/6]

template<typename T >

std::vector< T > olb::CuboidGeometry2D< T >::getPhysR	(	int	iCglob,
		int	iX,
		int	iY ) const

Returns the physical position to the given lattice position respecting periodicity for the overlap nodes which are not in the mother cuboid for the case the flag periodicityOn[iDim]=true if the physical position is within any of the cuboids with an overlap of 1/2*delta belonging to the cuboid geometry.

Definition at line 213 of file cuboidGeometry2D.hh.

{
  std::vector<T> physR(2,T());
  _cuboids[iCglob].getPhysR(&(physR[0]), iX, iY);
  for (int iDim = 0; iDim < 2; iDim++) {
    if (_periodicityOn[iDim]) {
      //std::cout << iDim << _periodicityOn[iDim] <<":"<< _motherCuboid.getDeltaR()*(_motherCuboid.getExtent()[iDim]) << std::endl;
      physR[iDim] = remainder( physR[iDim] - _motherCuboid.getOrigin()[iDim]
                               + _motherCuboid.getDeltaR() * (_motherCuboid.getExtent()[iDim]),
                               _motherCuboid.getDeltaR() * (_motherCuboid.getExtent()[iDim]));
      // solving the rounding error problem for double
      if ( physR[iDim]*physR[iDim] < 0.001 * _motherCuboid.getDeltaR()*_motherCuboid.getDeltaR() ) {
        physR[iDim] = T();
      }
      // make it to mod instead remainer
      if ( physR[iDim] < 0 ) {
        physR[iDim] += _motherCuboid.getDeltaR() * _motherCuboid.getExtent()[iDim];
      }
      // add origin
      physR[iDim] += _motherCuboid.getOrigin()[iDim];
    }
  }
  return physR;
}

Here is the caller graph for this function:

getPhysR() [2/6]

template<typename T >

std::vector< T > olb::CuboidGeometry2D< T >::getPhysR

(

std::vector< int >

latticeR

)

const

Returns the physical position to the given lattice position respecting periodicity for the overlap nodes which are not in the mother cuboid for the case the flag periodicityOn[iDim]=true.

Definition at line 239 of file cuboidGeometry2D.hh.

{
  return getPhysR(latticeR[0], latticeR[1], latticeR[2]);
}

getPhysR() [3/6]

template<typename T >

void olb::CuboidGeometry2D< T >::getPhysR	(	T	output[2],
		const int	iCglob,
		const int	iX,
		const int	iY ) const

Definition at line 264 of file cuboidGeometry2D.hh.

{
  _cuboids[iCglob].getPhysR(output, iX, iY);
  for (int iDim = 0; iDim < 2; iDim++) {
    if (_periodicityOn[iDim]) {
      //std::cout << iDim << _periodicityOn[iDim] <<":"<< _motherCuboid.getDeltaR()*(_motherCuboid.getExtent()[iDim]) << std::endl;
      output[iDim] = remainder( output[iDim] - _motherCuboid.getOrigin()[iDim]
                                + _motherCuboid.getDeltaR() * (_motherCuboid.getExtent()[iDim]),
                                _motherCuboid.getDeltaR() * (_motherCuboid.getExtent()[iDim]));
      // solving the rounding error problem for double
      if ( output[iDim]*output[iDim] < 0.001 * _motherCuboid.getDeltaR()*_motherCuboid.getDeltaR() ) {
        output[iDim] = T();
      }
      // make it to mod instead remainer
      if ( output[iDim] < 0 ) {
        output[iDim] += _motherCuboid.getDeltaR() * _motherCuboid.getExtent()[iDim];
      }
      // add origin
      output[iDim] += _motherCuboid.getOrigin()[iDim];
    }
  }
}

getPhysR() [4/6]

template<typename T >

void olb::CuboidGeometry2D< T >::getPhysR	(	T	output[2],
		const int	iCglob,
		LatticeR< 2 >	latticeR ) const

Definition at line 257 of file cuboidGeometry2D.hh.

{
  getPhysR(output, iCglob, latticeR[0], latticeR[1]);
}

getPhysR() [5/6]

template<typename T >

void olb::CuboidGeometry2D< T >::getPhysR	(	T	output[2],
		const int	latticeR[3] ) const

Definition at line 245 of file cuboidGeometry2D.hh.

{
  getPhysR(output, latticeR[0], latticeR[1], latticeR[2]);
}

getPhysR() [6/6]

template<typename T >

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

print()

template<typename T >

void olb::CuboidGeometry2D< T >::print

(

)

const

Prints cuboid geometry details.

Definition at line 614 of file cuboidGeometry2D.hh.

{
  clout << "---Cuboid Stucture Statistics---" << std::endl;
  clout << " Number of Cuboids: " << "\t" << getNc() << std::endl;
  clout << " Delta (min): " << "\t" << "\t" << getMinDeltaR() << std::endl;
  clout << "       (max): " << "\t" << "\t" << getMaxDeltaR() << std::endl;
  clout << " Ratio (min): " << "\t" << "\t" << getMinRatio() << std::endl;
  clout << "       (max): " << "\t" << "\t" << getMaxRatio() << std::endl;
  clout << " Nodes (min): " << "\t" << "\t" << getMinLatticeVolume() << std::endl;
  clout << "       (max): " << "\t" << "\t" << getMaxLatticeVolume() << std::endl;
  clout << "--------------------------------" << std::endl;
}

printExtended()

template<typename T >

void olb::CuboidGeometry2D< T >::printExtended

(

)

Prints cuboid geometry details plus details of all cuboids.

Definition at line 628 of file cuboidGeometry2D.hh.

{
  clout << "Mothercuboid :" << std::endl;
  getMotherCuboid().print();
 
  for (int iC = 0; iC < getNc(); iC++) {
    clout << "Cuboid #" << iC << ": " << std::endl;
    get(iC).print();
  }
}

reInit()

template<typename T >

void olb::CuboidGeometry2D< T >::reInit	(	T	globPosX,
		T	globPosY,
		T	delta,
		int	nX,
		int	nY,
		int	nC = 1 )

Re init.

Definition at line 75 of file cuboidGeometry2D.hh.

{
  _cuboids.clear();
  _motherCuboid = Cuboid2D<T>(globPosX, globPosY, delta, nX, nY);
  Cuboid2D<T> cuboid(globPosX, globPosY, delta, nX, nY);
  if (_oldApproach) {
    cuboid.init(0, 0, 1, nX, nY);
  }
 
  add(cuboid);
  split(0, nC);
}

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

Here is the call graph for this function:

remove()

template<typename T >

void olb::CuboidGeometry2D< T >::remove

(

int

iC

)

Removes the cuboid iC.

Definition at line 502 of file cuboidGeometry2D.hh.

{
 
  _cuboids.erase(_cuboids.begin() + iC);
}

setPeriodicity()

template<typename T >

void olb::CuboidGeometry2D< T >::setPeriodicity	(	bool	periodicityX,
		bool	periodicityY )

Set flag to enable/disable periodicity.

Definition at line 101 of file cuboidGeometry2D.hh.

{
  _periodicityOn.resize(2);
  _periodicityOn[0] = periodicityX;
  _periodicityOn[1] = periodicityY;
}

References olb::Cuboid2D< T >::resize().

Here is the call graph for this function:

shrink()

template<typename T >

void olb::CuboidGeometry2D< T >::shrink

(

IndicatorF2D< T > &

indicatorF

)

Shrink all cuboids so that no empty planes are left.

Definition at line 539 of file cuboidGeometry2D.hh.

{
  //IndicatorIdentity3D<T> tmpIndicatorF(indicatorF);
  int newX, newY, maxX, maxY;
  int nC = getNc();
  std::vector<int> latticeR(3, 0);
  std::vector<T> physR(2, T());
  bool inside[1];
  for (int iC = nC - 1; iC >= 0; iC--) {
    latticeR[0] = iC;
    int fullCells = 0;
    int xN = get(iC).getNx();
    int yN = get(iC).getNy();
    maxX = 0;
    maxY = 0;
    newX = xN - 1;
    newY = yN - 1;
    for (int iX = 0; iX < xN; iX++) {
      for (int iY = 0; iY < yN; iY++) {
        latticeR[1] = iX;
        latticeR[2] = iY;
        physR = getPhysR(latticeR);
        indicatorF(inside,&physR[0]);
        if (inside[0]) {
          fullCells++;
          maxX = util::max(maxX, iX);
          maxY = util::max(maxY, iY);
          newX = util::min(newX, iX);
          newY = util::min(newY, iY);
        }
      }
    }
    if (fullCells > 0) {
      get(iC).setWeight(fullCells);
      _cuboids[iC].resize(newX, newY, maxX - newX + 1, maxY - newY + 1);
    }
    else {
      remove(iC);
    }
  }
  // shrink mother cuboid
  std::vector<T> minPhysR = getMinPhysR();
  std::vector<T> maxPhysR = getMaxPhysR();
  T minDelataR = getMinDeltaR();
  _motherCuboid = Cuboid2D<T>(minPhysR[0], minPhysR[1], minDelataR, (int)((maxPhysR[0]-minPhysR[0])/minDelataR + 0.5), (int)((maxPhysR[1]-minPhysR[1])/minDelataR + 0.5));
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

split()

template<typename T >

void olb::CuboidGeometry2D< T >::split	(	int	iC,
		int	p )

Removes all cuboids where geometryData = 0.

Splits cuboid iC, removes it and add p cuboids

Definition at line 587 of file cuboidGeometry2D.hh.

{
 
  Cuboid2D<T> temp(_cuboids[iC].get_globPosX(), _cuboids[iC].get_globPosY(),
                   _cuboids[iC].getDeltaR(), _cuboids[iC].getNx(), _cuboids[iC].getNy());
  temp.divide(p, _cuboids);
  remove(iC);
}

References olb::Cuboid2D< T >::divide().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• src/communication/blockLoadBalancer.h
• src/geometry/cuboidGeometry2D.h
• src/geometry/cuboidGeometry2D.hh