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

Decomposition of a physical volume into a set of disjoint cuboids. More...

#include <cuboidDecomposition.h>

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

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

Public Member Functions
	CuboidDecomposition (Vector< T, D > origin, T deltaR, Vector< int, D > extent, int nC=1)
	Constructs cuboid decomposition of cuboid with origin and extent.
	CuboidDecomposition (const Cuboid< T, D > &motherCuboid, int nC)
	Construction from an given mother cuboid.
	CuboidDecomposition (IndicatorF< T, D > &indicatorF, T voxelSize, int nC=1)
	Constructs a cuboid decomposition with uniform spacing of voxelSize which consists of nC cuboids.
	CuboidDecomposition (IndicatorF< T, D > &indicatorF, T voxelSize, int nC, std::string minimizeBy)
	Constructs a cuboid decomposition with uniform spacing of voxelSize which consists of nC cuboids shrunken using the minimizeBy strategy.
int	size () const
	Returns number of cuboids in decomposition.
std::optional< int >	getC (Vector< T, D > physR, int padding=0) const
	Returns ID of cuboid containing physR within padding.
Vector< T, D >	getPhysR (LatticeR< D+1 > latticeR) const
	Returns physical position of lattice position.
std::optional< LatticeR< D+1 > >	getLatticeR (Vector< T, D > physR) const
	Returns lattice position for given physical position if it exists.
std::optional< LatticeR< D+1 > >	getFloorLatticeR (Vector< T, D > physR) const
	Returns floor lattice position for given physical position if it exists.
T	getDeltaR () const
	Returns spacing between lattice points in physical units.
bool	isInside (Vector< T, D > physR) const
	Returns true iff physR is covered by the decomposition.
const Cuboid< T, D > &	get (int iC) const
	Read access to a single cuboid.
Cuboid< T, D > &	get (int iC)
	Read and write access to a single cuboid.
const Cuboid< T, D > &	getMotherCuboid () const
	Returns the smallest cuboid that includes all cuboids of the structure.
Cuboid< T, D > &	getMotherCuboid ()
	Returns the smallest cuboid that includes all cuboids of the structure.
void	setPeriodicity (Vector< bool, D > periodicity)
	Set flag to enable/disable periodicity depending of direction. Be aware that not all directions are true to ensure boundary conditions like for velocity are not disturbed.
std::vector< Cuboid< T, D > > &	cuboids ()
std::set< int >	getNeighborhood (int iCglob, int overlap=0) const
	Returns set of neighbors to cuboid iCglob within overlap.
void	setWeights (IndicatorF< T, D > &indicatorF)
	Sets the number of full cells of each cuboid.
void	split (int iC, int p)
	Splits cuboid iC, removes it and adds p cuboids of same volume.
void	splitRegular (int iC, int width)
	Splits cuboid iC, removes it, adds approx. width^3 sized new cuboids.
void	splitByWeight (int iC, int p, IndicatorF< T, D > &indicatorF)
	Splits cuboid iC, removes it and adds p cuboids of same weight.
void	splitFractional (int iC, int iD, std::vector< T > fractions)
	Splits cuboid iC along dimension iD into cuboids of fractions.
void	remove (int iC)
	Removes the cuboid iC.
void	remove (IndicatorF< T, D > &indicatorF)
	Removes all cuboids where indicatorF = 0.
void	removeByWeight ()
	Removes all cuboids where weight = 0.
void	shrink (int iC, IndicatorF< T, D > &indicatorF)
	Shrink cuboid iC so that no empty planes are left.
void	shrink (IndicatorF< T, D > &indicatorF)
	Shrink all cuboids so that no empty planes are left.
void	refine (int factor)
	Refines mesh by splitting each cell into factor^3 cells.
bool	tryRefineTo (T deltaR)
	Tries to refine mesh to given deltaR.
void	print () const
	Prints cuboid geometry details.
void	printExtended ()
	Prints cuboid geometry details plus details of all cuboids.
void	writeToExistingFile (std::string completeFileName, LoadBalancer< T > &loadBalancer)
	Save CuboidDecomposition into an existing XML File.
void	writeToFile (std::string fileName, LoadBalancer< T > &loadBalancer)
	Save CuboidDecomposition into XML File.
T	getMinRatio () const
	Returns the minimum of the ratio nX/nY/nZ in the structure.
T	getMaxRatio () const
	Returns the maximum of the ratio nX/nY/nZ in the structure.
Vector< T, D >	getMinPhysR () const
	Returns the minimum coordinate in the structure.
Vector< T, D >	getMaxPhysR () const
	Returns the maximum coordinate in the structure.
T	getMinPhysVolume () const
	Returns the minimum volume in the structure.
T	getMaxPhysVolume () const
	Returns the maximum volume in the structure.
std::size_t	getMinLatticeVolume () const
	Returns the minimum number of nodes in the structure.
std::size_t	getMaxLatticeVolume () const
	Returns the maximum number of nodes in the structure.
std::size_t	getMinLatticeWeight () const
	Returns the minimum number of nodes in the structure inside the indicator.
std::size_t	getMaxLatticeWeight () const
	Returns the maximum number of nodes in the structure inside the indicator.
std::size_t	getNumNodes () const
	Returns the total number cells (without overlap)

Detailed Description

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

Decomposition of a physical volume into a set of disjoint cuboids.

The union of all cuboids is a superset of the decomposed volume. Cuboids are dimensioned s.t. they exactly represent a regular lattice with fixed spacing. Two cuboids are neighbors if the distance between them is less than the lattice spacing.

Definition at line 32 of file cuboidDecompositionMinimizer.h.

Constructor & Destructor Documentation

CuboidDecomposition() [1/4]

template<typename T , unsigned D>

