olb::Cuboid< T, D > Class Template Reference

#include <cuboid.h>

Inheritance diagram for olb::Cuboid< T, D >:

Collaboration diagram for olb::Cuboid< T, D >:

Public Member Functions
	Cuboid ()=default
	Cuboid (Vector< T, D > origin, T delta, Vector< int, D > extent)
	Cuboid (const Cuboid &rhs)
	Cuboid (IndicatorF< T, D > &indicatorF, T delta)
Cuboid &	operator= (const Cuboid &rhs)
bool	operator== (const Cuboid &rhs) const
Vector< T, D >	getOrigin () const
	Returns lower left corner coordinates.
T	getDeltaR () const
	Returns spacing of cuboid nodes.
Vector< int, D >	getExtent () const
	Returns extent in number of voxels.
int	getNx () const
int	getNy () const
int	getNz () const
T	getPhysVolume () const
	Returns the volume of the cuboid.
std::size_t	getWeight () const
void	setWeight (std::size_t weight)
Vector< T, D >	getPhysR (LatticeR< D > latticeR) const
LatticeR< D >	getLatticeR (Vector< T, D > physR) const
LatticeR< D >	getFloorLatticeR (Vector< T, D > physR) const
std::optional< LatticeR< D > >	getCloseLatticeR (Vector< T, D > physR, T eps=1e-5) const
	Returns closest latticeR within eps of physR if it exists.
std::size_t	getLatticeVolume () const
	Returns the number of Nodes in the volume.
T	getPhysPerimeter () const
	Returns the perimeter of the cuboid.
T	getPhysPerimeter () const
	Returns the perimeter of the cuboid.
std::size_t	getLatticePerimeter () const
	Returns the number of Nodes at the perimeter.
std::size_t	getLatticePerimeter () const
	Returns the number of Nodes at the perimeter.
bool	isInside (Vector< T, D > pos, int overlap=0) const
	Checks whether pos is contained in the cuboid extended with an layer of size overlap*delta.
bool	intersects (Vector< T, D > globMin, Vector< T, D > globMax, int overlap=0) const
	Checks whether there is an intersection with the cuboid extended by a layer of size overlap*delta.
bool	intersects (const Cuboid< T, D > &cuboid) const
	Returns true iff self intersects cuboid.
void	divide (Vector< int, D > division, std::vector< Cuboid< T, D > > &childrenC) const
	Divides the cuboid in p*q*r cuboids of equal volume and add them to the given vector.
void	divide (Vector< int, D > division, std::vector< Cuboid< T, D > > &childrenC) const
	Divides the cuboid in p*q cuboids of equal volume and add them to the given vector.
void	divideP (int p, std::vector< Cuboid< T, D > > &childrenC) const
	Divides the cuboid in p cuboids and add them to the given vector.
void	divideP (int p, std::vector< Cuboid< T, D > > &childrenC) const
	Divides the cuboid in p cuboids and add them to the given vector.
void	divideFractional (int iD, std::vector< T > fractions, std::vector< Cuboid< T, D > > &childrenC) const
	Divides the cuboid into fractions along the iDth dimension.
void	resize (Vector< int, D > offset, Vector< int, D > extent)
void	refine (int factor)
void	write (std::ostream &cout) const
void	print () const
void	writeAsXML (std::ostream &) const

Detailed Description

template<typename T, unsigned D>
class olb::Cuboid< T, D >

Definition at line 38 of file cuboid.h.

Constructor & Destructor Documentation

Cuboid() [1/4]

template<typename T , unsigned D>

olb::Cuboid< T, D >::Cuboid ( )

default

Cuboid() [2/4]

template<typename T , unsigned D>

olb::Cuboid< T, D >::Cuboid ( Vector< T, D > origin, T delta, Vector< int, D > extent )

inline

Definition at line 54 of file cuboid.h.

                                                           :
    _origin(origin),
    _extent(extent),
    _delta(delta),
    _weight(getLatticeVolume()) { }

