olb::Cuboid2D< T > Class Template Reference

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

#include <cuboid2D.h>

Collaboration diagram for olb::Cuboid2D< T >:

Public Member Functions
	Cuboid2D (T globPosX, T globPosY, T delta, int nX, int nY)
	Construction of a cuboid.
	Cuboid2D (Vector< T, 2 > origin, T delta, Vector< int, 2 > extend)
	Construction of a cuboid vector version.
	Cuboid2D (Cuboid2D< T > const &rhs, int overlap=0)
	Copy constructor.
Cuboid2D &	operator= (Cuboid2D const &rhs)
	Copy assignment.
void	init (T globPosX, T globPosY, T delta, int nX, int nY)
	Initializes the cuboid.
T	get_globPosX () const
	Read access to left lower corner coordinates.
T	get_globPosY () const
Vector< T, 2 > const	getOrigin () const
	Read only access to left lower corner coordinates.
T	getDeltaR () const
	Read access to the distance of cuboid nodes.
int	getNx () const
	Read access to cuboid width.
int	getNy () const
	Read access to cuboid height.
Vector< int, 2 > const	getExtent () const
	Read only access to the number of voxels in every dimension.
T	getPhysVolume () const
	Returns the volume of the cuboid.
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	print () const
	Prints cuboid details.
void	getPhysR (T physR[2], const int latticeR[2]) const
void	getPhysR (T physR[2], const int &iX, const int &iY) const
void	getPhysR (T physR[3], LatticeR< 2 > latticeR) const
void	getLatticeR (int latticeR[2], const T physR[2]) const
void	getLatticeR (int latticeR[2], const Vector< T, 2 > &physR) const
void	getFloorLatticeR (const std::vector< T > &physR, std::vector< int > &latticeR) const
void	getFloorLatticeR (int latticeR[2], const T physR[2]) const
size_t	getWeight () const
	Returns the number of full cells.
void	setWeight (size_t fullCells)
	Sets the number of full cells.
bool	checkPoint (T globX, T globY, int overlap=0) const
	Checks whether a point (globX/globY) is contained in the cuboid extended with an layer of size overlap*delta.
bool	checkPoint (Vector< T, 2 > &globXY, int overlap=0) const
bool	checkPoint (T globX, T globY, int &locX, int &locY, int overlap=0) const
	Checks whether a point (globX/gloxY) 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, 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, 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, int &locX0, int &locX1, int &locY0, int &locY1, 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 of the cuboid extended with an layer of size overlap*delta.
void	divide (int p, int q, std::vector< Cuboid2D< T > > &childrenC) const
	Divides the cuboid in p*q cuboids and adds them to the given vector.
void	divide (int p, std::vector< Cuboid2D< T > > &childrenC) const
	Divides the cuboid in p cuboids and add them to the given vector.
void	resize (int X, int Y, int nX, int nY)
	resize the cuboid to the passed size

Detailed Description

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

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

A cuboid is given with its left lower corner, the number of nodes in the direction x and y and the distance between two nodes. Among other 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 54 of file cuboid2D.h.

Constructor & Destructor Documentation

Cuboid2D() [1/3]

template<typename T >

olb::Cuboid2D< T >::Cuboid2D	(	T	globPosX,
		T	globPosY,
		T	delta,
		int	nX,
		int	nY )

Construction of a cuboid.

Definition at line 45 of file cuboid2D.hh.

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

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

Here is the call graph for this function:

Cuboid2D() [2/3]

template<typename T >

olb::Cuboid2D< T >::Cuboid2D	(	Vector< T, 2 >	origin,
		T	delta,
		Vector< int, 2 >	extend )

Construction of a cuboid vector version.

Definition at line 52 of file cuboid2D.hh.

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

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

Here is the call graph for this function:

Cuboid2D() [3/3]

template<typename T >

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

Copy constructor.

Definition at line 60 of file cuboid2D.hh.

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

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

Here is the call graph for this function:

Member Function Documentation

checkInters() [1/3]

template<typename T >

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

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

Definition at line 256 of file cuboid2D.hh.

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

checkInters() [2/3]

template<typename T >