olb::CuboidDecomposition< T, D >::CuboidDecomposition	(	Vector< T, D >	origin,
		T	deltaR,
		Vector< int, D >	extent,
		int	nC = 1 )

Constructs cuboid decomposition of cuboid with origin and extent.

Definition at line 43 of file cuboidDecomposition.hh.

  : _motherCuboid(origin, deltaR, extent)
  , _cuboids{_motherCuboid}
  , _periodicityOn{}
{
  split(0, nC);
}

References olb::CuboidDecomposition< T, D >::split().

Here is the call graph for this function:

CuboidDecomposition() [2/4]

template<typename T , unsigned D>

olb::CuboidDecomposition< T, D >::CuboidDecomposition	(	const Cuboid< T, D > &	motherCuboid,
		int	nC )

Construction from an given mother cuboid.

Definition at line 52 of file cuboidDecomposition.hh.

  : CuboidDecomposition(motherCuboid.getOrigin(), motherCuboid.getDeltaR(), motherCuboid.getExtent(), nC)
{ }

CuboidDecomposition() [3/4]

template<typename T , unsigned D>

olb::CuboidDecomposition< T, D >::CuboidDecomposition	(	IndicatorF< T, D > &	indicatorF,
		T	voxelSize,
		int	nC = 1 )

Constructs a cuboid decomposition with uniform spacing of voxelSize which consists of nC cuboids.

Definition at line 57 of file cuboidDecomposition.hh.

  : _motherCuboid(indicatorF.getMin(),
                  voxelSize,
                  (indicatorF.getMax() - indicatorF.getMin()) / voxelSize + 1.5)
  , _cuboids{_motherCuboid}
  , _periodicityOn{}
{
  _cuboids.reserve(nC+2);
  if (nC > 1) {
    split(0, nC);
  }
  shrink(indicatorF);
}

CuboidDecomposition() [4/4]

template<typename T , unsigned D>

olb::CuboidDecomposition< T, D >::CuboidDecomposition	(	IndicatorF< T, D > &	indicatorF,
		T	voxelSize,
		int	nC,
		std::string	minimizeBy )

Constructs a cuboid decomposition with uniform spacing of voxelSize which consists of nC cuboids shrunken using the minimizeBy strategy.

Definition at line 72 of file cuboidDecomposition.hh.

  : _motherCuboid(indicatorF.getMin(), voxelSize, (indicatorF.getMax() - indicatorF.getMin()) / voxelSize + 1.5)
  , _cuboids{_motherCuboid}
  , _periodicityOn{}
{
  if ( minimizeBy == "volume" ) {
    minimizeByVolume(*this, indicatorF, nC);
  }
  else if ( minimizeBy == "weight" ) {
    minimizeByWeight(*this, indicatorF, nC);
  }
}

Member Function Documentation

cuboids()

template<typename T , unsigned D>

std::vector< Cuboid< T, D > > & olb::CuboidDecomposition< T, D >::cuboids ( )

inline

Definition at line 106 of file cuboidDecomposition.h.

                                    {
    return _cuboids;
  }

Here is the caller graph for this function:

get() [1/2]

template<typename T , unsigned D>

Cuboid< T, D > & olb::CuboidDecomposition< T, D >::get

(

int

iC

)

Read and write access to a single cuboid.

Definition at line 141 of file cuboidDecomposition.hh.

{
  return _cuboids[iC];
}

get() [2/2]

template<typename T , unsigned D>

const Cuboid< T, D > & olb::CuboidDecomposition< T, D >::get

(

int

iC

)

const

Read access to a single cuboid.

Definition at line 135 of file cuboidDecomposition.hh.

{
  return _cuboids.at(iC);
}

Here is the caller graph for this function:

getC()

template<typename T , unsigned D>

std::optional< int > olb::CuboidDecomposition< T, D >::getC	(	Vector< T, D >	physR,
		int	padding = 0 ) const

Returns ID of cuboid containing physR within padding.

Definition at line 92 of file cuboidDecomposition.hh.

                                                                                    {
  for (int iC = 0; iC < size(); ++iC) {
    if (get(iC).isInside(physR, padding)) {
      return iC;
    }
  }
  return std::nullopt;
}

Here is the caller graph for this function:

getDeltaR()

template<typename T , unsigned D>

T olb::CuboidDecomposition< T, D >::getDeltaR

(

)

const

Returns spacing between lattice points in physical units.

Definition at line 120 of file cuboidDecomposition.hh.

                                            {
  return _motherCuboid.getDeltaR();
}

Here is the caller graph for this function:

getFloorLatticeR()

template<typename T , unsigned D>

std::optional< LatticeR< D+1 > > olb::CuboidDecomposition< T, D >::getFloorLatticeR

(

Vector< T, D >

physR

)

const

Returns floor lattice position for given physical position if it exists.

Definition at line 111 of file cuboidDecomposition.hh.

                                                                                             {
  if (auto iC = getC(physR, 0)) {
    const auto& c = get(*iC);
    return LatticeR<D>{util::floor((physR - c.getOrigin()) / c.getDeltaR())}.withPrefix(*iC);
  }
  return std::nullopt;
}

getLatticeR()

template<typename T , unsigned D>

std::optional< LatticeR< D+1 > > olb::CuboidDecomposition< T, D >::getLatticeR

(

Vector< T, D >

physR

)

const

Returns lattice position for given physical position if it exists.

Definition at line 102 of file cuboidDecomposition.hh.

                                                                                        {
  if (auto iC = getC(physR, 0)) {
    const auto& c = get(*iC);
    return LatticeR<D>{util::floor((physR - c.getOrigin()) / c.getDeltaR() + 0.5)}.withPrefix(*iC);
  }
  return std::nullopt;
}

Here is the caller graph for this function:

getMaxLatticeVolume()