Cuboid() [3/4]

template<typename T , unsigned D>

olb::Cuboid< T, D >::Cuboid ( const Cuboid< T, D > & rhs )

inline

Definition at line 59 of file cuboid.h.

                           :
    _origin(rhs._origin),
    _extent(rhs._extent),
    _delta(rhs._delta),
    _weight(rhs._weight) { }

Cuboid() [4/4]

template<typename T , unsigned D>

olb::Cuboid< T, D >::Cuboid ( IndicatorF< T, D > & indicatorF, T delta )

inline

Definition at line 64 of file cuboid.h.

                                              :
    _origin(indicatorF.getMin()),
    _extent((indicatorF.getMax() - indicatorF.getMin()) / delta + 1.5),
    _delta(delta),
    _weight(getLatticeVolume()) { }

Member Function Documentation

divide() [1/2]

template<typename T , unsigned D>
requires (D == 3)

void olb::Cuboid< T, D >::divide	(	Vector< int, D >	division,
		std::vector< Cuboid< T, D > > &	childrenC ) const

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

Definition at line 161 of file cuboid.hh.

{
  T globPosX_child, globPosY_child;
  int xN_child = 0;
  int yN_child = 0;
 
  globPosX_child = _origin[0];
  globPosY_child = _origin[1];
 
  for (int iX=0; iX < division[0]; iX++) {
    for (int iY=0; iY < division[1]; iY++) {
      xN_child       = (_extent[0]+division[0]-iX-1)/division[0];
      yN_child       = (_extent[1]+division[1]-iY-1)/division[1];
      Cuboid2D<T> child({globPosX_child, globPosY_child}, _delta, {xN_child, yN_child});
      childrenC.push_back(child);
      globPosY_child += yN_child*_delta;
    }
    globPosY_child = _origin[1];
    globPosX_child += xN_child*_delta;
  }
}

Here is the caller graph for this function:

divide() [2/2]

template<typename T , unsigned D>

void olb::Cuboid< T, D >::divide	(	Vector< int, D >	division,
		std::vector< Cuboid< T, D > > &	childrenC ) const

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

divideFractional()

template<typename T , unsigned D>

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

Divides the cuboid into fractions along the iDth dimension.

Definition at line 546 of file cuboid.hh.