bool olb::Cuboid2D< T >::checkInters	(	T	globX0,
		T	globX1,
		T	globY0,
		T	globY1,
		int &	locX0,
		int &	locX1,
		int &	locY0,
		int &	locY1,
		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 of the cuboid extended with an layer of size overlap*delta.

Definition at line 262 of file cuboid2D.hh.

{
  if (overlap!=0) {
    Cuboid2D tmp(_globPosX - overlap*_delta, _globPosY - overlap*_delta, _delta, _nX + overlap*2, _nY + overlap*2);
    return tmp.checkInters(globX0, globX1, globY0, globY1, locX0, locX1, locY0, locY1);
  }
  else if (!checkInters(globX0, globX1, globY0, globY1)) {
    locX0 = 1;
    locX1 = 0;
    locY0 = 1;
    locY1 = 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;
    }
    return true;
  }
}

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

Here is the call graph for this function:

checkInters() [3/3]

template<typename T >

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

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

Definition at line 241 of file cuboid2D.hh.

{
 
  T locX0d = util::max(_globPosX-overlap*_delta,globX0);
  T locY0d = util::max(_globPosY-overlap*_delta,globY0);
  T locX1d = util::min(_globPosX+(_nX+overlap-1)*_delta,globX1);
  T locY1d = util::min(_globPosY+(_nY+overlap-1)*_delta,globY1);
 
  if (!(locX1d>=locX0d && locY1d>=locY0d)) {
    return false;
  }
  return true;
}

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::Cuboid2D< T >::checkPoint	(	T	globX,
		T	globY,
		int &	locX,
		int &	locY,
		int	overlap = 0 ) const

Checks whether a point (globX/gloxY) 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 224 of file cuboid2D.hh.

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

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

Here is the call graph for this function:

checkPoint() [2/3]

template<typename T >

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

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

Definition at line 203 of file cuboid2D.hh.

{
 
  if (_globPosX <= globX + T(0.5 + overlap)*_delta &&
      _globPosX + T(_nX+overlap)*_delta  > globX + 0.5*_delta &&
      _globPosY <= globY + T(0.5 + overlap)*_delta &&
      _globPosY + T(_nY+overlap)*_delta  > globY + 0.5*_delta ) {
    return true;
  }
  else {
    return false;
  }
}

Here is the caller graph for this function:

checkPoint() [3/3]

template<typename T >

bool olb::Cuboid2D< T >::checkPoint	(	Vector< T, 2 > &	globXY,
		int	overlap = 0 ) const

Definition at line 218 of file cuboid2D.hh.

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

divide() [1/2]

template<typename T >

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

Divides the cuboid in p*q cuboids and adds them to the given vector.

Definition at line 298 of file cuboid2D.hh.