template<typename T , unsigned D>

std::size_t olb::CuboidDecomposition< T, D >::getMaxLatticeVolume

(

)

const

Returns the maximum number of nodes in the structure.

Definition at line 509 of file cuboidDecomposition.hh.

{
  std::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;
}

getMaxLatticeWeight()

template<typename T , unsigned D>

std::size_t olb::CuboidDecomposition< T, D >::getMaxLatticeWeight

(

)

const

Returns the maximum number of nodes in the structure inside the indicator.

Definition at line 543 of file cuboidDecomposition.hh.

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

getMaxPhysR()

template<typename T , unsigned D>

Vector< T, D > olb::CuboidDecomposition< T, D >::getMaxPhysR

(

)

const

Returns the maximum coordinate in the structure.

Definition at line 456 of file cuboidDecomposition.hh.

{
  Vector<T,D> output(_cuboids[0].getOrigin());
  for (unsigned iD=0; iD < D; ++iD) {
    output[iD] += _cuboids[0].getExtent()[iD]*_cuboids[0].getDeltaR();
  }
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    for (unsigned iD=0; iD < D; ++iD) {
      if (_cuboids[i].getOrigin()[iD] + _cuboids[i].getExtent()[iD]*_cuboids[i].getDeltaR() > output[iD]) {
        output[iD] = _cuboids[i].getOrigin()[iD] + _cuboids[i].getExtent()[iD]*_cuboids[i].getDeltaR();
      }
    }
  }
  return output;
}

getMaxPhysVolume()

template<typename T , unsigned D>

T olb::CuboidDecomposition< T, D >::getMaxPhysVolume

(

)

const

Returns the maximum volume in the structure.

Definition at line 485 of file cuboidDecomposition.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 , unsigned D>

T olb::CuboidDecomposition< T, D >::getMaxRatio

(

)

const

Returns the maximum of the ratio nX/nY/nZ in the structure.

Definition at line 422 of file cuboidDecomposition.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();
    }
    if constexpr (D == 3) {
      if ((T)_cuboids[i].getNy() / (T)_cuboids[i].getNz() > maxRatio) {
        maxRatio = (T)_cuboids[i].getNy() / (T)_cuboids[i].getNz();
      }
      if ((T)_cuboids[i].getNz() / (T)_cuboids[i].getNx() > maxRatio) {
        maxRatio = (T)_cuboids[i].getNz() / (T)_cuboids[i].getNx();
      }
    }
  }
  return maxRatio;
}

getMinLatticeVolume()

template<typename T , unsigned D>

std::size_t olb::CuboidDecomposition< T, D >::getMinLatticeVolume

(

)

const

Returns the minimum number of nodes in the structure.

Definition at line 497 of file cuboidDecomposition.hh.

{
  std::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;
}

getMinLatticeWeight()

template<typename T , unsigned D>

std::size_t olb::CuboidDecomposition< T, D >::getMinLatticeWeight

(

)

const

Returns the minimum number of nodes in the structure inside the indicator.

Definition at line 531 of file cuboidDecomposition.hh.

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

getMinPhysR()

template<typename T , unsigned D>

Vector< T, D > olb::CuboidDecomposition< T, D >::getMinPhysR

(

)

const

Returns the minimum coordinate in the structure.

Definition at line 442 of file cuboidDecomposition.hh.

{
  Vector<T,D> output(_cuboids[0].getOrigin());
  for (int i = 0; i < size(); i++) {
    for (unsigned iD=0; iD < D; ++iD) {
      if (_cuboids[i].getOrigin()[iD] < output[iD]) {
        output[iD] = _cuboids[i].getOrigin()[iD];
      }
    }
  }
  return output;
}

getMinPhysVolume()

template<typename T , unsigned D>

T olb::CuboidDecomposition< T, D >::getMinPhysVolume

(

)

const

Returns the minimum volume in the structure.

Definition at line 473 of file cuboidDecomposition.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 , unsigned D>

T olb::CuboidDecomposition< T, D >::getMinRatio

(

)

const

Returns the minimum of the ratio nX/nY/nZ in the structure.

Definition at line 402 of file cuboidDecomposition.hh.

{
  T minRatio = 1.;
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if ((T)_cuboids[i].getNx() / (T)_cuboids[i].getNy() < minRatio) {
      minRatio = (T)_cuboids[i].getNx() / (T)_cuboids[i].getNy();
    }
    if constexpr (D == 3) {
      if ((T)_cuboids[i].getNy() / (T)_cuboids[i].getNz() < minRatio) {
        minRatio = (T)_cuboids[i].getNy() / (T)_cuboids[i].getNz();
      }
      if ((T)_cuboids[i].getNz() / (T)_cuboids[i].getNx() < minRatio) {
        minRatio = (T)_cuboids[i].getNz() / (T)_cuboids[i].getNx();
      }
    }
  }
  return minRatio;
}

getMotherCuboid() [1/2]

template<typename T , unsigned D>

Cuboid< T, D > & olb::CuboidDecomposition< T, D >::getMotherCuboid

(

)

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

Definition at line 153 of file cuboidDecomposition.hh.

{
  return _motherCuboid;
}

getMotherCuboid() [2/2]

template<typename T , unsigned D>

const Cuboid< T, D > & olb::CuboidDecomposition< T, D >::getMotherCuboid

(

)

const

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

Definition at line 147 of file cuboidDecomposition.hh.

{
  return _motherCuboid;
}

Here is the caller graph for this function:

getNeighborhood()

template<typename T , unsigned D>

std::set< int > olb::CuboidDecomposition< T, D >::getNeighborhood	(	int	iCglob,
		int	overlap = 0 ) const

Returns set of neighbors to cuboid iCglob within overlap.