{
  auto delta = Vector<T,D>([&](int i) -> T {
    return i == iD ? _delta : 0;
  });
  auto base = Vector<int,D>([&](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,D>([&](int i) -> T {
    return i == iD ? 0 : getExtent()[i];
  });
 
  for (int width : fractionWidths) {
    Cuboid<T,D> child(origin, _delta, extent + (width)*base);
    child.print();
    origin += width*delta;
    childrenC.push_back(child);
  }
}

References olb::Cuboid< T, D >::print().

Here is the call graph for this function:

Here is the caller graph for this function:

divideP() [1/2]

template<typename T , unsigned D>
requires (D == 2)

void olb::Cuboid< T, D >::divideP	(	int	p,
		std::vector< Cuboid< T, D > > &	childrenC ) const

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

Definition at line 214 of file cuboid.hh.

{
  int nX = 0;
  int nY = 0;
  T ratio;
  T bestRatio = (T)_extent[0]/(T)_extent[1];
  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)_extent[0]*_extent[1] * n_QNoInsertions/(T)p;
    int yN_QNoInsertions = (int)(bestVolume_QNoInsertions / (T)_extent[0]);
    int xN_QNoInsertions = _extent[0];
    int yN_QInsertions = _extent[1]-yN_QNoInsertions;
    int xN_QInsertions = _extent[0];
    Cuboid2D<T> firstChildQ({_origin[0], _origin[1]}, _delta, {xN_QNoInsertions, yN_QNoInsertions});
    Cuboid2D<T> secondChildQ({_origin[0], _origin[1]+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)_extent[0]*_extent[1] * n_QNoInsertions/(T)p;
    int xN_QNoInsertions = (int)(bestVolume_QNoInsertions / (T)_extent[1] + 0.9999);
    int yN_QNoInsertions = _extent[1];
    int xN_QInsertions = _extent[0]-xN_QNoInsertions;
    int yN_QInsertions = _extent[1];
    Cuboid2D<T> firstChildQ({_origin[0], _origin[1]}, _delta, {xN_QNoInsertions, yN_QNoInsertions});
    Cuboid2D<T> secondChildQ({_origin[0]+xN_QNoInsertions*_delta, _origin[1]}, _delta, {xN_QInsertions, yN_QInsertions});
    firstChildQ.divide({nX-rest, nY}, childrenC);
    secondChildQ.divide({rest,nY+1}, childrenC);
  }
}

References olb::Cuboid< T, D >::divide(), and olb::util::fabs().

Here is the call graph for this function:

Here is the caller graph for this function:

divideP() [2/2]

template<typename T , unsigned D>

void olb::Cuboid< T, D >::divideP	(	int	p,
		std::vector< Cuboid< T, D > > &	childrenC ) const

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

getCloseLatticeR()

template<typename T , unsigned D>

std::optional< LatticeR< D > > olb::Cuboid< T, D >::getCloseLatticeR	(	Vector< T, D >	physR,
		T	eps = 1e-5 ) const

Returns closest latticeR within eps of physR if it exists.

Definition at line 42 of file cuboid.hh.

                                                                                     {
  auto globR = _origin;
  auto physLatticeR = (physR - globR) / _delta;
  if (util::abs(util::round(physLatticeR) - physLatticeR) <= eps) {
    return LatticeR<D>(util::round(physLatticeR));
  } else {
    return std::nullopt;
  }
}

References olb::util::abs(), and olb::util::round().

Here is the call graph for this function:

getDeltaR()

template<typename T , unsigned D>

T olb::Cuboid< T, D >::getDeltaR ( ) const

inline

Returns spacing of cuboid nodes.

Definition at line 76 of file cuboid.h.

{ return _delta; }

Here is the caller graph for this function:

getExtent()

template<typename T , unsigned D>

Vector< int, D > olb::Cuboid< T, D >::getExtent ( ) const

inline

Returns extent in number of voxels.

Definition at line 78 of file cuboid.h.

{ return _extent; }

Here is the caller graph for this function:

getFloorLatticeR()

template<typename T , unsigned D>

LatticeR< D > olb::Cuboid< T, D >::getFloorLatticeR ( Vector< T, D > physR ) const

inline

Definition at line 98 of file cuboid.h.

                                                        {
    return util::floor((physR - _origin) / _delta);
  }

References olb::util::floor().

Here is the call graph for this function:

getLatticePerimeter() [1/2]

template<typename T , unsigned D>
requires (D == 2)

std::size_t olb::Cuboid< T, D >::getLatticePerimeter

(

)

const

Returns the number of Nodes at the perimeter.

Definition at line 82 of file cuboid.hh.

                                                                   {
  return 2*_extent[1] + 2*_extent[0] - 4;
}

getLatticePerimeter() [2/2]

template<typename T , unsigned D>

std::size_t olb::Cuboid< T, D >::getLatticePerimeter

(

)

const

Returns the number of Nodes at the perimeter.

getLatticeR()

template<typename T , unsigned D>

LatticeR< D > olb::Cuboid< T, D >::getLatticeR ( Vector< T, D > physR ) const

inline

Definition at line 94 of file cuboid.h.

                                                   {
    return util::floor((physR - _origin) / _delta + 0.5);
  }

References olb::util::floor().

Here is the call graph for this function:

Here is the caller graph for this function:

getLatticeVolume()

template<typename T , unsigned D>

std::size_t olb::Cuboid< T, D >::getLatticeVolume

(

)

const

Returns the number of Nodes in the volume.

Definition at line 62 of file cuboid.hh.

                                              {
  std::size_t latticeVolume = _extent[0];
  for (unsigned iD=1; iD < D; ++iD) {
    latticeVolume *= _extent[iD];
  }
  return latticeVolume;
}

Here is the caller graph for this function:

getNx()

template<typename T , unsigned D>

int olb::Cuboid< T, D >::getNx ( ) const

inline

Definition at line 80 of file cuboid.h.

{ return _extent[0]; }

Here is the caller graph for this function:

getNy()

template<typename T , unsigned D>

int olb::Cuboid< T, D >::getNy ( ) const

inline

Definition at line 81 of file cuboid.h.

{ return _extent[1]; }

Here is the caller graph for this function:

getNz()

template<typename T , unsigned D>

int olb::Cuboid< T, D >::getNz ( ) const

inline

Definition at line 82 of file cuboid.h.

{ return _extent[2]; }

Here is the caller graph for this function:

getOrigin()

template<typename T , unsigned D>

Vector< T, D > olb::Cuboid< T, D >::getOrigin ( ) const

inline

Returns lower left corner coordinates.

Definition at line 74 of file cuboid.h.

{ return _origin; }

Here is the caller graph for this function:

getPhysPerimeter() [1/2]

template<typename T , unsigned D>
requires (D == 2)

T olb::Cuboid< T, D >::getPhysPerimeter

(

)

const

Returns the perimeter of the cuboid.

Definition at line 71 of file cuboid.hh.

                                                        {
  return 2*_extent[1]*_delta + 2*_extent[0]*_delta;
}

getPhysPerimeter() [2/2]

template<typename T , unsigned D>

T olb::Cuboid< T, D >::getPhysPerimeter

(

)

const

Returns the perimeter of the cuboid.

getPhysR()

template<typename T , unsigned D>

Vector< T, D > olb::Cuboid< T, D >::getPhysR ( LatticeR< D > latticeR ) const

inline

Definition at line 90 of file cuboid.h.

                                                   {
    return _origin + latticeR*_delta;
  }

Here is the caller graph for this function:

getPhysVolume()

template<typename T , unsigned D>

T olb::Cuboid< T, D >::getPhysVolume

(

)

const

Returns the volume of the cuboid.

Definition at line 53 of file cuboid.hh.

                                   {
  T physVolume = util::pow(_delta,D);
  for (unsigned iD=0; iD < D; ++iD) {
    physVolume *= _extent[iD];
  }
  return physVolume;
}

References olb::util::pow().

Here is the call graph for this function:

getWeight()

template<typename T , unsigned D>

std::size_t olb::Cuboid< T, D >::getWeight ( ) const

inline

Definition at line 87 of file cuboid.h.

{ return _weight; }

intersects() [1/2]

template<typename T , unsigned D>

bool olb::Cuboid< T, D >::intersects

(

const Cuboid< T, D > &

cuboid

)

const

Returns true iff self intersects cuboid.

Definition at line 153 of file cuboid.hh.

{
  return intersects(cuboid.getOrigin(),
                    cuboid.getOrigin() + cuboid.getDeltaR()*(cuboid.getExtent()-1),
                    0);
}

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

Here is the call graph for this function:

intersects() [2/2]

template<typename T , unsigned D>

bool olb::Cuboid< T, D >::intersects	(	Vector< T, D >	globMin,
		Vector< T, D >	globMax,
		int	overlap = 0 ) const

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

Definition at line 144 of file cuboid.hh.

{
  auto loc0 = maxv(_origin-overlap*_delta, min);
  auto loc1 = minv(_origin+(_extent+overlap-1)*_delta, max);
  return loc1 >= loc0;
 
}

References olb::maxv(), and olb::minv().

Here is the call graph for this function:

Here is the caller graph for this function:

isInside()

template<typename T , unsigned D>

bool olb::Cuboid< T, D >::isInside	(	Vector< T, D >	pos,
		int	overlap = 0 ) const

Checks whether pos is contained in the cuboid extended with an layer of size overlap*delta.

Definition at line 137 of file cuboid.hh.

{
  return _origin <= pos + overlap*_delta + _delta / 2
      && _origin + (_extent+overlap) * _delta > pos + _delta / 2;
}

operator=()

template<typename T , unsigned D>

Cuboid< T, D > & olb::Cuboid< T, D >::operator=

(

const Cuboid< T, D > &

rhs

)

Definition at line 33 of file cuboid.hh.

                                                          {
  _origin = rhs._origin;
  _extent = rhs._extent;
  _delta = rhs._delta;
  _weight = rhs._weight;
  return *this;
}

operator==()

template<typename T , unsigned D>

bool olb::Cuboid< T, D >::operator==

(

const Cuboid< T, D > &

rhs

)

const

Definition at line 129 of file cuboid.hh.

{
  return    util::nearZero(_origin - rhs._origin)
         && _extent == rhs._extent
         && _weight == rhs._weight;
}

print()

template<typename T , unsigned D>

void olb::Cuboid< T, D >::print

(

)

const

Definition at line 122 of file cuboid.hh.

{
  OstreamManager clout(std::cout, "cuboid");
  write(clout);
}

Here is the caller graph for this function:

refine()

template<typename T , unsigned D>

void olb::Cuboid< T, D >::refine

(

int

factor

)

Definition at line 92 of file cuboid.hh.

                                   {
  if (factor < 1) {
    throw std::invalid_argument("refinement factor must be >= 1");
  } else if (factor == 2) {
    _delta /= factor;
    _extent *= factor;
    _extent -= 1;
    _weight *= util::pow(factor,D);
  } else if (factor != 1) {
    throw std::invalid_argument("TBD refinement factor must be == 2");
  }
}

References olb::util::pow().

Here is the call graph for this function:

resize()

template<typename T , unsigned D>

void olb::Cuboid< T, D >::resize	(	Vector< int, D >	offset,
		Vector< int, D >	extent )

Definition at line 540 of file cuboid.hh.

                                                                   {
  _origin += offset*_delta;
  _extent = extent;
}

setWeight()

template<typename T , unsigned D>

void olb::Cuboid< T, D >::setWeight ( std::size_t weight )

inline

Definition at line 88 of file cuboid.h.

{ _weight = weight; }

write()

template<typename T , unsigned D>

void olb::Cuboid< T, D >::write

(

std::ostream &

cout

)

const

Definition at line 106 of file cuboid.hh.

{
  cout << "--------Cuboid Details----------" << std::endl;
  cout << " Corner: " << "\t" << _origin << std::endl;
  cout << " Delta: " << "\t" << "\t" << getDeltaR() << std::endl;
  cout << " Perimeter: " << "\t" << "\t" << getPhysPerimeter() << std::endl;
  cout << " Volume: " << "\t" << "\t" << getPhysVolume() << std::endl;
  cout << " Extent: " << "\t" << _extent << std::endl;
  cout << " Nodes at Perimeter: " << "\t" << getLatticePerimeter() << std::endl;
  cout << " Nodes in Volume: " << "\t" << getLatticeVolume() << std::endl;
  cout << " Nodes in Indicator: " << "\t" << getWeight() << std::endl;
  cout << " Other Corner: "  << "\t"<< _origin + (_extent-0.5)*_delta << std::endl;
  cout << "--------------------------------" << std::endl;
}

writeAsXML()

template<typename T , unsigned D>

void olb::Cuboid< T, D >::writeAsXML

(

std::ostream &

ss

)

const

Definition at line 577 of file cuboid.hh.

                                                 {
  ss << " extent=\"";
  for (int i = 0; i<3; i++) {
    ss << getExtent()[i] << " ";
  }
 
  ss << "\" origin=\"";
  for (int i = 0; i<3; i++) {
    ss << getOrigin()[i] << " ";
  }
 
  ss << "\" deltaR=\"" << getDeltaR();
  ss << "\" weight=\"" << getWeight();
}

---

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

• src/geometry/cuboid.h
• src/geometry/cuboid.hh