{
  T globPosX_child, globPosY_child;
  int xN_child = 0;
  int yN_child = 0;
 
  globPosX_child = _globPosX;
  globPosY_child = _globPosY;
 
  for (int iX=0; iX<nX; iX++) {
    for (int iY=0; iY<nY; iY++) {
      xN_child       = (_nX+nX-iX-1)/nX;
      yN_child       = (_nY+nY-iY-1)/nY;
      Cuboid2D<T> child(globPosX_child, globPosY_child, _delta, xN_child, yN_child);
      childrenC.push_back(child);
      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::Cuboid2D< T >::divide	(	int	p,
		std::vector< Cuboid2D< T > > &	childrenC ) const

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

Definition at line 321 of file cuboid2D.hh.

{
 
  OLB_PRECONDITION(p>0);
  int nX = 0;
  int nY = 0;
  T ratio;
  T bestRatio = (T)_nX/(T)_nY;
  T difRatio = util::fabs(bestRatio - 1) + 1;
  for (int i=1; i<= p; i++) {
    int j = p / i;
    if (i*j<=p) {
      if ( util::fabs(bestRatio - (T)i/(T)j) <= difRatio) {
        difRatio = util::fabs(bestRatio - (T)i/(T)j);
        nX = i;
        nY = j;
      }
    }
  }
 
  ratio = T(nX)/(T)nY;
  int rest = p - nX*nY;
 
  if (rest==0) {
    divide(nX,nY,childrenC);
    return;
  }
 
  if (ratio < bestRatio && (nY-rest) >= 0) {
    int n_QNoInsertions = nX*(nY-rest);
    T bestVolume_QNoInsertions = (T)_nX*_nY * n_QNoInsertions/(T)p;
    int yN_QNoInsertions = (int)(bestVolume_QNoInsertions / (T)_nX);
    int xN_QNoInsertions = _nX;
    int yN_QInsertions = _nY-yN_QNoInsertions;
    int xN_QInsertions = _nX;
    Cuboid2D<T> firstChildQ(_globPosX, _globPosY, _delta, xN_QNoInsertions, yN_QNoInsertions);
    Cuboid2D<T> secondChildQ(_globPosX, _globPosY+yN_QNoInsertions*_delta, _delta, xN_QInsertions, yN_QInsertions);
    firstChildQ.divide(nX, nY-rest, childrenC);
    secondChildQ.divide(nX+1,rest, childrenC);
  }
  else {
    int n_QNoInsertions = nY*(nX-rest);
    T bestVolume_QNoInsertions = (T)_nX*_nY * n_QNoInsertions/(T)p;
    int xN_QNoInsertions = (int)(bestVolume_QNoInsertions / (T)_nY + 0.9999);
    int yN_QNoInsertions = _nY;
    int xN_QInsertions = _nX-xN_QNoInsertions;
    int yN_QInsertions = _nY;
    Cuboid2D<T> firstChildQ(_globPosX, _globPosY, _delta, xN_QNoInsertions, yN_QNoInsertions);
    Cuboid2D<T> secondChildQ(_globPosX+xN_QNoInsertions*_delta, _globPosY, _delta, xN_QInsertions, yN_QInsertions);
    firstChildQ.divide(nX-rest, nY, childrenC);
    secondChildQ.divide(rest,nY+1, childrenC);
  }
}

References olb::Cuboid2D< T >::divide(), olb::util::fabs(), and OLB_PRECONDITION.

Here is the call graph for this function:

get_globPosX()

template<typename T >

T olb::Cuboid2D< T >::get_globPosX

(

)

const

Read access to left lower corner coordinates.

Definition at line 88 of file cuboid2D.hh.

{
  return _globPosX;
}

get_globPosY()

template<typename T >

T olb::Cuboid2D< T >::get_globPosY

(

)

const

Definition at line 94 of file cuboid2D.hh.

{
  return _globPosY;
}

getDeltaR()

template<typename T >

T olb::Cuboid2D< T >::getDeltaR

(

)

const

Read access to the distance of cuboid nodes.

Definition at line 106 of file cuboid2D.hh.

{
  return _delta;
}

Here is the caller graph for this function:

getExtent()

template<typename T >

Vector< int, 2 > const olb::Cuboid2D< T >::getExtent

(

)

const

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

Definition at line 124 of file cuboid2D.hh.

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

Here is the caller graph for this function:

getFloorLatticeR() [1/2]

template<typename T >

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

inline

Definition at line 111 of file cuboid2D.h.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

getFloorLatticeR() [2/2]

template<typename T >

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

inline

Definition at line 116 of file cuboid2D.h.

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

References olb::util::floor().

Here is the call graph for this function:

getLatticePerimeter()

template<typename T >

int olb::Cuboid2D< T >::getLatticePerimeter

(

)

const

Returns the number of Nodes at the perimeter.

Definition at line 148 of file cuboid2D.hh.

{
  return 2*_nY + 2*_nX -4;
}

getLatticeR() [1/2]

template<typename T >

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

Definition at line 189 of file cuboid2D.hh.

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

References olb::util::floor().

Here is the call graph for this function:

getLatticeR() [2/2]

template<typename T >

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

Definition at line 196 of file cuboid2D.hh.

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

References olb::util::floor().

Here is the call graph for this function:

getLatticeVolume()

template<typename T >

size_t olb::Cuboid2D< T >::getLatticeVolume

(

)

const

Returns the number of Nodes in the volume.

Definition at line 136 of file cuboid2D.hh.

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

getNx()

template<typename T >

int olb::Cuboid2D< T >::getNx

(

)

const

Read access to cuboid width.

Definition at line 112 of file cuboid2D.hh.

{
  return _nX;
}

Here is the caller graph for this function:

getNy()

template<typename T >

int olb::Cuboid2D< T >::getNy

(

)

const

Read access to cuboid height.

Definition at line 118 of file cuboid2D.hh.

{
  return _nY;
}

Here is the caller graph for this function:

getOrigin()

template<typename T >

Vector< T, 2 > const olb::Cuboid2D< T >::getOrigin

(

)

const

Read only access to left lower corner coordinates.

Definition at line 100 of file cuboid2D.hh.

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

Here is the caller graph for this function:

getPhysPerimeter()

template<typename T >

T olb::Cuboid2D< T >::getPhysPerimeter

(

)

const

Returns the perimeter of the cuboid.

Definition at line 142 of file cuboid2D.hh.

{
  return 2*_nY*_delta + 2*_nX*_delta;
}

getPhysR() [1/3]

template<typename T >

void olb::Cuboid2D< T >::getPhysR	(	T	physR[2],
		const int &	iX,
		const int &	iY ) const

Definition at line 175 of file cuboid2D.hh.

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

getPhysR() [2/3]

template<typename T >

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

Definition at line 168 of file cuboid2D.hh.

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

getPhysR() [3/3]

template<typename T >

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

getPhysVolume()

template<typename T >

T olb::Cuboid2D< T >::getPhysVolume

(

)

const

Returns the volume of the cuboid.

Definition at line 130 of file cuboid2D.hh.

{
  return _nY*_nX*_delta*_delta;
}

getWeight()

template<typename T >

size_t olb::Cuboid2D< T >::getWeight

(

)

const

Returns the number of full cells.

Definition at line 386 of file cuboid2D.hh.

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

init()

template<typename T >

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

Initializes the cuboid.

Definition at line 77 of file cuboid2D.hh.

{
  _globPosX = globPosX;
  _globPosY = globPosY;
  _delta    = delta;
  _nX       = nX;
  _nY       = nY;
}

Here is the caller graph for this function:

operator=()

template<typename T >

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

(

Cuboid2D< T > const &

rhs

)

Copy assignment.

Definition at line 69 of file cuboid2D.hh.

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

print()

template<typename T >

void olb::Cuboid2D< T >::print

(

)

const

Prints cuboid details.

Definition at line 154 of file cuboid2D.hh.

{
  clout << "--------Cuboid Details----------" << std::endl;
  clout << " Left Corner (x/y): " << "\t" << "(" << this->get_globPosX() << "/" << this->get_globPosY() << ")" << std::endl;
  clout << " Delta: " << "\t" << "\t" << this->getDeltaR() << std::endl;
  clout << " Perimeter: " << "\t" << "\t" << this->getPhysPerimeter() << std::endl;
  clout << " Volume: " << "\t" << "\t" << this->getPhysVolume() << std::endl;
  clout << " Extent (x/y): " << "\t" << "\t" << "(" << this->getNx() << "/" << this->getNy() << ")" << std::endl;
  clout << " Nodes at Perimeter: " << "\t" << this->getLatticePerimeter() << std::endl;
  clout << " Nodes in Volume: " << "\t" << this->getLatticeVolume() << std::endl;
  clout << "--------------------------------" << std::endl;
}

resize()

template<typename T >

void olb::Cuboid2D< T >::resize	(	int	X,
		int	Y,
		int	nX,
		int	nY )

resize the cuboid to the passed size

Definition at line 377 of file cuboid2D.hh.

{
  _globPosX = _globPosX+iX*_delta;
  _globPosY = _globPosY+iY*_delta;
  _nX = nX;
  _nY = nY;
}

Here is the caller graph for this function:

setWeight()

template<typename T >

void olb::Cuboid2D< T >::setWeight

(

size_t

fullCells

)

Sets the number of full cells.

Definition at line 397 of file cuboid2D.hh.

{
  _weight = fullCells;
}

---

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

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