Definition at line 188 of file cuboidDecomposition.hh.

{
  std::set<int> dummy;
  if constexpr (D == 3) {
    for (int iC = 0; iC < size(); iC++) {
      if (cuboid == iC) {
        continue;
      }
      T globX = get(iC).getOrigin()[0];
      T globY = get(iC).getOrigin()[1];
      T globZ = get(iC).getOrigin()[2];
      T nX = get(iC).getNx();
      T nY = get(iC).getNy();
      T nZ = get(iC).getNz();
      T deltaR = get(iC).getDeltaR();
      if (get(cuboid).intersects({globX - overlap * deltaR,
                                  globY - overlap * deltaR,
                                  globZ - overlap * deltaR},
                                 {globX + (nX + overlap - 1)*deltaR,
                                  globY + (nY + overlap - 1)*deltaR,
                                  globZ + (nZ + overlap - 1)*deltaR}, overlap)) {
        dummy.insert(iC);
      }
 
      if (_periodicityOn[0]) {
        if (get(cuboid).getOrigin()[0] + (get(cuboid).getNx() + overlap - 1)*get(cuboid).getDeltaR() > getMaxPhysR()[0]) {
          Cuboid<T,D> cub({get(cuboid).getOrigin()[0]-getMaxPhysR()[0],
                           get(cuboid).getOrigin()[1],
                           get(cuboid).getOrigin()[2]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy(),
                           get(cuboid).getNz()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR,
                               globZ - overlap * deltaR},
                              {globY + (nY + overlap - 1)*deltaR,
                               globX + (nX + overlap - 1)*deltaR,
                               globZ + (nZ + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
        if (get(cuboid).getOrigin()[0] - overlap*get(cuboid).getDeltaR() < getMinPhysR()[0]) {
          Cuboid<T,D> cub({get(cuboid).getOrigin()[0]+getMaxPhysR()[0],
                           get(cuboid).getOrigin()[1],
                           get(cuboid).getOrigin()[2]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy(),
                           get(cuboid).getNz()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR,
                               globZ - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR,
                               globZ + (nZ + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
      }
 
      if (_periodicityOn[1]) {
        if (get(cuboid).getOrigin()[1] + (get(cuboid).getNy() + overlap - 1)*get(cuboid).getDeltaR() > getMaxPhysR()[1]) {
          Cuboid<T,D> cub({get(cuboid).getOrigin()[0],
                           get(cuboid).getOrigin()[1]-getMaxPhysR()[1],
                           get(cuboid).getOrigin()[2]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy(),
                           get(cuboid).getNz()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR,
                               globZ - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR,
                               globZ + (nZ + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
        if (get(cuboid).getOrigin()[1] - overlap*get(cuboid).getDeltaR() < getMinPhysR()[1]) {
          Cuboid<T,D> cub({get(cuboid).getOrigin()[0],
                           get(cuboid).getOrigin()[1]+getMaxPhysR()[1],
                           get(cuboid).getOrigin()[2]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy(),
                           get(cuboid).getNz()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR,
                               globZ - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR,
                               globZ + (nZ + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
      }
 
      if (_periodicityOn[2]) {
        if (get(cuboid).getOrigin()[2] + (get(cuboid).getNz() + overlap - 1)*get(cuboid).getDeltaR() > getMaxPhysR()[2]) {
          Cuboid<T,D> cub({get(cuboid).getOrigin()[0],
                           get(cuboid).getOrigin()[1],
                           get(cuboid).getOrigin()[2]-getMaxPhysR()[2]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy(),
                           get(cuboid).getNz()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR,
                               globZ - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR,
                               globZ + (nZ + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
        if (get(cuboid).getOrigin()[2] - overlap*get(cuboid).getDeltaR() < getMinPhysR()[2]) {
          Cuboid<T,D> cub({get(cuboid).getOrigin()[0],
                           get(cuboid).getOrigin()[1],
                           get(cuboid).getOrigin()[2]+getMaxPhysR()[2]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy(),
                           get(cuboid).getNz()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR,
                               globZ - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR,
                               globZ + (nZ + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
      }
    }
  } else if constexpr (D == 2) {
    for (int iC = 0; iC < size(); iC++) {
      if (cuboid == iC) {
        continue;
      }
      T globX = get(iC).getOrigin()[0];
      T globY = get(iC).getOrigin()[1];
      T nX = get(iC).getNx();
      T nY = get(iC).getNy();
      T deltaR = get(iC).getDeltaR();
      if (get(cuboid).intersects({globX,
                                   globY - overlap * deltaR},
                                  {globX + (nX + overlap - 1)*deltaR,
                                   globY + (nY + overlap - 1)*deltaR}, overlap)) {
        dummy.insert(iC);
      }
      if (_periodicityOn[0]) {
        if (get(cuboid).getOrigin()[0] + (get(cuboid).getNx() + overlap - 1)*get(cuboid).getDeltaR() > getMaxPhysR()[0]) {
          Cuboid2D<T> cub({get(cuboid).getOrigin()[0]-getMaxPhysR()[0],
                           get(cuboid).getOrigin()[1]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
        if (get(cuboid).getOrigin()[0] - overlap*get(cuboid).getDeltaR() < getMinPhysR()[0]) {
          Cuboid2D<T> cub({get(cuboid).getOrigin()[0]+getMaxPhysR()[0],
                           get(cuboid).getOrigin()[1]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
      }
 
      if (_periodicityOn[1]) {
        if (get(cuboid).getOrigin()[1] + (get(cuboid).getNy() + overlap - 1)*get(cuboid).getDeltaR() > getMaxPhysR()[1]) {
          Cuboid2D<T> cub({get(cuboid).getOrigin()[0],
                           get(cuboid).getOrigin()[1]-getMaxPhysR()[1]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
        if (get(cuboid).getOrigin()[1] - overlap*get(cuboid).getDeltaR() < getMinPhysR()[1]) {
          Cuboid2D<T> cub({get(cuboid).getOrigin()[0],
                           get(cuboid).getOrigin()[1]+getMaxPhysR()[1]},
                           get(cuboid).getDeltaR(),
                          {get(cuboid).getNx(),
                           get(cuboid).getNy()});
          if (cub.intersects({globX - overlap * deltaR,
                               globY - overlap * deltaR},
                              {globX + (nX + overlap - 1)*deltaR,
                               globY + (nY + overlap - 1)*deltaR}, overlap)) {
            dummy.insert(iC);
          }
        }
      }
    }
  }
  return dummy;
}

Here is the caller graph for this function:

getNumNodes()

template<typename T , unsigned D>

std::size_t olb::CuboidDecomposition< T, D >::getNumNodes

(

)

const

Returns the total number cells (without overlap)

Definition at line 521 of file cuboidDecomposition.hh.

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

getPhysR()

template<typename T , unsigned D>

Vector< T, D > olb::CuboidDecomposition< T, D >::getPhysR

(

LatticeR< D+1 >

latticeR

)

const

Returns physical position of lattice position.

Definition at line 159 of file cuboidDecomposition.hh.

{
  auto physR = get(latticeR[0]).getPhysR(latticeR.withoutPrefix());
  for (unsigned iD=0; iD < D; ++iD) {
    if (_periodicityOn[iD]) {
      physR[iD] = remainder(physR[iD] - _motherCuboid.getOrigin()[iD]
                                      + _motherCuboid.getDeltaR() * (_motherCuboid.getExtent()[iD]),
                            _motherCuboid.getDeltaR() * (_motherCuboid.getExtent()[iD]));
      // solving the rounding error problem for double
      if (physR[iD]*physR[iD] < 0.001 * _motherCuboid.getDeltaR()*_motherCuboid.getDeltaR()) {
        physR[iD] = T{};
      }
      // make it to mod instead remainer
      if (physR[iD] < 0) {
        physR[iD] += _motherCuboid.getDeltaR() * (_motherCuboid.getExtent()[iD]);
      }
      physR[iD] += _motherCuboid.getOrigin()[iD];
    }
  }
  return physR;
}

Here is the caller graph for this function:

isInside()

template<typename T , unsigned D>

bool olb::CuboidDecomposition< T, D >::isInside

(

Vector< T, D >

physR

)

const

Returns true iff physR is covered by the decomposition.

Definition at line 125 of file cuboidDecomposition.hh.

                                                               {
  for (unsigned i = 0; i < _cuboids.size(); i++) {
    if (_cuboids[i].isInside(physR, 1)) {
      return true;
    }
  }
  return false;
}

Here is the caller graph for this function:

print()

template<typename T , unsigned D>

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

(

)

const

Prints cuboid geometry details.

Definition at line 977 of file cuboidDecomposition.hh.

{
  OstreamManager clout(std::cout, "CuboidDecomposition");
  clout << "---Cuboid Structure Statistics---" << std::endl;
  clout << " Number of Cuboids: " << "\t" << size() << std::endl;
  clout << " Delta       : " << "\t" << "\t" << getDeltaR() << 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 << " Weight (min): " << "\t" << "\t" << getMinLatticeWeight() << std::endl;
  clout << "        (max): " << "\t" << "\t" << getMaxLatticeWeight() << std::endl;
  clout << "--------------------------------" << std::endl;
}

printExtended()

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::printExtended

(

)

Prints cuboid geometry details plus details of all cuboids.

Definition at line 993 of file cuboidDecomposition.hh.

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

refine()

template<typename T , unsigned D>

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

(

int

factor

)

Refines mesh by splitting each cell into factor^3 cells.

Definition at line 710 of file cuboidDecomposition.hh.

{
  _motherCuboid.refine(factor);
  for (auto& cuboid : _cuboids) {
    cuboid.refine(factor);
  }
  // Fix neighbor relationships
  for (int iC=0; iC < size(); ++iC) {
    auto& iCuboid = get(iC);
    auto inconsistentNeighbors = getNeighborhood(iC, 2);
    for (int jC : inconsistentNeighbors) {
      auto& jCuboid = get(jC);
      for (unsigned iD=0; iD < D; ++iD) {
        auto extent = iCuboid.getExtent();
        if (iCuboid.getOrigin()[iD] + extent[iD]*iCuboid.getDeltaR() < jCuboid.getOrigin()[iD]) {
          extent[iD] += (jCuboid.getOrigin()[iD] - (iCuboid.getOrigin()[iD] + extent[iD]*iCuboid.getDeltaR())) / iCuboid.getDeltaR() > std::numeric_limits<T>::epsilon();
          iCuboid.resize(0, extent);
        }
      }
    }
  }
}

remove() [1/2]

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::remove

(

IndicatorF< T, D > &

indicatorF

)

Removes all cuboids where indicatorF = 0.

Definition at line 561 of file cuboidDecomposition.hh.

{
  std::vector<bool> allZero{};
  LatticeR<D+1> latticeR{};
  for (int iC = 0; iC < size(); iC++) {
    latticeR[0] = iC;
    allZero.push_back(true);
    for (int iX = 0; iX < _cuboids[iC].getNx(); iX++) {
      latticeR[1] = iX;
      for (int iY = 0; iY < _cuboids[iC].getNy(); iY++) {
        latticeR[2] = iY;
        if constexpr (D == 3) {
          for (int iZ = 0; iZ < _cuboids[iC].getNz(); iZ++) {
            latticeR[3] = iZ;
            auto physR = getPhysR(latticeR);
            bool inside[1];
            indicatorF(inside, physR.data());
            if (inside[0]) {
              allZero[iC] = 0;
            }
          }
        } else {
          auto physR = getPhysR(latticeR);
          bool inside[1];
          indicatorF(inside, physR.data());
          if (inside[0]) {
            allZero[iC] = 0;
          }
        }
      }
    }
  }
  for (int iC = _cuboids.size() - 1; iC >= 0; iC--) {
    if (allZero[iC]) {
      remove(iC);
    }
  }
}

References olb::Vector< T, Size >::data().

Here is the call graph for this function:

remove() [2/2]

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::remove

(

int

iC

)

Removes the cuboid iC.

Definition at line 555 of file cuboidDecomposition.hh.

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

Here is the caller graph for this function:

removeByWeight()

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::removeByWeight

(

)

Removes all cuboids where weight = 0.

Definition at line 601 of file cuboidDecomposition.hh.

{
  std::vector<bool> allZero(_cuboids.size(), false);
  for (unsigned iC = 0; iC < _cuboids.size(); iC++) {
    allZero[iC] = (_cuboids[iC].getWeight() == 0);
  }
  for (int iC = _cuboids.size() - 1; iC >= 0; iC--) {
    if (allZero[iC]) {
      remove(iC);
    }
  }
}

setPeriodicity()

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::setPeriodicity

(

Vector< bool, D >

periodicity

)

Set flag to enable/disable periodicity depending of direction. Be aware that not all directions are true to ensure boundary conditions like for velocity are not disturbed.

Definition at line 182 of file cuboidDecomposition.hh.

{
  _periodicityOn = periodicity;
}

setWeights()

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

void olb::CuboidDecomposition< T, D >::setWeights

(

IndicatorF< T, D > &

indicatorF

)

Sets the number of full cells of each cuboid.

Definition at line 946 of file cuboidDecomposition.hh.

{
  #ifdef PARALLEL_MODE_OMP
  #pragma omp parallel for schedule(dynamic,1)
  #endif
  for (int iC=0; iC < size(); ++iC) {
    int latticeR[4] { iC, 0, 0, 0 };
    int xN = get(iC).getNx();
    int yN = get(iC).getNy();
    int zN = get(iC).getNz();
    size_t fullCells = 0;
    for (int iX = 0; iX < xN; iX++) {
      for (int iY = 0; iY < yN; iY++) {
        for (int iZ = 0; iZ < zN; iZ++) {
          latticeR[1] = iX;
          latticeR[2] = iY;
          latticeR[3] = iZ;
          auto physR = getPhysR(latticeR);
          bool inside[1];
          indicatorF(inside,physR.data());
          if (inside[0]) {
            fullCells++;
          }
        }
      }
    }
    get(iC).setWeight(fullCells);
  }
}

References olb::Vector< T, Size >::data().

Here is the call graph for this function:

Here is the caller graph for this function:

shrink() [1/2]

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::shrink

(

IndicatorF< T, D > &

indicatorF

)

Shrink all cuboids so that no empty planes are left.

Definition at line 697 of file cuboidDecomposition.hh.

{
  for (int iC = size() - 1; iC >= 0; iC--) {
    shrink(iC, indicatorF);
  }
  // shrink mother cuboid
  Vector<T,D> minPhysR = getMinPhysR();
  Vector<T,D> maxPhysR = getMaxPhysR();
  T deltaR = getDeltaR();
  _motherCuboid = Cuboid<T,D>(minPhysR, deltaR, (maxPhysR - minPhysR) / deltaR + 0.5);
}

shrink() [2/2]

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::shrink	(	int	iC,
		IndicatorF< T, D > &	indicatorF )

Shrink cuboid iC so that no empty planes are left.

Definition at line 615 of file cuboidDecomposition.hh.

{
  if constexpr (D == 3) {
    LatticeR<D+1> latticeR{};
    bool inside[1] {};
 
    latticeR[0] = iC;
    std::size_t fullCells = 0;
    int xN = get(iC).getNx();
    int yN = get(iC).getNy();
    int zN = get(iC).getNz();
    int maxX = 0;
    int maxY = 0;
    int maxZ = 0;
    int newX = xN - 1;
    int newY = yN - 1;
    int newZ = zN - 1;
    for (int iX = 0; iX < xN; iX++) {
      for (int iY = 0; iY < yN; iY++) {
        for (int iZ = 0; iZ < zN; iZ++) {
          latticeR[1] = iX;
          latticeR[2] = iY;
          latticeR[3] = iZ;
          auto physR = getPhysR(latticeR);
          indicatorF(inside,physR.data());
          if (inside[0]) {
            fullCells++;
            maxX = util::max(maxX, iX);
            maxY = util::max(maxY, iY);
            maxZ = util::max(maxZ, iZ);
            newX = util::min(newX, iX);
            newY = util::min(newY, iY);
            newZ = util::min(newZ, iZ);
          }
        }
      }
    }
    if (fullCells > 0) {
      get(iC).setWeight(fullCells);
      _cuboids[iC].resize({newX, newY, newZ}, {maxX - newX + 1, maxY - newY + 1, maxZ - newZ + 1});
    }
    else {
      remove(iC);
    }
  } else {
    LatticeR<D+1> latticeR{};
    bool inside[1] {};
 
    latticeR[0] = iC;
    std::size_t fullCells = 0;
    int xN = get(iC).getNx();
    int yN = get(iC).getNy();
    int maxX = 0;
    int maxY = 0;
    int newX = xN - 1;
    int newY = yN - 1;
    for (int iX = 0; iX < xN; iX++) {
      for (int iY = 0; iY < yN; iY++) {
        latticeR[1] = iX;
        latticeR[2] = iY;
        auto physR = getPhysR(latticeR);
        indicatorF(inside,physR.data());
        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);
    }
  }
}

References olb::Vector< T, Size >::data(), olb::util::max(), and olb::util::min().

Here is the call graph for this function:

Here is the caller graph for this function:

size()

template<typename T , unsigned D>

int olb::CuboidDecomposition< T, D >::size

(

)

const

Returns number of cuboids in decomposition.

Definition at line 86 of file cuboidDecomposition.hh.

                                         {
  OLB_PRECONDITION(_cuboids.size() < std::numeric_limits<int>::max());
  return static_cast<int>(_cuboids.size());
}

References OLB_PRECONDITION.

Here is the caller graph for this function:

split()

template<typename T , unsigned D>

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

Splits cuboid iC, removes it and adds p cuboids of same volume.

Definition at line 748 of file cuboidDecomposition.hh.

{
  Cuboid<T,D> temp(_cuboids[iC]);
  temp.divideP(p, _cuboids);
  remove(iC);
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

splitByWeight()

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

void olb::CuboidDecomposition< T, D >::splitByWeight	(	int	iC,
		int	p,
		IndicatorF< T, D > &	indicatorF )

Splits cuboid iC, removes it and adds p cuboids of same weight.

Definition at line 767 of file cuboidDecomposition.hh.

{
  T averageWeight = get(iC).getWeight() / (T) p;
  Cuboid<T,D> temp(_cuboids[iC]);
 
  int latticeR[4];
  latticeR[0] = iC;
  int xN = get(iC).getNx();
  int yN = get(iC).getNy();
  int zN = get(iC).getNz();
  T deltaR = get(iC).getDeltaR();
  int fullCells = 0;
 
  Vector<T, 3> globPos_child = get(iC).getOrigin();
  std::vector<int> extend_child = {xN, yN, zN};
  int localPos_child = 0;
 
  // looking for largest extend, because halfing the cuboid by its largest extend will result in the smallest surface and therfore in the least comminication cells
  if ( get(iC).getNx() >= get(iC).getNy() && get(iC).getNx() >= get(iC).getNz()) {
    // clout << "Cut in x direction!" << std::endl;
 
    // for each child cuboid search for the optimal cutting plane
    for ( int iChild = 0; iChild < p - 1; iChild++) {
      fullCells = 0;
      int fullCells_minusOne = 0;
 
      for (int iX = localPos_child; iX < xN; iX++) {
        fullCells_minusOne = fullCells;
        for (int iY = 0; iY < yN; iY++) {
          for (int iZ = 0; iZ < zN; iZ++) {
            latticeR[1] = iX;
            latticeR[2] = iY;
            latticeR[3] = iZ;
            auto physR = getPhysR(latticeR);
            bool inside[1];
            indicatorF(inside,physR.data());
            if (inside[0]) {
              fullCells++;
            }
          }
        }
        // the optimal cutting plane is determined, so that the child cuboid's cells inside the indicator are the closest to the total cells inside the indicator per number of children
        if ( fullCells >= averageWeight ) {
          if ( (fullCells - averageWeight) > (averageWeight - fullCells_minusOne) ) {
            iX--;
          }
          // clout << "found optimal iX = " << iX << std::endl;
          extend_child[0] = iX - localPos_child + 1;
 
          Cuboid<T,D> child(globPos_child, deltaR, extend_child);
          _cuboids.push_back(child);
 
          globPos_child[0] += extend_child[0]*deltaR;
          localPos_child += extend_child[0] + 1;
          // clout << "added child " << iChild << " of " << p << std::endl;
 
          break;
        }
      }
 
    }
 
    extend_child[0] = xN - localPos_child + p - 1;
 
    Cuboid<T,D> child(globPos_child, deltaR, extend_child);
    _cuboids.push_back(child);
 
    // clout << "added last child of " << p << std::endl;
 
  }
  else if ( get(iC).getNy() >= get(iC).getNx() && get(iC).getNy() >= get(iC).getNz()) {
    // clout << "Cut in y direction!" << std::endl;
 
    for ( int iChild = 0; iChild < p - 1; iChild++) {
      fullCells = 0;
      int fullCells_minusOne = 0;
 
      for (int iY = localPos_child; iY < yN; iY++) {
        fullCells_minusOne = fullCells;
        for (int iX = 0; iX < xN; iX++) {
          for (int iZ = 0; iZ < zN; iZ++) {
            latticeR[1] = iX;
            latticeR[2] = iY;
            latticeR[3] = iZ;
            auto physR = getPhysR(latticeR);
            bool inside[1];
            indicatorF(inside,physR.data());
            if (inside[0]) {
              fullCells++;
            }
          }
        }
        if ( fullCells >= averageWeight ) {
          if ( (fullCells - averageWeight) > (averageWeight - fullCells_minusOne) ) {
            iY--;
          }
          // clout << "found optimal iY = " << iY << std::endl;
          extend_child[1] = iY - localPos_child + 1;
 
          Cuboid<T,D> child(globPos_child, deltaR, extend_child);
          _cuboids.push_back(child);
 
          globPos_child[1] += extend_child[1]*deltaR;
          localPos_child += extend_child[1] + 1;
          // clout << "added child " << iChild << " of " << p << std::endl;
 
          break;
        }
      }
 
    }
 
    extend_child[1] = yN - localPos_child + p - 1;
 
    Cuboid<T,D> child(globPos_child, deltaR, extend_child);
    _cuboids.push_back(child);
 
    // clout << "added last child of " << p << std::endl;
  }
  else {
    // clout << "Cut in z direction!" << std::endl;
 
    for ( int iChild = 0; iChild < p - 1; iChild++) {
      fullCells = 0;
      int fullCells_minusOne = 0;
 
      for (int iZ = localPos_child; iZ < zN; iZ++) {
        fullCells_minusOne = fullCells;
        for (int iY = 0; iY < yN; iY++) {
          for (int iX = 0; iX < xN; iX++) {
            latticeR[1] = iX;
            latticeR[2] = iY;
            latticeR[3] = iZ;
            auto physR = getPhysR(latticeR);
            bool inside[1];
            indicatorF(inside,physR.data());
            if (inside[0]) {
              fullCells++;
            }
          }
        }
        if ( fullCells >= averageWeight ) {
          if ( (fullCells - averageWeight) > (averageWeight - fullCells_minusOne) ) {
            iZ--;
          }
          // clout << "found optimal iZ = " << iZ << std::endl;
          extend_child[2] = iZ - localPos_child + 1;
 
          Cuboid<T,D> child(globPos_child, deltaR, extend_child);
          _cuboids.push_back(child);
 
          globPos_child[2] += extend_child[2]*deltaR;
          localPos_child += extend_child[2] + 1;
          // clout << "added child " << iChild << " of " << p << std::endl;
 
          break;
        }
      }
 
    }
 
    extend_child[2] = zN - localPos_child + p - 1;
 
    Cuboid<T,D> child(globPos_child, deltaR, extend_child);
    _cuboids.push_back(child);
 
    // clout << "added last child of " << p << std::endl;
  }
}

References olb::Vector< T, Size >::data().

Here is the call graph for this function:

Here is the caller graph for this function:

splitFractional()

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::splitFractional	(	int	iC,
		int	iD,
		std::vector< T >	fractions )

Splits cuboid iC along dimension iD into cuboids of fractions.

Definition at line 938 of file cuboidDecomposition.hh.

{
  Cuboid<T,D> tmp = _cuboids[iC];
  tmp.divideFractional(iD, fractions, _cuboids);
  remove(iC);
}

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

Here is the call graph for this function:

splitRegular()

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::splitRegular	(	int	iC,
		int	width )

Splits cuboid iC, removes it, adds approx. width^3 sized new cuboids.

Definition at line 756 of file cuboidDecomposition.hh.

{
  Cuboid<T,D> temp(_cuboids[iC]);
  const int p = std::max(1, temp.getNx() / width);
  const int q = std::max(1, temp.getNy() / width);
  const int r = std::max(1, temp.getNz() / width);
  temp.divide({p, q, r}, _cuboids);
  remove(iC);
}

References olb::Cuboid< T, D >::divide(), olb::Cuboid< T, D >::getNx(), olb::Cuboid< T, D >::getNy(), and olb::Cuboid< T, D >::getNz().

Here is the call graph for this function:

tryRefineTo()

template<typename T , unsigned D>

bool olb::CuboidDecomposition< T, D >::tryRefineTo

(

T

deltaR

)

Tries to refine mesh to given deltaR.

Definition at line 734 of file cuboidDecomposition.hh.

{
  const T tolerance = std::numeric_limits<T>::epsilon();
  const T currDeltaR = _motherCuboid.getDeltaR();
  const int factor = std::ceil(currDeltaR / goalDeltaR);
  if (util::fabs(currDeltaR / factor - goalDeltaR) < tolerance) {
    refine(factor);
    return true;
  } else {
    return false;
  }
}

References olb::util::fabs().

Here is the call graph for this function:

writeToExistingFile()

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::writeToExistingFile	(	std::string	completeFileName,
		LoadBalancer< T > &	loadBalancer )

Save CuboidDecomposition into an existing XML File.

Definition at line 1006 of file cuboidDecomposition.hh.

{
  OstreamManager clout(std::cout, "CuboidDecomposition");
  std::ofstream fout;
  fout.flags(std::ios::scientific);
  fout.precision (std::numeric_limits<double>::digits10 + 1);
  if ( singleton::mpi().isMainProcessor() ) {
 
    // Open File
    fout.open(completeFileName.c_str(), std::ios::app);
    if (!fout) {
      clout << "Error: could not open " << completeFileName << std::endl;
    }
 
    // --- Preamble --- //
    fout << "<CuboidDecomposition dimension=\"3\" ";
    getMotherCuboid().writeAsXML(fout);
    fout << ">\n";
 
    // TODO: Move Cuboid XML Serialization to Cuboid3D class
    for (int iC = 0; iC < size(); ++iC) {
      fout << "<Cuboid ";
      get(iC).writeAsXML(fout);
      fout << " />\n";
    }
 
    fout << "</CuboidDecomposition>\n";
 
    fout.close();
  }
}

References olb::singleton::mpi().

Here is the call graph for this function:

writeToFile()

template<typename T , unsigned D>

void olb::CuboidDecomposition< T, D >::writeToFile	(	std::string	fileName,
		LoadBalancer< T > &	loadBalancer )

Save CuboidDecomposition into XML File.

Definition at line 1040 of file cuboidDecomposition.hh.

{
  std::string fname = singleton::directories().getLogOutDir() + fileName + ".xml";
  std::ofstream fout;
  if (singleton::mpi().isMainProcessor()) {
    fout.open(fname.c_str(), std::ios::trunc);
    fout << "<?xml version=\"1.0\"?>\n";
    fout << "<XMLContent>\n";
    fout.close();
    fout.clear();
  }
 
  writeToExistingFile(fname, loadBalancer);
 
  if (singleton::mpi().isMainProcessor()) {
    fout.open(fname.c_str(), std::ios::app);
    fout << "</XMLContent>\n";
    fout.close();
  }
}

References olb::singleton::directories(), olb::singleton::Directories::getLogOutDir(), and olb::singleton::mpi().

Here is the call graph for this function:

---

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

• src/geometry/cuboidDecomposition.h
• src/geometry/cuboidDecompositionMinimizer.h
• src/geometry/cuboidDecomposition.hh